1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "AudioTrackShared"
18 //#define LOG_NDEBUG 0
19
20 #include <private/media/AudioTrackShared.h>
21 #include <utils/Log.h>
22
23 #include <linux/futex.h>
24 #include <sys/syscall.h>
25
26 namespace android {
27
28 // used to clamp a value to size_t. TODO: move to another file.
29 template <typename T>
clampToSize(T x)30 size_t clampToSize(T x) {
31 return sizeof(T) > sizeof(size_t) && x > (T) SIZE_MAX ? SIZE_MAX : x < 0 ? 0 : (size_t) x;
32 }
33
34 // incrementSequence is used to determine the next sequence value
35 // for the loop and position sequence counters. It should return
36 // a value between "other" + 1 and "other" + INT32_MAX, the choice of
37 // which needs to be the "least recently used" sequence value for "self".
38 // In general, this means (new_self) returned is max(self, other) + 1.
39
incrementSequence(uint32_t self,uint32_t other)40 static uint32_t incrementSequence(uint32_t self, uint32_t other) {
41 int32_t diff = (int32_t) self - (int32_t) other;
42 if (diff >= 0 && diff < INT32_MAX) {
43 return self + 1; // we're already ahead of other.
44 }
45 return other + 1; // we're behind, so move just ahead of other.
46 }
47
audio_track_cblk_t()48 audio_track_cblk_t::audio_track_cblk_t()
49 : mServer(0), mFutex(0), mMinimum(0)
50 , mVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY), mSampleRate(0), mSendLevel(0)
51 , mBufferSizeInFrames(0)
52 , mFlags(0)
53 {
54 memset(&u, 0, sizeof(u));
55 }
56
57 // ---------------------------------------------------------------------------
58
Proxy(audio_track_cblk_t * cblk,void * buffers,size_t frameCount,size_t frameSize,bool isOut,bool clientInServer)59 Proxy::Proxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount, size_t frameSize,
60 bool isOut, bool clientInServer)
61 : mCblk(cblk), mBuffers(buffers), mFrameCount(frameCount), mFrameSize(frameSize),
62 mFrameCountP2(roundup(frameCount)), mIsOut(isOut), mClientInServer(clientInServer),
63 mIsShutdown(false), mUnreleased(0)
64 {
65 }
66
67 // ---------------------------------------------------------------------------
68
ClientProxy(audio_track_cblk_t * cblk,void * buffers,size_t frameCount,size_t frameSize,bool isOut,bool clientInServer)69 ClientProxy::ClientProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
70 size_t frameSize, bool isOut, bool clientInServer)
71 : Proxy(cblk, buffers, frameCount, frameSize, isOut, clientInServer)
72 , mEpoch(0)
73 , mTimestampObserver(&cblk->mExtendedTimestampQueue)
74 {
75 setBufferSizeInFrames(frameCount);
76 }
77
78 const struct timespec ClientProxy::kForever = {INT_MAX /*tv_sec*/, 0 /*tv_nsec*/};
79 const struct timespec ClientProxy::kNonBlocking = {0 /*tv_sec*/, 0 /*tv_nsec*/};
80
81 #define MEASURE_NS 10000000 // attempt to provide accurate timeouts if requested >= MEASURE_NS
82
83 // To facilitate quicker recovery from server failure, this value limits the timeout per each futex
84 // wait. However it does not protect infinite timeouts. If defined to be zero, there is no limit.
85 // FIXME May not be compatible with audio tunneling requirements where timeout should be in the
86 // order of minutes.
87 #define MAX_SEC 5
88
setBufferSizeInFrames(uint32_t size)89 uint32_t ClientProxy::setBufferSizeInFrames(uint32_t size)
90 {
91 // The minimum should be greater than zero and less than the size
92 // at which underruns will occur.
93 const uint32_t minimum = 16; // based on AudioMixer::BLOCKSIZE
94 const uint32_t maximum = frameCount();
95 uint32_t clippedSize = size;
96 if (maximum < minimum) {
97 clippedSize = maximum;
98 } else if (clippedSize < minimum) {
99 clippedSize = minimum;
100 } else if (clippedSize > maximum) {
101 clippedSize = maximum;
102 }
103 // for server to read
104 android_atomic_release_store(clippedSize, (int32_t *)&mCblk->mBufferSizeInFrames);
105 // for client to read
106 mBufferSizeInFrames = clippedSize;
107 return clippedSize;
108 }
109
110 __attribute__((no_sanitize("integer")))
obtainBuffer(Buffer * buffer,const struct timespec * requested,struct timespec * elapsed)111 status_t ClientProxy::obtainBuffer(Buffer* buffer, const struct timespec *requested,
112 struct timespec *elapsed)
113 {
114 LOG_ALWAYS_FATAL_IF(buffer == NULL || buffer->mFrameCount == 0);
115 struct timespec total; // total elapsed time spent waiting
116 total.tv_sec = 0;
117 total.tv_nsec = 0;
118 bool measure = elapsed != NULL; // whether to measure total elapsed time spent waiting
119
120 status_t status;
121 enum {
122 TIMEOUT_ZERO, // requested == NULL || *requested == 0
123 TIMEOUT_INFINITE, // *requested == infinity
124 TIMEOUT_FINITE, // 0 < *requested < infinity
125 TIMEOUT_CONTINUE, // additional chances after TIMEOUT_FINITE
126 } timeout;
127 if (requested == NULL) {
128 timeout = TIMEOUT_ZERO;
129 } else if (requested->tv_sec == 0 && requested->tv_nsec == 0) {
130 timeout = TIMEOUT_ZERO;
131 } else if (requested->tv_sec == INT_MAX) {
132 timeout = TIMEOUT_INFINITE;
133 } else {
134 timeout = TIMEOUT_FINITE;
135 if (requested->tv_sec > 0 || requested->tv_nsec >= MEASURE_NS) {
136 measure = true;
137 }
138 }
139 struct timespec before;
140 bool beforeIsValid = false;
141 audio_track_cblk_t* cblk = mCblk;
142 bool ignoreInitialPendingInterrupt = true;
143 // check for shared memory corruption
144 if (mIsShutdown) {
145 status = NO_INIT;
146 goto end;
147 }
148 for (;;) {
149 int32_t flags = android_atomic_and(~CBLK_INTERRUPT, &cblk->mFlags);
150 // check for track invalidation by server, or server death detection
151 if (flags & CBLK_INVALID) {
152 ALOGV("Track invalidated");
153 status = DEAD_OBJECT;
154 goto end;
155 }
156 if (flags & CBLK_DISABLED) {
157 ALOGV("Track disabled");
158 status = NOT_ENOUGH_DATA;
159 goto end;
160 }
161 // check for obtainBuffer interrupted by client
162 if (!ignoreInitialPendingInterrupt && (flags & CBLK_INTERRUPT)) {
163 ALOGV("obtainBuffer() interrupted by client");
164 status = -EINTR;
165 goto end;
166 }
167 ignoreInitialPendingInterrupt = false;
168 // compute number of frames available to write (AudioTrack) or read (AudioRecord)
169 int32_t front;
170 int32_t rear;
171 if (mIsOut) {
172 // The barrier following the read of mFront is probably redundant.
173 // We're about to perform a conditional branch based on 'filled',
174 // which will force the processor to observe the read of mFront
175 // prior to allowing data writes starting at mRaw.
176 // However, the processor may support speculative execution,
177 // and be unable to undo speculative writes into shared memory.
178 // The barrier will prevent such speculative execution.
179 front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront);
180 rear = cblk->u.mStreaming.mRear;
181 } else {
182 // On the other hand, this barrier is required.
183 rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
184 front = cblk->u.mStreaming.mFront;
185 }
186 // write to rear, read from front
187 ssize_t filled = rear - front;
188 // pipe should not be overfull
189 if (!(0 <= filled && (size_t) filled <= mFrameCount)) {
190 if (mIsOut) {
191 ALOGE("Shared memory control block is corrupt (filled=%zd, mFrameCount=%zu); "
192 "shutting down", filled, mFrameCount);
193 mIsShutdown = true;
194 status = NO_INIT;
195 goto end;
196 }
197 // for input, sync up on overrun
198 filled = 0;
199 cblk->u.mStreaming.mFront = rear;
200 (void) android_atomic_or(CBLK_OVERRUN, &cblk->mFlags);
201 }
202 // Don't allow filling pipe beyond the user settable size.
203 // The calculation for avail can go negative if the buffer size
204 // is suddenly dropped below the amount already in the buffer.
205 // So use a signed calculation to prevent a numeric overflow abort.
206 ssize_t adjustableSize = (ssize_t) getBufferSizeInFrames();
207 ssize_t avail = (mIsOut) ? adjustableSize - filled : filled;
208 if (avail < 0) {
209 avail = 0;
210 } else if (avail > 0) {
211 // 'avail' may be non-contiguous, so return only the first contiguous chunk
212 size_t part1;
213 if (mIsOut) {
214 rear &= mFrameCountP2 - 1;
215 part1 = mFrameCountP2 - rear;
216 } else {
217 front &= mFrameCountP2 - 1;
218 part1 = mFrameCountP2 - front;
219 }
220 if (part1 > (size_t)avail) {
221 part1 = avail;
222 }
223 if (part1 > buffer->mFrameCount) {
224 part1 = buffer->mFrameCount;
225 }
226 buffer->mFrameCount = part1;
227 buffer->mRaw = part1 > 0 ?
228 &((char *) mBuffers)[(mIsOut ? rear : front) * mFrameSize] : NULL;
229 buffer->mNonContig = avail - part1;
230 mUnreleased = part1;
231 status = NO_ERROR;
232 break;
233 }
234 struct timespec remaining;
235 const struct timespec *ts;
236 switch (timeout) {
237 case TIMEOUT_ZERO:
238 status = WOULD_BLOCK;
239 goto end;
240 case TIMEOUT_INFINITE:
241 ts = NULL;
242 break;
243 case TIMEOUT_FINITE:
244 timeout = TIMEOUT_CONTINUE;
245 if (MAX_SEC == 0) {
246 ts = requested;
247 break;
248 }
249 // fall through
250 case TIMEOUT_CONTINUE:
251 // FIXME we do not retry if requested < 10ms? needs documentation on this state machine
252 if (!measure || requested->tv_sec < total.tv_sec ||
253 (requested->tv_sec == total.tv_sec && requested->tv_nsec <= total.tv_nsec)) {
254 status = TIMED_OUT;
255 goto end;
256 }
257 remaining.tv_sec = requested->tv_sec - total.tv_sec;
258 if ((remaining.tv_nsec = requested->tv_nsec - total.tv_nsec) < 0) {
259 remaining.tv_nsec += 1000000000;
260 remaining.tv_sec++;
261 }
262 if (0 < MAX_SEC && MAX_SEC < remaining.tv_sec) {
263 remaining.tv_sec = MAX_SEC;
264 remaining.tv_nsec = 0;
265 }
266 ts = &remaining;
267 break;
268 default:
269 LOG_ALWAYS_FATAL("obtainBuffer() timeout=%d", timeout);
270 ts = NULL;
271 break;
272 }
273 int32_t old = android_atomic_and(~CBLK_FUTEX_WAKE, &cblk->mFutex);
274 if (!(old & CBLK_FUTEX_WAKE)) {
275 if (measure && !beforeIsValid) {
276 clock_gettime(CLOCK_MONOTONIC, &before);
277 beforeIsValid = true;
278 }
279 errno = 0;
280 (void) syscall(__NR_futex, &cblk->mFutex,
281 mClientInServer ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT, old & ~CBLK_FUTEX_WAKE, ts);
282 status_t error = errno; // clock_gettime can affect errno
283 // update total elapsed time spent waiting
284 if (measure) {
285 struct timespec after;
286 clock_gettime(CLOCK_MONOTONIC, &after);
287 total.tv_sec += after.tv_sec - before.tv_sec;
288 long deltaNs = after.tv_nsec - before.tv_nsec;
289 if (deltaNs < 0) {
290 deltaNs += 1000000000;
291 total.tv_sec--;
292 }
293 if ((total.tv_nsec += deltaNs) >= 1000000000) {
294 total.tv_nsec -= 1000000000;
295 total.tv_sec++;
296 }
297 before = after;
298 beforeIsValid = true;
299 }
300 switch (error) {
301 case 0: // normal wakeup by server, or by binderDied()
302 case EWOULDBLOCK: // benign race condition with server
303 case EINTR: // wait was interrupted by signal or other spurious wakeup
304 case ETIMEDOUT: // time-out expired
305 // FIXME these error/non-0 status are being dropped
306 break;
307 default:
308 status = error;
309 ALOGE("%s unexpected error %s", __func__, strerror(status));
310 goto end;
311 }
312 }
313 }
314
315 end:
316 if (status != NO_ERROR) {
317 buffer->mFrameCount = 0;
318 buffer->mRaw = NULL;
319 buffer->mNonContig = 0;
320 mUnreleased = 0;
321 }
322 if (elapsed != NULL) {
323 *elapsed = total;
324 }
325 if (requested == NULL) {
326 requested = &kNonBlocking;
327 }
328 if (measure) {
329 ALOGV("requested %ld.%03ld elapsed %ld.%03ld",
330 requested->tv_sec, requested->tv_nsec / 1000000,
331 total.tv_sec, total.tv_nsec / 1000000);
332 }
333 return status;
334 }
335
336 __attribute__((no_sanitize("integer")))
releaseBuffer(Buffer * buffer)337 void ClientProxy::releaseBuffer(Buffer* buffer)
338 {
339 LOG_ALWAYS_FATAL_IF(buffer == NULL);
340 size_t stepCount = buffer->mFrameCount;
341 if (stepCount == 0 || mIsShutdown) {
342 // prevent accidental re-use of buffer
343 buffer->mFrameCount = 0;
344 buffer->mRaw = NULL;
345 buffer->mNonContig = 0;
346 return;
347 }
348 LOG_ALWAYS_FATAL_IF(!(stepCount <= mUnreleased && mUnreleased <= mFrameCount));
349 mUnreleased -= stepCount;
350 audio_track_cblk_t* cblk = mCblk;
351 // Both of these barriers are required
352 if (mIsOut) {
353 int32_t rear = cblk->u.mStreaming.mRear;
354 android_atomic_release_store(stepCount + rear, &cblk->u.mStreaming.mRear);
355 } else {
356 int32_t front = cblk->u.mStreaming.mFront;
357 android_atomic_release_store(stepCount + front, &cblk->u.mStreaming.mFront);
358 }
359 }
360
binderDied()361 void ClientProxy::binderDied()
362 {
363 audio_track_cblk_t* cblk = mCblk;
364 if (!(android_atomic_or(CBLK_INVALID, &cblk->mFlags) & CBLK_INVALID)) {
365 android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex);
366 // it seems that a FUTEX_WAKE_PRIVATE will not wake a FUTEX_WAIT, even within same process
367 (void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE,
368 1);
369 }
370 }
371
interrupt()372 void ClientProxy::interrupt()
373 {
374 audio_track_cblk_t* cblk = mCblk;
375 if (!(android_atomic_or(CBLK_INTERRUPT, &cblk->mFlags) & CBLK_INTERRUPT)) {
376 android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex);
377 (void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE,
378 1);
379 }
380 }
381
382 __attribute__((no_sanitize("integer")))
getMisalignment()383 size_t ClientProxy::getMisalignment()
384 {
385 audio_track_cblk_t* cblk = mCblk;
386 return (mFrameCountP2 - (mIsOut ? cblk->u.mStreaming.mRear : cblk->u.mStreaming.mFront)) &
387 (mFrameCountP2 - 1);
388 }
389
390 // ---------------------------------------------------------------------------
391
flush()392 void AudioTrackClientProxy::flush()
393 {
394 // This works for mFrameCountP2 <= 2^30
395 size_t increment = mFrameCountP2 << 1;
396 size_t mask = increment - 1;
397 audio_track_cblk_t* cblk = mCblk;
398 // mFlush is 32 bits concatenated as [ flush_counter ] [ newfront_offset ]
399 // Should newFlush = cblk->u.mStreaming.mRear? Only problem is
400 // if you want to flush twice to the same rear location after a 32 bit wrap.
401 int32_t newFlush = (cblk->u.mStreaming.mRear & mask) |
402 ((cblk->u.mStreaming.mFlush & ~mask) + increment);
403 android_atomic_release_store(newFlush, &cblk->u.mStreaming.mFlush);
404 }
405
clearStreamEndDone()406 bool AudioTrackClientProxy::clearStreamEndDone() {
407 return (android_atomic_and(~CBLK_STREAM_END_DONE, &mCblk->mFlags) & CBLK_STREAM_END_DONE) != 0;
408 }
409
getStreamEndDone() const410 bool AudioTrackClientProxy::getStreamEndDone() const {
411 return (mCblk->mFlags & CBLK_STREAM_END_DONE) != 0;
412 }
413
waitStreamEndDone(const struct timespec * requested)414 status_t AudioTrackClientProxy::waitStreamEndDone(const struct timespec *requested)
415 {
416 struct timespec total; // total elapsed time spent waiting
417 total.tv_sec = 0;
418 total.tv_nsec = 0;
419 audio_track_cblk_t* cblk = mCblk;
420 status_t status;
421 enum {
422 TIMEOUT_ZERO, // requested == NULL || *requested == 0
423 TIMEOUT_INFINITE, // *requested == infinity
424 TIMEOUT_FINITE, // 0 < *requested < infinity
425 TIMEOUT_CONTINUE, // additional chances after TIMEOUT_FINITE
426 } timeout;
427 if (requested == NULL) {
428 timeout = TIMEOUT_ZERO;
429 } else if (requested->tv_sec == 0 && requested->tv_nsec == 0) {
430 timeout = TIMEOUT_ZERO;
431 } else if (requested->tv_sec == INT_MAX) {
432 timeout = TIMEOUT_INFINITE;
433 } else {
434 timeout = TIMEOUT_FINITE;
435 }
436 for (;;) {
437 int32_t flags = android_atomic_and(~(CBLK_INTERRUPT|CBLK_STREAM_END_DONE), &cblk->mFlags);
438 // check for track invalidation by server, or server death detection
439 if (flags & CBLK_INVALID) {
440 ALOGV("Track invalidated");
441 status = DEAD_OBJECT;
442 goto end;
443 }
444 // a track is not supposed to underrun at this stage but consider it done
445 if (flags & (CBLK_STREAM_END_DONE | CBLK_DISABLED)) {
446 ALOGV("stream end received");
447 status = NO_ERROR;
448 goto end;
449 }
450 // check for obtainBuffer interrupted by client
451 if (flags & CBLK_INTERRUPT) {
452 ALOGV("waitStreamEndDone() interrupted by client");
453 status = -EINTR;
454 goto end;
455 }
456 struct timespec remaining;
457 const struct timespec *ts;
458 switch (timeout) {
459 case TIMEOUT_ZERO:
460 status = WOULD_BLOCK;
461 goto end;
462 case TIMEOUT_INFINITE:
463 ts = NULL;
464 break;
465 case TIMEOUT_FINITE:
466 timeout = TIMEOUT_CONTINUE;
467 if (MAX_SEC == 0) {
468 ts = requested;
469 break;
470 }
471 // fall through
472 case TIMEOUT_CONTINUE:
473 // FIXME we do not retry if requested < 10ms? needs documentation on this state machine
474 if (requested->tv_sec < total.tv_sec ||
475 (requested->tv_sec == total.tv_sec && requested->tv_nsec <= total.tv_nsec)) {
476 status = TIMED_OUT;
477 goto end;
478 }
479 remaining.tv_sec = requested->tv_sec - total.tv_sec;
480 if ((remaining.tv_nsec = requested->tv_nsec - total.tv_nsec) < 0) {
481 remaining.tv_nsec += 1000000000;
482 remaining.tv_sec++;
483 }
484 if (0 < MAX_SEC && MAX_SEC < remaining.tv_sec) {
485 remaining.tv_sec = MAX_SEC;
486 remaining.tv_nsec = 0;
487 }
488 ts = &remaining;
489 break;
490 default:
491 LOG_ALWAYS_FATAL("waitStreamEndDone() timeout=%d", timeout);
492 ts = NULL;
493 break;
494 }
495 int32_t old = android_atomic_and(~CBLK_FUTEX_WAKE, &cblk->mFutex);
496 if (!(old & CBLK_FUTEX_WAKE)) {
497 errno = 0;
498 (void) syscall(__NR_futex, &cblk->mFutex,
499 mClientInServer ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT, old & ~CBLK_FUTEX_WAKE, ts);
500 switch (errno) {
501 case 0: // normal wakeup by server, or by binderDied()
502 case EWOULDBLOCK: // benign race condition with server
503 case EINTR: // wait was interrupted by signal or other spurious wakeup
504 case ETIMEDOUT: // time-out expired
505 break;
506 default:
507 status = errno;
508 ALOGE("%s unexpected error %s", __func__, strerror(status));
509 goto end;
510 }
511 }
512 }
513
514 end:
515 if (requested == NULL) {
516 requested = &kNonBlocking;
517 }
518 return status;
519 }
520
521 // ---------------------------------------------------------------------------
522
StaticAudioTrackClientProxy(audio_track_cblk_t * cblk,void * buffers,size_t frameCount,size_t frameSize)523 StaticAudioTrackClientProxy::StaticAudioTrackClientProxy(audio_track_cblk_t* cblk, void *buffers,
524 size_t frameCount, size_t frameSize)
525 : AudioTrackClientProxy(cblk, buffers, frameCount, frameSize),
526 mMutator(&cblk->u.mStatic.mSingleStateQueue),
527 mPosLoopObserver(&cblk->u.mStatic.mPosLoopQueue)
528 {
529 memset(&mState, 0, sizeof(mState));
530 memset(&mPosLoop, 0, sizeof(mPosLoop));
531 }
532
flush()533 void StaticAudioTrackClientProxy::flush()
534 {
535 LOG_ALWAYS_FATAL("static flush");
536 }
537
setLoop(size_t loopStart,size_t loopEnd,int loopCount)538 void StaticAudioTrackClientProxy::setLoop(size_t loopStart, size_t loopEnd, int loopCount)
539 {
540 // This can only happen on a 64-bit client
541 if (loopStart > UINT32_MAX || loopEnd > UINT32_MAX) {
542 // FIXME Should return an error status
543 return;
544 }
545 mState.mLoopStart = (uint32_t) loopStart;
546 mState.mLoopEnd = (uint32_t) loopEnd;
547 mState.mLoopCount = loopCount;
548 mState.mLoopSequence = incrementSequence(mState.mLoopSequence, mState.mPositionSequence);
549 // set patch-up variables until the mState is acknowledged by the ServerProxy.
550 // observed buffer position and loop count will freeze until then to give the
551 // illusion of a synchronous change.
552 getBufferPositionAndLoopCount(NULL, NULL);
553 // preserve behavior to restart at mState.mLoopStart if position exceeds mState.mLoopEnd.
554 if (mState.mLoopCount != 0 && mPosLoop.mBufferPosition >= mState.mLoopEnd) {
555 mPosLoop.mBufferPosition = mState.mLoopStart;
556 }
557 mPosLoop.mLoopCount = mState.mLoopCount;
558 (void) mMutator.push(mState);
559 }
560
setBufferPosition(size_t position)561 void StaticAudioTrackClientProxy::setBufferPosition(size_t position)
562 {
563 // This can only happen on a 64-bit client
564 if (position > UINT32_MAX) {
565 // FIXME Should return an error status
566 return;
567 }
568 mState.mPosition = (uint32_t) position;
569 mState.mPositionSequence = incrementSequence(mState.mPositionSequence, mState.mLoopSequence);
570 // set patch-up variables until the mState is acknowledged by the ServerProxy.
571 // observed buffer position and loop count will freeze until then to give the
572 // illusion of a synchronous change.
573 if (mState.mLoopCount > 0) { // only check if loop count is changing
574 getBufferPositionAndLoopCount(NULL, NULL); // get last position
575 }
576 mPosLoop.mBufferPosition = position;
577 if (position >= mState.mLoopEnd) {
578 // no ongoing loop is possible if position is greater than loopEnd.
579 mPosLoop.mLoopCount = 0;
580 }
581 (void) mMutator.push(mState);
582 }
583
setBufferPositionAndLoop(size_t position,size_t loopStart,size_t loopEnd,int loopCount)584 void StaticAudioTrackClientProxy::setBufferPositionAndLoop(size_t position, size_t loopStart,
585 size_t loopEnd, int loopCount)
586 {
587 setLoop(loopStart, loopEnd, loopCount);
588 setBufferPosition(position);
589 }
590
getBufferPosition()591 size_t StaticAudioTrackClientProxy::getBufferPosition()
592 {
593 getBufferPositionAndLoopCount(NULL, NULL);
594 return mPosLoop.mBufferPosition;
595 }
596
getBufferPositionAndLoopCount(size_t * position,int * loopCount)597 void StaticAudioTrackClientProxy::getBufferPositionAndLoopCount(
598 size_t *position, int *loopCount)
599 {
600 if (mMutator.ack() == StaticAudioTrackSingleStateQueue::SSQ_DONE) {
601 if (mPosLoopObserver.poll(mPosLoop)) {
602 ; // a valid mPosLoop should be available if ackDone is true.
603 }
604 }
605 if (position != NULL) {
606 *position = mPosLoop.mBufferPosition;
607 }
608 if (loopCount != NULL) {
609 *loopCount = mPosLoop.mLoopCount;
610 }
611 }
612
613 // ---------------------------------------------------------------------------
614
ServerProxy(audio_track_cblk_t * cblk,void * buffers,size_t frameCount,size_t frameSize,bool isOut,bool clientInServer)615 ServerProxy::ServerProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
616 size_t frameSize, bool isOut, bool clientInServer)
617 : Proxy(cblk, buffers, frameCount, frameSize, isOut, clientInServer),
618 mAvailToClient(0), mFlush(0), mReleased(0), mFlushed(0)
619 , mTimestampMutator(&cblk->mExtendedTimestampQueue)
620 {
621 cblk->mBufferSizeInFrames = frameCount;
622 }
623
624 __attribute__((no_sanitize("integer")))
flushBufferIfNeeded()625 void ServerProxy::flushBufferIfNeeded()
626 {
627 audio_track_cblk_t* cblk = mCblk;
628 // The acquire_load is not really required. But since the write is a release_store in the
629 // client, using acquire_load here makes it easier for people to maintain the code,
630 // and the logic for communicating ipc variables seems somewhat standard,
631 // and there really isn't much penalty for 4 or 8 byte atomics.
632 int32_t flush = android_atomic_acquire_load(&cblk->u.mStreaming.mFlush);
633 if (flush != mFlush) {
634 ALOGV("ServerProxy::flushBufferIfNeeded() mStreaming.mFlush = 0x%x, mFlush = 0x%0x",
635 flush, mFlush);
636 int32_t rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
637 int32_t front = cblk->u.mStreaming.mFront;
638
639 // effectively obtain then release whatever is in the buffer
640 const size_t overflowBit = mFrameCountP2 << 1;
641 const size_t mask = overflowBit - 1;
642 int32_t newFront = (front & ~mask) | (flush & mask);
643 ssize_t filled = rear - newFront;
644 if (filled >= (ssize_t)overflowBit) {
645 // front and rear offsets span the overflow bit of the p2 mask
646 // so rebasing newFront on the front offset is off by the overflow bit.
647 // adjust newFront to match rear offset.
648 ALOGV("flush wrap: filled %zx >= overflowBit %zx", filled, overflowBit);
649 newFront += overflowBit;
650 filled -= overflowBit;
651 }
652 // Rather than shutting down on a corrupt flush, just treat it as a full flush
653 if (!(0 <= filled && (size_t) filled <= mFrameCount)) {
654 ALOGE("mFlush %#x -> %#x, front %#x, rear %#x, mask %#x, newFront %#x, "
655 "filled %zd=%#x",
656 mFlush, flush, front, rear,
657 (unsigned)mask, newFront, filled, (unsigned)filled);
658 newFront = rear;
659 }
660 mFlush = flush;
661 android_atomic_release_store(newFront, &cblk->u.mStreaming.mFront);
662 // There is no danger from a false positive, so err on the side of caution
663 if (true /*front != newFront*/) {
664 int32_t old = android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex);
665 if (!(old & CBLK_FUTEX_WAKE)) {
666 (void) syscall(__NR_futex, &cblk->mFutex,
667 mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1);
668 }
669 }
670 mFlushed += (newFront - front) & mask;
671 }
672 }
673
674 __attribute__((no_sanitize("integer")))
obtainBuffer(Buffer * buffer,bool ackFlush)675 status_t ServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush)
676 {
677 LOG_ALWAYS_FATAL_IF(buffer == NULL || buffer->mFrameCount == 0);
678 if (mIsShutdown) {
679 goto no_init;
680 }
681 {
682 audio_track_cblk_t* cblk = mCblk;
683 // compute number of frames available to write (AudioTrack) or read (AudioRecord),
684 // or use previous cached value from framesReady(), with added barrier if it omits.
685 int32_t front;
686 int32_t rear;
687 // See notes on barriers at ClientProxy::obtainBuffer()
688 if (mIsOut) {
689 flushBufferIfNeeded(); // might modify mFront
690 rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
691 front = cblk->u.mStreaming.mFront;
692 } else {
693 front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront);
694 rear = cblk->u.mStreaming.mRear;
695 }
696 ssize_t filled = rear - front;
697 // pipe should not already be overfull
698 if (!(0 <= filled && (size_t) filled <= mFrameCount)) {
699 ALOGE("Shared memory control block is corrupt (filled=%zd); shutting down", filled);
700 mIsShutdown = true;
701 }
702 if (mIsShutdown) {
703 goto no_init;
704 }
705 // don't allow filling pipe beyond the nominal size
706 size_t availToServer;
707 if (mIsOut) {
708 availToServer = filled;
709 mAvailToClient = mFrameCount - filled;
710 } else {
711 availToServer = mFrameCount - filled;
712 mAvailToClient = filled;
713 }
714 // 'availToServer' may be non-contiguous, so return only the first contiguous chunk
715 size_t part1;
716 if (mIsOut) {
717 front &= mFrameCountP2 - 1;
718 part1 = mFrameCountP2 - front;
719 } else {
720 rear &= mFrameCountP2 - 1;
721 part1 = mFrameCountP2 - rear;
722 }
723 if (part1 > availToServer) {
724 part1 = availToServer;
725 }
726 size_t ask = buffer->mFrameCount;
727 if (part1 > ask) {
728 part1 = ask;
729 }
730 // is assignment redundant in some cases?
731 buffer->mFrameCount = part1;
732 buffer->mRaw = part1 > 0 ?
733 &((char *) mBuffers)[(mIsOut ? front : rear) * mFrameSize] : NULL;
734 buffer->mNonContig = availToServer - part1;
735 // After flush(), allow releaseBuffer() on a previously obtained buffer;
736 // see "Acknowledge any pending flush()" in audioflinger/Tracks.cpp.
737 if (!ackFlush) {
738 mUnreleased = part1;
739 }
740 return part1 > 0 ? NO_ERROR : WOULD_BLOCK;
741 }
742 no_init:
743 buffer->mFrameCount = 0;
744 buffer->mRaw = NULL;
745 buffer->mNonContig = 0;
746 mUnreleased = 0;
747 return NO_INIT;
748 }
749
750 __attribute__((no_sanitize("integer")))
releaseBuffer(Buffer * buffer)751 void ServerProxy::releaseBuffer(Buffer* buffer)
752 {
753 LOG_ALWAYS_FATAL_IF(buffer == NULL);
754 size_t stepCount = buffer->mFrameCount;
755 if (stepCount == 0 || mIsShutdown) {
756 // prevent accidental re-use of buffer
757 buffer->mFrameCount = 0;
758 buffer->mRaw = NULL;
759 buffer->mNonContig = 0;
760 return;
761 }
762 LOG_ALWAYS_FATAL_IF(!(stepCount <= mUnreleased && mUnreleased <= mFrameCount));
763 mUnreleased -= stepCount;
764 audio_track_cblk_t* cblk = mCblk;
765 if (mIsOut) {
766 int32_t front = cblk->u.mStreaming.mFront;
767 android_atomic_release_store(stepCount + front, &cblk->u.mStreaming.mFront);
768 } else {
769 int32_t rear = cblk->u.mStreaming.mRear;
770 android_atomic_release_store(stepCount + rear, &cblk->u.mStreaming.mRear);
771 }
772
773 cblk->mServer += stepCount;
774 mReleased += stepCount;
775
776 size_t half = mFrameCount / 2;
777 if (half == 0) {
778 half = 1;
779 }
780 size_t minimum = (size_t) cblk->mMinimum;
781 if (minimum == 0) {
782 minimum = mIsOut ? half : 1;
783 } else if (minimum > half) {
784 minimum = half;
785 }
786 // FIXME AudioRecord wakeup needs to be optimized; it currently wakes up client every time
787 if (!mIsOut || (mAvailToClient + stepCount >= minimum)) {
788 ALOGV("mAvailToClient=%zu stepCount=%zu minimum=%zu", mAvailToClient, stepCount, minimum);
789 int32_t old = android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex);
790 if (!(old & CBLK_FUTEX_WAKE)) {
791 (void) syscall(__NR_futex, &cblk->mFutex,
792 mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1);
793 }
794 }
795
796 buffer->mFrameCount = 0;
797 buffer->mRaw = NULL;
798 buffer->mNonContig = 0;
799 }
800
801 // ---------------------------------------------------------------------------
802
803 __attribute__((no_sanitize("integer")))
framesReady()804 size_t AudioTrackServerProxy::framesReady()
805 {
806 LOG_ALWAYS_FATAL_IF(!mIsOut);
807
808 if (mIsShutdown) {
809 return 0;
810 }
811 audio_track_cblk_t* cblk = mCblk;
812
813 int32_t flush = cblk->u.mStreaming.mFlush;
814 if (flush != mFlush) {
815 // FIXME should return an accurate value, but over-estimate is better than under-estimate
816 return mFrameCount;
817 }
818 // the acquire might not be necessary since not doing a subsequent read
819 int32_t rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);
820 ssize_t filled = rear - cblk->u.mStreaming.mFront;
821 // pipe should not already be overfull
822 if (!(0 <= filled && (size_t) filled <= mFrameCount)) {
823 ALOGE("Shared memory control block is corrupt (filled=%zd); shutting down", filled);
824 mIsShutdown = true;
825 return 0;
826 }
827 // cache this value for later use by obtainBuffer(), with added barrier
828 // and racy if called by normal mixer thread
829 // ignores flush(), so framesReady() may report a larger mFrameCount than obtainBuffer()
830 return filled;
831 }
832
setStreamEndDone()833 bool AudioTrackServerProxy::setStreamEndDone() {
834 audio_track_cblk_t* cblk = mCblk;
835 bool old =
836 (android_atomic_or(CBLK_STREAM_END_DONE, &cblk->mFlags) & CBLK_STREAM_END_DONE) != 0;
837 if (!old) {
838 (void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE,
839 1);
840 }
841 return old;
842 }
843
tallyUnderrunFrames(uint32_t frameCount)844 void AudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount)
845 {
846 audio_track_cblk_t* cblk = mCblk;
847 if (frameCount > 0) {
848 cblk->u.mStreaming.mUnderrunFrames += frameCount;
849
850 if (!mUnderrunning) { // start of underrun?
851 mUnderrunCount++;
852 cblk->u.mStreaming.mUnderrunCount = mUnderrunCount;
853 mUnderrunning = true;
854 ALOGV("tallyUnderrunFrames(%3u) at uf = %u, bump mUnderrunCount = %u",
855 frameCount, cblk->u.mStreaming.mUnderrunFrames, mUnderrunCount);
856 }
857
858 // FIXME also wake futex so that underrun is noticed more quickly
859 (void) android_atomic_or(CBLK_UNDERRUN, &cblk->mFlags);
860 } else {
861 ALOGV_IF(mUnderrunning,
862 "tallyUnderrunFrames(%3u) at uf = %u, underrun finished",
863 frameCount, cblk->u.mStreaming.mUnderrunFrames);
864 mUnderrunning = false; // so we can detect the next edge
865 }
866 }
867
getPlaybackRate()868 AudioPlaybackRate AudioTrackServerProxy::getPlaybackRate()
869 { // do not call from multiple threads without holding lock
870 mPlaybackRateObserver.poll(mPlaybackRate);
871 return mPlaybackRate;
872 }
873
874 // ---------------------------------------------------------------------------
875
StaticAudioTrackServerProxy(audio_track_cblk_t * cblk,void * buffers,size_t frameCount,size_t frameSize)876 StaticAudioTrackServerProxy::StaticAudioTrackServerProxy(audio_track_cblk_t* cblk, void *buffers,
877 size_t frameCount, size_t frameSize)
878 : AudioTrackServerProxy(cblk, buffers, frameCount, frameSize),
879 mObserver(&cblk->u.mStatic.mSingleStateQueue),
880 mPosLoopMutator(&cblk->u.mStatic.mPosLoopQueue),
881 mFramesReadySafe(frameCount), mFramesReady(frameCount),
882 mFramesReadyIsCalledByMultipleThreads(false)
883 {
884 memset(&mState, 0, sizeof(mState));
885 }
886
framesReadyIsCalledByMultipleThreads()887 void StaticAudioTrackServerProxy::framesReadyIsCalledByMultipleThreads()
888 {
889 mFramesReadyIsCalledByMultipleThreads = true;
890 }
891
framesReady()892 size_t StaticAudioTrackServerProxy::framesReady()
893 {
894 // Can't call pollPosition() from multiple threads.
895 if (!mFramesReadyIsCalledByMultipleThreads) {
896 (void) pollPosition();
897 }
898 return mFramesReadySafe;
899 }
900
updateStateWithLoop(StaticAudioTrackState * localState,const StaticAudioTrackState & update) const901 status_t StaticAudioTrackServerProxy::updateStateWithLoop(
902 StaticAudioTrackState *localState, const StaticAudioTrackState &update) const
903 {
904 if (localState->mLoopSequence != update.mLoopSequence) {
905 bool valid = false;
906 const size_t loopStart = update.mLoopStart;
907 const size_t loopEnd = update.mLoopEnd;
908 size_t position = localState->mPosition;
909 if (update.mLoopCount == 0) {
910 valid = true;
911 } else if (update.mLoopCount >= -1) {
912 if (loopStart < loopEnd && loopEnd <= mFrameCount &&
913 loopEnd - loopStart >= MIN_LOOP) {
914 // If the current position is greater than the end of the loop
915 // we "wrap" to the loop start. This might cause an audible pop.
916 if (position >= loopEnd) {
917 position = loopStart;
918 }
919 valid = true;
920 }
921 }
922 if (!valid || position > mFrameCount) {
923 return NO_INIT;
924 }
925 localState->mPosition = position;
926 localState->mLoopCount = update.mLoopCount;
927 localState->mLoopEnd = loopEnd;
928 localState->mLoopStart = loopStart;
929 localState->mLoopSequence = update.mLoopSequence;
930 }
931 return OK;
932 }
933
updateStateWithPosition(StaticAudioTrackState * localState,const StaticAudioTrackState & update) const934 status_t StaticAudioTrackServerProxy::updateStateWithPosition(
935 StaticAudioTrackState *localState, const StaticAudioTrackState &update) const
936 {
937 if (localState->mPositionSequence != update.mPositionSequence) {
938 if (update.mPosition > mFrameCount) {
939 return NO_INIT;
940 } else if (localState->mLoopCount != 0 && update.mPosition >= localState->mLoopEnd) {
941 localState->mLoopCount = 0; // disable loop count if position is beyond loop end.
942 }
943 localState->mPosition = update.mPosition;
944 localState->mPositionSequence = update.mPositionSequence;
945 }
946 return OK;
947 }
948
pollPosition()949 ssize_t StaticAudioTrackServerProxy::pollPosition()
950 {
951 StaticAudioTrackState state;
952 if (mObserver.poll(state)) {
953 StaticAudioTrackState trystate = mState;
954 bool result;
955 const int32_t diffSeq = (int32_t) state.mLoopSequence - (int32_t) state.mPositionSequence;
956
957 if (diffSeq < 0) {
958 result = updateStateWithLoop(&trystate, state) == OK &&
959 updateStateWithPosition(&trystate, state) == OK;
960 } else {
961 result = updateStateWithPosition(&trystate, state) == OK &&
962 updateStateWithLoop(&trystate, state) == OK;
963 }
964 if (!result) {
965 mObserver.done();
966 // caution: no update occurs so server state will be inconsistent with client state.
967 ALOGE("%s client pushed an invalid state, shutting down", __func__);
968 mIsShutdown = true;
969 return (ssize_t) NO_INIT;
970 }
971 mState = trystate;
972 if (mState.mLoopCount == -1) {
973 mFramesReady = INT64_MAX;
974 } else if (mState.mLoopCount == 0) {
975 mFramesReady = mFrameCount - mState.mPosition;
976 } else if (mState.mLoopCount > 0) {
977 // TODO: Later consider fixing overflow, but does not seem needed now
978 // as will not overflow if loopStart and loopEnd are Java "ints".
979 mFramesReady = int64_t(mState.mLoopCount) * (mState.mLoopEnd - mState.mLoopStart)
980 + mFrameCount - mState.mPosition;
981 }
982 mFramesReadySafe = clampToSize(mFramesReady);
983 // This may overflow, but client is not supposed to rely on it
984 StaticAudioTrackPosLoop posLoop;
985
986 posLoop.mLoopCount = (int32_t) mState.mLoopCount;
987 posLoop.mBufferPosition = (uint32_t) mState.mPosition;
988 mPosLoopMutator.push(posLoop);
989 mObserver.done(); // safe to read mStatic variables.
990 }
991 return (ssize_t) mState.mPosition;
992 }
993
obtainBuffer(Buffer * buffer,bool ackFlush)994 status_t StaticAudioTrackServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush)
995 {
996 if (mIsShutdown) {
997 buffer->mFrameCount = 0;
998 buffer->mRaw = NULL;
999 buffer->mNonContig = 0;
1000 mUnreleased = 0;
1001 return NO_INIT;
1002 }
1003 ssize_t positionOrStatus = pollPosition();
1004 if (positionOrStatus < 0) {
1005 buffer->mFrameCount = 0;
1006 buffer->mRaw = NULL;
1007 buffer->mNonContig = 0;
1008 mUnreleased = 0;
1009 return (status_t) positionOrStatus;
1010 }
1011 size_t position = (size_t) positionOrStatus;
1012 size_t end = mState.mLoopCount != 0 ? mState.mLoopEnd : mFrameCount;
1013 size_t avail;
1014 if (position < end) {
1015 avail = end - position;
1016 size_t wanted = buffer->mFrameCount;
1017 if (avail < wanted) {
1018 buffer->mFrameCount = avail;
1019 } else {
1020 avail = wanted;
1021 }
1022 buffer->mRaw = &((char *) mBuffers)[position * mFrameSize];
1023 } else {
1024 avail = 0;
1025 buffer->mFrameCount = 0;
1026 buffer->mRaw = NULL;
1027 }
1028 // As mFramesReady is the total remaining frames in the static audio track,
1029 // it is always larger or equal to avail.
1030 LOG_ALWAYS_FATAL_IF(mFramesReady < (int64_t) avail);
1031 buffer->mNonContig = mFramesReady == INT64_MAX ? SIZE_MAX : clampToSize(mFramesReady - avail);
1032 if (!ackFlush) {
1033 mUnreleased = avail;
1034 }
1035 return NO_ERROR;
1036 }
1037
releaseBuffer(Buffer * buffer)1038 void StaticAudioTrackServerProxy::releaseBuffer(Buffer* buffer)
1039 {
1040 size_t stepCount = buffer->mFrameCount;
1041 LOG_ALWAYS_FATAL_IF(!((int64_t) stepCount <= mFramesReady));
1042 LOG_ALWAYS_FATAL_IF(!(stepCount <= mUnreleased));
1043 if (stepCount == 0) {
1044 // prevent accidental re-use of buffer
1045 buffer->mRaw = NULL;
1046 buffer->mNonContig = 0;
1047 return;
1048 }
1049 mUnreleased -= stepCount;
1050 audio_track_cblk_t* cblk = mCblk;
1051 size_t position = mState.mPosition;
1052 size_t newPosition = position + stepCount;
1053 int32_t setFlags = 0;
1054 if (!(position <= newPosition && newPosition <= mFrameCount)) {
1055 ALOGW("%s newPosition %zu outside [%zu, %zu]", __func__, newPosition, position,
1056 mFrameCount);
1057 newPosition = mFrameCount;
1058 } else if (mState.mLoopCount != 0 && newPosition == mState.mLoopEnd) {
1059 newPosition = mState.mLoopStart;
1060 if (mState.mLoopCount == -1 || --mState.mLoopCount != 0) {
1061 setFlags = CBLK_LOOP_CYCLE;
1062 } else {
1063 setFlags = CBLK_LOOP_FINAL;
1064 }
1065 }
1066 if (newPosition == mFrameCount) {
1067 setFlags |= CBLK_BUFFER_END;
1068 }
1069 mState.mPosition = newPosition;
1070 if (mFramesReady != INT64_MAX) {
1071 mFramesReady -= stepCount;
1072 }
1073 mFramesReadySafe = clampToSize(mFramesReady);
1074
1075 cblk->mServer += stepCount;
1076 mReleased += stepCount;
1077
1078 // This may overflow, but client is not supposed to rely on it
1079 StaticAudioTrackPosLoop posLoop;
1080 posLoop.mBufferPosition = mState.mPosition;
1081 posLoop.mLoopCount = mState.mLoopCount;
1082 mPosLoopMutator.push(posLoop);
1083 if (setFlags != 0) {
1084 (void) android_atomic_or(setFlags, &cblk->mFlags);
1085 // this would be a good place to wake a futex
1086 }
1087
1088 buffer->mFrameCount = 0;
1089 buffer->mRaw = NULL;
1090 buffer->mNonContig = 0;
1091 }
1092
tallyUnderrunFrames(uint32_t frameCount)1093 void StaticAudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount)
1094 {
1095 // Unlike AudioTrackServerProxy::tallyUnderrunFrames() used for streaming tracks,
1096 // we don't have a location to count underrun frames. The underrun frame counter
1097 // only exists in AudioTrackSharedStreaming. Fortunately, underruns are not
1098 // possible for static buffer tracks other than at end of buffer, so this is not a loss.
1099
1100 // FIXME also wake futex so that underrun is noticed more quickly
1101 if (frameCount > 0) {
1102 (void) android_atomic_or(CBLK_UNDERRUN, &mCblk->mFlags);
1103 }
1104 }
1105
1106 // ---------------------------------------------------------------------------
1107
1108 } // namespace android
1109