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 26namespace android { 27 28// used to clamp a value to size_t. TODO: move to another file. 29template <typename T> 30size_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 40static 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 48audio_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 59Proxy::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 69ClientProxy::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 78const struct timespec ClientProxy::kForever = {INT_MAX /*tv_sec*/, 0 /*tv_nsec*/}; 79const 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 89uint32_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"))) 111status_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 315end: 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"))) 337void 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 361void 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 372void 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"))) 383size_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 392void 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 406bool AudioTrackClientProxy::clearStreamEndDone() { 407 return (android_atomic_and(~CBLK_STREAM_END_DONE, &mCblk->mFlags) & CBLK_STREAM_END_DONE) != 0; 408} 409 410bool AudioTrackClientProxy::getStreamEndDone() const { 411 return (mCblk->mFlags & CBLK_STREAM_END_DONE) != 0; 412} 413 414status_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 514end: 515 if (requested == NULL) { 516 requested = &kNonBlocking; 517 } 518 return status; 519} 520 521// --------------------------------------------------------------------------- 522 523StaticAudioTrackClientProxy::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 533void StaticAudioTrackClientProxy::flush() 534{ 535 LOG_ALWAYS_FATAL("static flush"); 536} 537 538void 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 561void 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 584void 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 591size_t StaticAudioTrackClientProxy::getBufferPosition() 592{ 593 getBufferPositionAndLoopCount(NULL, NULL); 594 return mPosLoop.mBufferPosition; 595} 596 597void 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 615ServerProxy::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"))) 625status_t ServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush) 626{ 627 LOG_ALWAYS_FATAL_IF(buffer == NULL || buffer->mFrameCount == 0); 628 if (mIsShutdown) { 629 goto no_init; 630 } 631 { 632 audio_track_cblk_t* cblk = mCblk; 633 // compute number of frames available to write (AudioTrack) or read (AudioRecord), 634 // or use previous cached value from framesReady(), with added barrier if it omits. 635 int32_t front; 636 int32_t rear; 637 // See notes on barriers at ClientProxy::obtainBuffer() 638 if (mIsOut) { 639 int32_t flush = cblk->u.mStreaming.mFlush; 640 rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear); 641 front = cblk->u.mStreaming.mFront; 642 if (flush != mFlush) { 643 // effectively obtain then release whatever is in the buffer 644 const size_t overflowBit = mFrameCountP2 << 1; 645 const size_t mask = overflowBit - 1; 646 int32_t newFront = (front & ~mask) | (flush & mask); 647 ssize_t filled = rear - newFront; 648 if (filled >= (ssize_t)overflowBit) { 649 // front and rear offsets span the overflow bit of the p2 mask 650 // so rebasing newFront on the front offset is off by the overflow bit. 651 // adjust newFront to match rear offset. 652 ALOGV("flush wrap: filled %zx >= overflowBit %zx", filled, overflowBit); 653 newFront += overflowBit; 654 filled -= overflowBit; 655 } 656 // Rather than shutting down on a corrupt flush, just treat it as a full flush 657 if (!(0 <= filled && (size_t) filled <= mFrameCount)) { 658 ALOGE("mFlush %#x -> %#x, front %#x, rear %#x, mask %#x, newFront %#x, " 659 "filled %zd=%#x", 660 mFlush, flush, front, rear, 661 (unsigned)mask, newFront, filled, (unsigned)filled); 662 newFront = rear; 663 } 664 mFlush = flush; 665 android_atomic_release_store(newFront, &cblk->u.mStreaming.mFront); 666 // There is no danger from a false positive, so err on the side of caution 667 if (true /*front != newFront*/) { 668 int32_t old = android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex); 669 if (!(old & CBLK_FUTEX_WAKE)) { 670 (void) syscall(__NR_futex, &cblk->mFutex, 671 mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1); 672 } 673 } 674 mFlushed += (newFront - front) & mask; 675 front = newFront; 676 } 677 } else { 678 front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront); 679 rear = cblk->u.mStreaming.mRear; 680 } 681 ssize_t filled = rear - front; 682 // pipe should not already be overfull 683 if (!(0 <= filled && (size_t) filled <= mFrameCount)) { 684 ALOGE("Shared memory control block is corrupt (filled=%zd); shutting down", filled); 685 mIsShutdown = true; 686 } 687 if (mIsShutdown) { 688 goto no_init; 689 } 690 // don't allow filling pipe beyond the nominal size 691 size_t availToServer; 692 if (mIsOut) { 693 availToServer = filled; 694 mAvailToClient = mFrameCount - filled; 695 } else { 696 availToServer = mFrameCount - filled; 697 mAvailToClient = filled; 698 } 699 // 'availToServer' may be non-contiguous, so return only the first contiguous chunk 700 size_t part1; 701 if (mIsOut) { 702 front &= mFrameCountP2 - 1; 703 part1 = mFrameCountP2 - front; 704 } else { 705 rear &= mFrameCountP2 - 1; 706 part1 = mFrameCountP2 - rear; 707 } 708 if (part1 > availToServer) { 709 part1 = availToServer; 710 } 711 size_t ask = buffer->mFrameCount; 712 if (part1 > ask) { 713 part1 = ask; 714 } 715 // is assignment redundant in some cases? 716 buffer->mFrameCount = part1; 717 buffer->mRaw = part1 > 0 ? 718 &((char *) mBuffers)[(mIsOut ? front : rear) * mFrameSize] : NULL; 719 buffer->mNonContig = availToServer - part1; 720 // After flush(), allow releaseBuffer() on a previously obtained buffer; 721 // see "Acknowledge any pending flush()" in audioflinger/Tracks.cpp. 722 if (!ackFlush) { 723 mUnreleased = part1; 724 } 725 return part1 > 0 ? NO_ERROR : WOULD_BLOCK; 726 } 727no_init: 728 buffer->mFrameCount = 0; 729 buffer->mRaw = NULL; 730 buffer->mNonContig = 0; 731 mUnreleased = 0; 732 return NO_INIT; 733} 734 735__attribute__((no_sanitize("integer"))) 736void ServerProxy::releaseBuffer(Buffer* buffer) 737{ 738 LOG_ALWAYS_FATAL_IF(buffer == NULL); 739 size_t stepCount = buffer->mFrameCount; 740 if (stepCount == 0 || mIsShutdown) { 741 // prevent accidental re-use of buffer 742 buffer->mFrameCount = 0; 743 buffer->mRaw = NULL; 744 buffer->mNonContig = 0; 745 return; 746 } 747 LOG_ALWAYS_FATAL_IF(!(stepCount <= mUnreleased && mUnreleased <= mFrameCount)); 748 mUnreleased -= stepCount; 749 audio_track_cblk_t* cblk = mCblk; 750 if (mIsOut) { 751 int32_t front = cblk->u.mStreaming.mFront; 752 android_atomic_release_store(stepCount + front, &cblk->u.mStreaming.mFront); 753 } else { 754 int32_t rear = cblk->u.mStreaming.mRear; 755 android_atomic_release_store(stepCount + rear, &cblk->u.mStreaming.mRear); 756 } 757 758 cblk->mServer += stepCount; 759 mReleased += stepCount; 760 761 size_t half = mFrameCount / 2; 762 if (half == 0) { 763 half = 1; 764 } 765 size_t minimum = (size_t) cblk->mMinimum; 766 if (minimum == 0) { 767 minimum = mIsOut ? half : 1; 768 } else if (minimum > half) { 769 minimum = half; 770 } 771 // FIXME AudioRecord wakeup needs to be optimized; it currently wakes up client every time 772 if (!mIsOut || (mAvailToClient + stepCount >= minimum)) { 773 ALOGV("mAvailToClient=%zu stepCount=%zu minimum=%zu", mAvailToClient, stepCount, minimum); 774 int32_t old = android_atomic_or(CBLK_FUTEX_WAKE, &cblk->mFutex); 775 if (!(old & CBLK_FUTEX_WAKE)) { 776 (void) syscall(__NR_futex, &cblk->mFutex, 777 mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1); 778 } 779 } 780 781 buffer->mFrameCount = 0; 782 buffer->mRaw = NULL; 783 buffer->mNonContig = 0; 784} 785 786// --------------------------------------------------------------------------- 787 788__attribute__((no_sanitize("integer"))) 789size_t AudioTrackServerProxy::framesReady() 790{ 791 LOG_ALWAYS_FATAL_IF(!mIsOut); 792 793 if (mIsShutdown) { 794 return 0; 795 } 796 audio_track_cblk_t* cblk = mCblk; 797 798 int32_t flush = cblk->u.mStreaming.mFlush; 799 if (flush != mFlush) { 800 // FIXME should return an accurate value, but over-estimate is better than under-estimate 801 return mFrameCount; 802 } 803 // the acquire might not be necessary since not doing a subsequent read 804 int32_t rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear); 805 ssize_t filled = rear - cblk->u.mStreaming.mFront; 806 // pipe should not already be overfull 807 if (!(0 <= filled && (size_t) filled <= mFrameCount)) { 808 ALOGE("Shared memory control block is corrupt (filled=%zd); shutting down", filled); 809 mIsShutdown = true; 810 return 0; 811 } 812 // cache this value for later use by obtainBuffer(), with added barrier 813 // and racy if called by normal mixer thread 814 // ignores flush(), so framesReady() may report a larger mFrameCount than obtainBuffer() 815 return filled; 816} 817 818bool AudioTrackServerProxy::setStreamEndDone() { 819 audio_track_cblk_t* cblk = mCblk; 820 bool old = 821 (android_atomic_or(CBLK_STREAM_END_DONE, &cblk->mFlags) & CBLK_STREAM_END_DONE) != 0; 822 if (!old) { 823 (void) syscall(__NR_futex, &cblk->mFutex, mClientInServer ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 824 1); 825 } 826 return old; 827} 828 829void AudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount) 830{ 831 audio_track_cblk_t* cblk = mCblk; 832 if (frameCount > 0) { 833 cblk->u.mStreaming.mUnderrunFrames += frameCount; 834 835 if (!mUnderrunning) { // start of underrun? 836 mUnderrunCount++; 837 cblk->u.mStreaming.mUnderrunCount = mUnderrunCount; 838 mUnderrunning = true; 839 ALOGV("tallyUnderrunFrames(%3u) at uf = %u, bump mUnderrunCount = %u", 840 frameCount, cblk->u.mStreaming.mUnderrunFrames, mUnderrunCount); 841 } 842 843 // FIXME also wake futex so that underrun is noticed more quickly 844 (void) android_atomic_or(CBLK_UNDERRUN, &cblk->mFlags); 845 } else { 846 ALOGV_IF(mUnderrunning, 847 "tallyUnderrunFrames(%3u) at uf = %u, underrun finished", 848 frameCount, cblk->u.mStreaming.mUnderrunFrames); 849 mUnderrunning = false; // so we can detect the next edge 850 } 851} 852 853AudioPlaybackRate AudioTrackServerProxy::getPlaybackRate() 854{ // do not call from multiple threads without holding lock 855 mPlaybackRateObserver.poll(mPlaybackRate); 856 return mPlaybackRate; 857} 858 859// --------------------------------------------------------------------------- 860 861StaticAudioTrackServerProxy::StaticAudioTrackServerProxy(audio_track_cblk_t* cblk, void *buffers, 862 size_t frameCount, size_t frameSize) 863 : AudioTrackServerProxy(cblk, buffers, frameCount, frameSize), 864 mObserver(&cblk->u.mStatic.mSingleStateQueue), 865 mPosLoopMutator(&cblk->u.mStatic.mPosLoopQueue), 866 mFramesReadySafe(frameCount), mFramesReady(frameCount), 867 mFramesReadyIsCalledByMultipleThreads(false) 868{ 869 memset(&mState, 0, sizeof(mState)); 870} 871 872void StaticAudioTrackServerProxy::framesReadyIsCalledByMultipleThreads() 873{ 874 mFramesReadyIsCalledByMultipleThreads = true; 875} 876 877size_t StaticAudioTrackServerProxy::framesReady() 878{ 879 // Can't call pollPosition() from multiple threads. 880 if (!mFramesReadyIsCalledByMultipleThreads) { 881 (void) pollPosition(); 882 } 883 return mFramesReadySafe; 884} 885 886status_t StaticAudioTrackServerProxy::updateStateWithLoop( 887 StaticAudioTrackState *localState, const StaticAudioTrackState &update) const 888{ 889 if (localState->mLoopSequence != update.mLoopSequence) { 890 bool valid = false; 891 const size_t loopStart = update.mLoopStart; 892 const size_t loopEnd = update.mLoopEnd; 893 size_t position = localState->mPosition; 894 if (update.mLoopCount == 0) { 895 valid = true; 896 } else if (update.mLoopCount >= -1) { 897 if (loopStart < loopEnd && loopEnd <= mFrameCount && 898 loopEnd - loopStart >= MIN_LOOP) { 899 // If the current position is greater than the end of the loop 900 // we "wrap" to the loop start. This might cause an audible pop. 901 if (position >= loopEnd) { 902 position = loopStart; 903 } 904 valid = true; 905 } 906 } 907 if (!valid || position > mFrameCount) { 908 return NO_INIT; 909 } 910 localState->mPosition = position; 911 localState->mLoopCount = update.mLoopCount; 912 localState->mLoopEnd = loopEnd; 913 localState->mLoopStart = loopStart; 914 localState->mLoopSequence = update.mLoopSequence; 915 } 916 return OK; 917} 918 919status_t StaticAudioTrackServerProxy::updateStateWithPosition( 920 StaticAudioTrackState *localState, const StaticAudioTrackState &update) const 921{ 922 if (localState->mPositionSequence != update.mPositionSequence) { 923 if (update.mPosition > mFrameCount) { 924 return NO_INIT; 925 } else if (localState->mLoopCount != 0 && update.mPosition >= localState->mLoopEnd) { 926 localState->mLoopCount = 0; // disable loop count if position is beyond loop end. 927 } 928 localState->mPosition = update.mPosition; 929 localState->mPositionSequence = update.mPositionSequence; 930 } 931 return OK; 932} 933 934ssize_t StaticAudioTrackServerProxy::pollPosition() 935{ 936 StaticAudioTrackState state; 937 if (mObserver.poll(state)) { 938 StaticAudioTrackState trystate = mState; 939 bool result; 940 const int32_t diffSeq = (int32_t) state.mLoopSequence - (int32_t) state.mPositionSequence; 941 942 if (diffSeq < 0) { 943 result = updateStateWithLoop(&trystate, state) == OK && 944 updateStateWithPosition(&trystate, state) == OK; 945 } else { 946 result = updateStateWithPosition(&trystate, state) == OK && 947 updateStateWithLoop(&trystate, state) == OK; 948 } 949 if (!result) { 950 mObserver.done(); 951 // caution: no update occurs so server state will be inconsistent with client state. 952 ALOGE("%s client pushed an invalid state, shutting down", __func__); 953 mIsShutdown = true; 954 return (ssize_t) NO_INIT; 955 } 956 mState = trystate; 957 if (mState.mLoopCount == -1) { 958 mFramesReady = INT64_MAX; 959 } else if (mState.mLoopCount == 0) { 960 mFramesReady = mFrameCount - mState.mPosition; 961 } else if (mState.mLoopCount > 0) { 962 // TODO: Later consider fixing overflow, but does not seem needed now 963 // as will not overflow if loopStart and loopEnd are Java "ints". 964 mFramesReady = int64_t(mState.mLoopCount) * (mState.mLoopEnd - mState.mLoopStart) 965 + mFrameCount - mState.mPosition; 966 } 967 mFramesReadySafe = clampToSize(mFramesReady); 968 // This may overflow, but client is not supposed to rely on it 969 StaticAudioTrackPosLoop posLoop; 970 971 posLoop.mLoopCount = (int32_t) mState.mLoopCount; 972 posLoop.mBufferPosition = (uint32_t) mState.mPosition; 973 mPosLoopMutator.push(posLoop); 974 mObserver.done(); // safe to read mStatic variables. 975 } 976 return (ssize_t) mState.mPosition; 977} 978 979status_t StaticAudioTrackServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush) 980{ 981 if (mIsShutdown) { 982 buffer->mFrameCount = 0; 983 buffer->mRaw = NULL; 984 buffer->mNonContig = 0; 985 mUnreleased = 0; 986 return NO_INIT; 987 } 988 ssize_t positionOrStatus = pollPosition(); 989 if (positionOrStatus < 0) { 990 buffer->mFrameCount = 0; 991 buffer->mRaw = NULL; 992 buffer->mNonContig = 0; 993 mUnreleased = 0; 994 return (status_t) positionOrStatus; 995 } 996 size_t position = (size_t) positionOrStatus; 997 size_t end = mState.mLoopCount != 0 ? mState.mLoopEnd : mFrameCount; 998 size_t avail; 999 if (position < end) { 1000 avail = end - position; 1001 size_t wanted = buffer->mFrameCount; 1002 if (avail < wanted) { 1003 buffer->mFrameCount = avail; 1004 } else { 1005 avail = wanted; 1006 } 1007 buffer->mRaw = &((char *) mBuffers)[position * mFrameSize]; 1008 } else { 1009 avail = 0; 1010 buffer->mFrameCount = 0; 1011 buffer->mRaw = NULL; 1012 } 1013 // As mFramesReady is the total remaining frames in the static audio track, 1014 // it is always larger or equal to avail. 1015 LOG_ALWAYS_FATAL_IF(mFramesReady < (int64_t) avail); 1016 buffer->mNonContig = mFramesReady == INT64_MAX ? SIZE_MAX : clampToSize(mFramesReady - avail); 1017 if (!ackFlush) { 1018 mUnreleased = avail; 1019 } 1020 return NO_ERROR; 1021} 1022 1023void StaticAudioTrackServerProxy::releaseBuffer(Buffer* buffer) 1024{ 1025 size_t stepCount = buffer->mFrameCount; 1026 LOG_ALWAYS_FATAL_IF(!((int64_t) stepCount <= mFramesReady)); 1027 LOG_ALWAYS_FATAL_IF(!(stepCount <= mUnreleased)); 1028 if (stepCount == 0) { 1029 // prevent accidental re-use of buffer 1030 buffer->mRaw = NULL; 1031 buffer->mNonContig = 0; 1032 return; 1033 } 1034 mUnreleased -= stepCount; 1035 audio_track_cblk_t* cblk = mCblk; 1036 size_t position = mState.mPosition; 1037 size_t newPosition = position + stepCount; 1038 int32_t setFlags = 0; 1039 if (!(position <= newPosition && newPosition <= mFrameCount)) { 1040 ALOGW("%s newPosition %zu outside [%zu, %zu]", __func__, newPosition, position, 1041 mFrameCount); 1042 newPosition = mFrameCount; 1043 } else if (mState.mLoopCount != 0 && newPosition == mState.mLoopEnd) { 1044 newPosition = mState.mLoopStart; 1045 if (mState.mLoopCount == -1 || --mState.mLoopCount != 0) { 1046 setFlags = CBLK_LOOP_CYCLE; 1047 } else { 1048 setFlags = CBLK_LOOP_FINAL; 1049 } 1050 } 1051 if (newPosition == mFrameCount) { 1052 setFlags |= CBLK_BUFFER_END; 1053 } 1054 mState.mPosition = newPosition; 1055 if (mFramesReady != INT64_MAX) { 1056 mFramesReady -= stepCount; 1057 } 1058 mFramesReadySafe = clampToSize(mFramesReady); 1059 1060 cblk->mServer += stepCount; 1061 mReleased += stepCount; 1062 1063 // This may overflow, but client is not supposed to rely on it 1064 StaticAudioTrackPosLoop posLoop; 1065 posLoop.mBufferPosition = mState.mPosition; 1066 posLoop.mLoopCount = mState.mLoopCount; 1067 mPosLoopMutator.push(posLoop); 1068 if (setFlags != 0) { 1069 (void) android_atomic_or(setFlags, &cblk->mFlags); 1070 // this would be a good place to wake a futex 1071 } 1072 1073 buffer->mFrameCount = 0; 1074 buffer->mRaw = NULL; 1075 buffer->mNonContig = 0; 1076} 1077 1078void StaticAudioTrackServerProxy::tallyUnderrunFrames(uint32_t frameCount) 1079{ 1080 // Unlike AudioTrackServerProxy::tallyUnderrunFrames() used for streaming tracks, 1081 // we don't have a location to count underrun frames. The underrun frame counter 1082 // only exists in AudioTrackSharedStreaming. Fortunately, underruns are not 1083 // possible for static buffer tracks other than at end of buffer, so this is not a loss. 1084 1085 // FIXME also wake futex so that underrun is noticed more quickly 1086 if (frameCount > 0) { 1087 (void) android_atomic_or(CBLK_UNDERRUN, &mCblk->mFlags); 1088 } 1089} 1090 1091// --------------------------------------------------------------------------- 1092 1093} // namespace android 1094