AudioTrack.cpp revision 2f35206b77dd7d8a8c761e0a81ea327c10787036
1/* 2** 3** Copyright 2007, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18//#define LOG_NDEBUG 0 19#define LOG_TAG "AudioTrack" 20 21#include <inttypes.h> 22#include <math.h> 23#include <sys/resource.h> 24 25#include <audio_utils/primitives.h> 26#include <binder/IPCThreadState.h> 27#include <media/AudioTrack.h> 28#include <utils/Log.h> 29#include <private/media/AudioTrackShared.h> 30#include <media/IAudioFlinger.h> 31#include <media/AudioPolicyHelper.h> 32#include <media/AudioResamplerPublic.h> 33 34#define WAIT_PERIOD_MS 10 35#define WAIT_STREAM_END_TIMEOUT_SEC 120 36static const int kMaxLoopCountNotifications = 32; 37 38namespace android { 39// --------------------------------------------------------------------------- 40 41// TODO: Move to a separate .h 42 43template <typename T> 44static inline const T &min(const T &x, const T &y) { 45 return x < y ? x : y; 46} 47 48template <typename T> 49static inline const T &max(const T &x, const T &y) { 50 return x > y ? x : y; 51} 52 53static const int32_t NANOS_PER_SECOND = 1000000000; 54 55static inline nsecs_t framesToNanoseconds(ssize_t frames, uint32_t sampleRate, float speed) 56{ 57 return ((double)frames * 1000000000) / ((double)sampleRate * speed); 58} 59 60static int64_t convertTimespecToUs(const struct timespec &tv) 61{ 62 return tv.tv_sec * 1000000ll + tv.tv_nsec / 1000; 63} 64 65static inline nsecs_t convertTimespecToNs(const struct timespec &tv) 66{ 67 return tv.tv_sec * (long long)NANOS_PER_SECOND + tv.tv_nsec; 68} 69 70// current monotonic time in microseconds. 71static int64_t getNowUs() 72{ 73 struct timespec tv; 74 (void) clock_gettime(CLOCK_MONOTONIC, &tv); 75 return convertTimespecToUs(tv); 76} 77 78// FIXME: we don't use the pitch setting in the time stretcher (not working); 79// instead we emulate it using our sample rate converter. 80static const bool kFixPitch = true; // enable pitch fix 81static inline uint32_t adjustSampleRate(uint32_t sampleRate, float pitch) 82{ 83 return kFixPitch ? (sampleRate * pitch + 0.5) : sampleRate; 84} 85 86static inline float adjustSpeed(float speed, float pitch) 87{ 88 return kFixPitch ? speed / max(pitch, AUDIO_TIMESTRETCH_PITCH_MIN_DELTA) : speed; 89} 90 91static inline float adjustPitch(float pitch) 92{ 93 return kFixPitch ? AUDIO_TIMESTRETCH_PITCH_NORMAL : pitch; 94} 95 96// Must match similar computation in createTrack_l in Threads.cpp. 97// TODO: Move to a common library 98static size_t calculateMinFrameCount( 99 uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate, 100 uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/) 101{ 102 // Ensure that buffer depth covers at least audio hardware latency 103 uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate); 104 if (minBufCount < 2) { 105 minBufCount = 2; 106 } 107#if 0 108 // The notificationsPerBufferReq parameter is not yet used for non-fast tracks, 109 // but keeping the code here to make it easier to add later. 110 if (minBufCount < notificationsPerBufferReq) { 111 minBufCount = notificationsPerBufferReq; 112 } 113#endif 114 ALOGV("calculateMinFrameCount afLatency %u afFrameCount %u afSampleRate %u " 115 "sampleRate %u speed %f minBufCount: %u" /*" notificationsPerBufferReq %u"*/, 116 afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount 117 /*, notificationsPerBufferReq*/); 118 return minBufCount * sourceFramesNeededWithTimestretch( 119 sampleRate, afFrameCount, afSampleRate, speed); 120} 121 122// static 123status_t AudioTrack::getMinFrameCount( 124 size_t* frameCount, 125 audio_stream_type_t streamType, 126 uint32_t sampleRate) 127{ 128 if (frameCount == NULL) { 129 return BAD_VALUE; 130 } 131 132 // FIXME handle in server, like createTrack_l(), possible missing info: 133 // audio_io_handle_t output 134 // audio_format_t format 135 // audio_channel_mask_t channelMask 136 // audio_output_flags_t flags (FAST) 137 uint32_t afSampleRate; 138 status_t status; 139 status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType); 140 if (status != NO_ERROR) { 141 ALOGE("Unable to query output sample rate for stream type %d; status %d", 142 streamType, status); 143 return status; 144 } 145 size_t afFrameCount; 146 status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType); 147 if (status != NO_ERROR) { 148 ALOGE("Unable to query output frame count for stream type %d; status %d", 149 streamType, status); 150 return status; 151 } 152 uint32_t afLatency; 153 status = AudioSystem::getOutputLatency(&afLatency, streamType); 154 if (status != NO_ERROR) { 155 ALOGE("Unable to query output latency for stream type %d; status %d", 156 streamType, status); 157 return status; 158 } 159 160 // When called from createTrack, speed is 1.0f (normal speed). 161 // This is rechecked again on setting playback rate (TODO: on setting sample rate, too). 162 *frameCount = calculateMinFrameCount(afLatency, afFrameCount, afSampleRate, sampleRate, 1.0f 163 /*, 0 notificationsPerBufferReq*/); 164 165 // The formula above should always produce a non-zero value under normal circumstances: 166 // AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX. 167 // Return error in the unlikely event that it does not, as that's part of the API contract. 168 if (*frameCount == 0) { 169 ALOGE("AudioTrack::getMinFrameCount failed for streamType %d, sampleRate %u", 170 streamType, sampleRate); 171 return BAD_VALUE; 172 } 173 ALOGV("getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u", 174 *frameCount, afFrameCount, afSampleRate, afLatency); 175 return NO_ERROR; 176} 177 178// --------------------------------------------------------------------------- 179 180AudioTrack::AudioTrack() 181 : mStatus(NO_INIT), 182 mState(STATE_STOPPED), 183 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 184 mPreviousSchedulingGroup(SP_DEFAULT), 185 mPausedPosition(0), 186 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE), 187 mPortId(AUDIO_PORT_HANDLE_NONE) 188{ 189 mAttributes.content_type = AUDIO_CONTENT_TYPE_UNKNOWN; 190 mAttributes.usage = AUDIO_USAGE_UNKNOWN; 191 mAttributes.flags = 0x0; 192 strcpy(mAttributes.tags, ""); 193} 194 195AudioTrack::AudioTrack( 196 audio_stream_type_t streamType, 197 uint32_t sampleRate, 198 audio_format_t format, 199 audio_channel_mask_t channelMask, 200 size_t frameCount, 201 audio_output_flags_t flags, 202 callback_t cbf, 203 void* user, 204 int32_t notificationFrames, 205 audio_session_t sessionId, 206 transfer_type transferType, 207 const audio_offload_info_t *offloadInfo, 208 uid_t uid, 209 pid_t pid, 210 const audio_attributes_t* pAttributes, 211 bool doNotReconnect, 212 float maxRequiredSpeed) 213 : mStatus(NO_INIT), 214 mState(STATE_STOPPED), 215 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 216 mPreviousSchedulingGroup(SP_DEFAULT), 217 mPausedPosition(0), 218 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE), 219 mPortId(AUDIO_PORT_HANDLE_NONE) 220{ 221 mStatus = set(streamType, sampleRate, format, channelMask, 222 frameCount, flags, cbf, user, notificationFrames, 223 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType, 224 offloadInfo, uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed); 225} 226 227AudioTrack::AudioTrack( 228 audio_stream_type_t streamType, 229 uint32_t sampleRate, 230 audio_format_t format, 231 audio_channel_mask_t channelMask, 232 const sp<IMemory>& sharedBuffer, 233 audio_output_flags_t flags, 234 callback_t cbf, 235 void* user, 236 int32_t notificationFrames, 237 audio_session_t sessionId, 238 transfer_type transferType, 239 const audio_offload_info_t *offloadInfo, 240 uid_t uid, 241 pid_t pid, 242 const audio_attributes_t* pAttributes, 243 bool doNotReconnect, 244 float maxRequiredSpeed) 245 : mStatus(NO_INIT), 246 mState(STATE_STOPPED), 247 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 248 mPreviousSchedulingGroup(SP_DEFAULT), 249 mPausedPosition(0), 250 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE), 251 mPortId(AUDIO_PORT_HANDLE_NONE) 252{ 253 mStatus = set(streamType, sampleRate, format, channelMask, 254 0 /*frameCount*/, flags, cbf, user, notificationFrames, 255 sharedBuffer, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo, 256 uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed); 257} 258 259AudioTrack::~AudioTrack() 260{ 261 if (mStatus == NO_ERROR) { 262 // Make sure that callback function exits in the case where 263 // it is looping on buffer full condition in obtainBuffer(). 264 // Otherwise the callback thread will never exit. 265 stop(); 266 if (mAudioTrackThread != 0) { 267 mProxy->interrupt(); 268 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h 269 mAudioTrackThread->requestExitAndWait(); 270 mAudioTrackThread.clear(); 271 } 272 // No lock here: worst case we remove a NULL callback which will be a nop 273 if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) { 274 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput); 275 } 276 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this); 277 mAudioTrack.clear(); 278 mCblkMemory.clear(); 279 mSharedBuffer.clear(); 280 IPCThreadState::self()->flushCommands(); 281 ALOGV("~AudioTrack, releasing session id %d from %d on behalf of %d", 282 mSessionId, IPCThreadState::self()->getCallingPid(), mClientPid); 283 AudioSystem::releaseAudioSessionId(mSessionId, mClientPid); 284 } 285} 286 287status_t AudioTrack::set( 288 audio_stream_type_t streamType, 289 uint32_t sampleRate, 290 audio_format_t format, 291 audio_channel_mask_t channelMask, 292 size_t frameCount, 293 audio_output_flags_t flags, 294 callback_t cbf, 295 void* user, 296 int32_t notificationFrames, 297 const sp<IMemory>& sharedBuffer, 298 bool threadCanCallJava, 299 audio_session_t sessionId, 300 transfer_type transferType, 301 const audio_offload_info_t *offloadInfo, 302 uid_t uid, 303 pid_t pid, 304 const audio_attributes_t* pAttributes, 305 bool doNotReconnect, 306 float maxRequiredSpeed) 307{ 308 ALOGV("set(): streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, " 309 "flags #%x, notificationFrames %d, sessionId %d, transferType %d, uid %d, pid %d", 310 streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames, 311 sessionId, transferType, uid, pid); 312 313 mThreadCanCallJava = threadCanCallJava; 314 315 switch (transferType) { 316 case TRANSFER_DEFAULT: 317 if (sharedBuffer != 0) { 318 transferType = TRANSFER_SHARED; 319 } else if (cbf == NULL || threadCanCallJava) { 320 transferType = TRANSFER_SYNC; 321 } else { 322 transferType = TRANSFER_CALLBACK; 323 } 324 break; 325 case TRANSFER_CALLBACK: 326 if (cbf == NULL || sharedBuffer != 0) { 327 ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0"); 328 return BAD_VALUE; 329 } 330 break; 331 case TRANSFER_OBTAIN: 332 case TRANSFER_SYNC: 333 if (sharedBuffer != 0) { 334 ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0"); 335 return BAD_VALUE; 336 } 337 break; 338 case TRANSFER_SHARED: 339 if (sharedBuffer == 0) { 340 ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0"); 341 return BAD_VALUE; 342 } 343 break; 344 default: 345 ALOGE("Invalid transfer type %d", transferType); 346 return BAD_VALUE; 347 } 348 mSharedBuffer = sharedBuffer; 349 mTransfer = transferType; 350 mDoNotReconnect = doNotReconnect; 351 352 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(), 353 sharedBuffer->size()); 354 355 ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags); 356 357 // invariant that mAudioTrack != 0 is true only after set() returns successfully 358 if (mAudioTrack != 0) { 359 ALOGE("Track already in use"); 360 return INVALID_OPERATION; 361 } 362 363 // handle default values first. 364 if (streamType == AUDIO_STREAM_DEFAULT) { 365 streamType = AUDIO_STREAM_MUSIC; 366 } 367 if (pAttributes == NULL) { 368 if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) { 369 ALOGE("Invalid stream type %d", streamType); 370 return BAD_VALUE; 371 } 372 mStreamType = streamType; 373 374 } else { 375 // stream type shouldn't be looked at, this track has audio attributes 376 memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t)); 377 ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]", 378 mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags); 379 mStreamType = AUDIO_STREAM_DEFAULT; 380 if ((mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) { 381 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC); 382 } 383 if ((mAttributes.flags & AUDIO_FLAG_LOW_LATENCY) != 0) { 384 flags = (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_FAST); 385 } 386 // check deep buffer after flags have been modified above 387 if (flags == AUDIO_OUTPUT_FLAG_NONE && (mAttributes.flags & AUDIO_FLAG_DEEP_BUFFER) != 0) { 388 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER; 389 } 390 } 391 392 // these below should probably come from the audioFlinger too... 393 if (format == AUDIO_FORMAT_DEFAULT) { 394 format = AUDIO_FORMAT_PCM_16_BIT; 395 } else if (format == AUDIO_FORMAT_IEC61937) { // HDMI pass-through? 396 mAttributes.flags |= AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO; 397 } 398 399 // validate parameters 400 if (!audio_is_valid_format(format)) { 401 ALOGE("Invalid format %#x", format); 402 return BAD_VALUE; 403 } 404 mFormat = format; 405 406 if (!audio_is_output_channel(channelMask)) { 407 ALOGE("Invalid channel mask %#x", channelMask); 408 return BAD_VALUE; 409 } 410 mChannelMask = channelMask; 411 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask); 412 mChannelCount = channelCount; 413 414 // force direct flag if format is not linear PCM 415 // or offload was requested 416 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) 417 || !audio_is_linear_pcm(format)) { 418 ALOGV( (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) 419 ? "Offload request, forcing to Direct Output" 420 : "Not linear PCM, forcing to Direct Output"); 421 flags = (audio_output_flags_t) 422 // FIXME why can't we allow direct AND fast? 423 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST); 424 } 425 426 // force direct flag if HW A/V sync requested 427 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) { 428 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT); 429 } 430 431 if (flags & AUDIO_OUTPUT_FLAG_DIRECT) { 432 if (audio_has_proportional_frames(format)) { 433 mFrameSize = channelCount * audio_bytes_per_sample(format); 434 } else { 435 mFrameSize = sizeof(uint8_t); 436 } 437 } else { 438 ALOG_ASSERT(audio_has_proportional_frames(format)); 439 mFrameSize = channelCount * audio_bytes_per_sample(format); 440 // createTrack will return an error if PCM format is not supported by server, 441 // so no need to check for specific PCM formats here 442 } 443 444 // sampling rate must be specified for direct outputs 445 if (sampleRate == 0 && (flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) { 446 return BAD_VALUE; 447 } 448 mSampleRate = sampleRate; 449 mOriginalSampleRate = sampleRate; 450 mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT; 451 // 1.0 <= mMaxRequiredSpeed <= AUDIO_TIMESTRETCH_SPEED_MAX 452 mMaxRequiredSpeed = min(max(maxRequiredSpeed, 1.0f), AUDIO_TIMESTRETCH_SPEED_MAX); 453 454 // Make copy of input parameter offloadInfo so that in the future: 455 // (a) createTrack_l doesn't need it as an input parameter 456 // (b) we can support re-creation of offloaded tracks 457 if (offloadInfo != NULL) { 458 mOffloadInfoCopy = *offloadInfo; 459 mOffloadInfo = &mOffloadInfoCopy; 460 } else { 461 mOffloadInfo = NULL; 462 memset(&mOffloadInfoCopy, 0, sizeof(audio_offload_info_t)); 463 } 464 465 mVolume[AUDIO_INTERLEAVE_LEFT] = 1.0f; 466 mVolume[AUDIO_INTERLEAVE_RIGHT] = 1.0f; 467 mSendLevel = 0.0f; 468 // mFrameCount is initialized in createTrack_l 469 mReqFrameCount = frameCount; 470 if (notificationFrames >= 0) { 471 mNotificationFramesReq = notificationFrames; 472 mNotificationsPerBufferReq = 0; 473 } else { 474 if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) { 475 ALOGE("notificationFrames=%d not permitted for non-fast track", 476 notificationFrames); 477 return BAD_VALUE; 478 } 479 if (frameCount > 0) { 480 ALOGE("notificationFrames=%d not permitted with non-zero frameCount=%zu", 481 notificationFrames, frameCount); 482 return BAD_VALUE; 483 } 484 mNotificationFramesReq = 0; 485 const uint32_t minNotificationsPerBuffer = 1; 486 const uint32_t maxNotificationsPerBuffer = 8; 487 mNotificationsPerBufferReq = min(maxNotificationsPerBuffer, 488 max((uint32_t) -notificationFrames, minNotificationsPerBuffer)); 489 ALOGW_IF(mNotificationsPerBufferReq != (uint32_t) -notificationFrames, 490 "notificationFrames=%d clamped to the range -%u to -%u", 491 notificationFrames, minNotificationsPerBuffer, maxNotificationsPerBuffer); 492 } 493 mNotificationFramesAct = 0; 494 if (sessionId == AUDIO_SESSION_ALLOCATE) { 495 mSessionId = (audio_session_t) AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION); 496 } else { 497 mSessionId = sessionId; 498 } 499 int callingpid = IPCThreadState::self()->getCallingPid(); 500 int mypid = getpid(); 501 if (uid == AUDIO_UID_INVALID || (callingpid != mypid)) { 502 mClientUid = IPCThreadState::self()->getCallingUid(); 503 } else { 504 mClientUid = uid; 505 } 506 if (pid == -1 || (callingpid != mypid)) { 507 mClientPid = callingpid; 508 } else { 509 mClientPid = pid; 510 } 511 mAuxEffectId = 0; 512 mOrigFlags = mFlags = flags; 513 mCbf = cbf; 514 515 if (cbf != NULL) { 516 mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava); 517 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/); 518 // thread begins in paused state, and will not reference us until start() 519 } 520 521 // create the IAudioTrack 522 status_t status = createTrack_l(); 523 524 if (status != NO_ERROR) { 525 if (mAudioTrackThread != 0) { 526 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h 527 mAudioTrackThread->requestExitAndWait(); 528 mAudioTrackThread.clear(); 529 } 530 return status; 531 } 532 533 mStatus = NO_ERROR; 534 mUserData = user; 535 mLoopCount = 0; 536 mLoopStart = 0; 537 mLoopEnd = 0; 538 mLoopCountNotified = 0; 539 mMarkerPosition = 0; 540 mMarkerReached = false; 541 mNewPosition = 0; 542 mUpdatePeriod = 0; 543 mPosition = 0; 544 mReleased = 0; 545 mStartUs = 0; 546 AudioSystem::acquireAudioSessionId(mSessionId, mClientPid); 547 mSequence = 1; 548 mObservedSequence = mSequence; 549 mInUnderrun = false; 550 mPreviousTimestampValid = false; 551 mTimestampStartupGlitchReported = false; 552 mRetrogradeMotionReported = false; 553 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID; 554 mStartTs.mPosition = 0; 555 mUnderrunCountOffset = 0; 556 mFramesWritten = 0; 557 mFramesWrittenServerOffset = 0; 558 mFramesWrittenAtRestore = -1; // -1 is a unique initializer. 559 mVolumeHandler = new VolumeHandler(); 560 return NO_ERROR; 561} 562 563// ------------------------------------------------------------------------- 564 565status_t AudioTrack::start() 566{ 567 AutoMutex lock(mLock); 568 569 if (mState == STATE_ACTIVE) { 570 return INVALID_OPERATION; 571 } 572 573 mInUnderrun = true; 574 575 State previousState = mState; 576 if (previousState == STATE_PAUSED_STOPPING) { 577 mState = STATE_STOPPING; 578 } else { 579 mState = STATE_ACTIVE; 580 } 581 (void) updateAndGetPosition_l(); 582 583 // save start timestamp 584 if (isOffloadedOrDirect_l()) { 585 if (getTimestamp_l(mStartTs) != OK) { 586 mStartTs.mPosition = 0; 587 } 588 } else { 589 if (getTimestamp_l(&mStartEts) != OK) { 590 mStartEts.clear(); 591 } 592 } 593 if (previousState == STATE_STOPPED || previousState == STATE_FLUSHED) { 594 // reset current position as seen by client to 0 595 mPosition = 0; 596 mPreviousTimestampValid = false; 597 mTimestampStartupGlitchReported = false; 598 mRetrogradeMotionReported = false; 599 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID; 600 601 if (!isOffloadedOrDirect_l() 602 && mStartEts.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] > 0) { 603 // Server side has consumed something, but is it finished consuming? 604 // It is possible since flush and stop are asynchronous that the server 605 // is still active at this point. 606 ALOGV("start: server read:%lld cumulative flushed:%lld client written:%lld", 607 (long long)(mFramesWrittenServerOffset 608 + mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER]), 609 (long long)mStartEts.mFlushed, 610 (long long)mFramesWritten); 611 mFramesWrittenServerOffset = -mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER]; 612 } 613 mFramesWritten = 0; 614 mProxy->clearTimestamp(); // need new server push for valid timestamp 615 mMarkerReached = false; 616 617 // For offloaded tracks, we don't know if the hardware counters are really zero here, 618 // since the flush is asynchronous and stop may not fully drain. 619 // We save the time when the track is started to later verify whether 620 // the counters are realistic (i.e. start from zero after this time). 621 mStartUs = getNowUs(); 622 623 // force refresh of remaining frames by processAudioBuffer() as last 624 // write before stop could be partial. 625 mRefreshRemaining = true; 626 } 627 mNewPosition = mPosition + mUpdatePeriod; 628 int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE | CBLK_DISABLED), &mCblk->mFlags); 629 630 status_t status = NO_ERROR; 631 if (!(flags & CBLK_INVALID)) { 632 status = mAudioTrack->start(); 633 if (status == DEAD_OBJECT) { 634 flags |= CBLK_INVALID; 635 } 636 } 637 if (flags & CBLK_INVALID) { 638 status = restoreTrack_l("start"); 639 } 640 641 // resume or pause the callback thread as needed. 642 sp<AudioTrackThread> t = mAudioTrackThread; 643 if (status == NO_ERROR) { 644 if (t != 0) { 645 if (previousState == STATE_STOPPING) { 646 mProxy->interrupt(); 647 } else { 648 t->resume(); 649 } 650 } else { 651 mPreviousPriority = getpriority(PRIO_PROCESS, 0); 652 get_sched_policy(0, &mPreviousSchedulingGroup); 653 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO); 654 } 655 656 // Start our local VolumeHandler for restoration purposes. 657 mVolumeHandler->setStarted(); 658 } else { 659 ALOGE("start() status %d", status); 660 mState = previousState; 661 if (t != 0) { 662 if (previousState != STATE_STOPPING) { 663 t->pause(); 664 } 665 } else { 666 setpriority(PRIO_PROCESS, 0, mPreviousPriority); 667 set_sched_policy(0, mPreviousSchedulingGroup); 668 } 669 } 670 671 return status; 672} 673 674void AudioTrack::stop() 675{ 676 AutoMutex lock(mLock); 677 if (mState != STATE_ACTIVE && mState != STATE_PAUSED) { 678 return; 679 } 680 681 if (isOffloaded_l()) { 682 mState = STATE_STOPPING; 683 } else { 684 mState = STATE_STOPPED; 685 ALOGD_IF(mSharedBuffer == nullptr, 686 "stop() called with %u frames delivered", mReleased.value()); 687 mReleased = 0; 688 } 689 690 mProxy->interrupt(); 691 mAudioTrack->stop(); 692 693 // Note: legacy handling - stop does not clear playback marker 694 // and periodic update counter, but flush does for streaming tracks. 695 696 if (mSharedBuffer != 0) { 697 // clear buffer position and loop count. 698 mStaticProxy->setBufferPositionAndLoop(0 /* position */, 699 0 /* loopStart */, 0 /* loopEnd */, 0 /* loopCount */); 700 } 701 702 sp<AudioTrackThread> t = mAudioTrackThread; 703 if (t != 0) { 704 if (!isOffloaded_l()) { 705 t->pause(); 706 } 707 } else { 708 setpriority(PRIO_PROCESS, 0, mPreviousPriority); 709 set_sched_policy(0, mPreviousSchedulingGroup); 710 } 711} 712 713bool AudioTrack::stopped() const 714{ 715 AutoMutex lock(mLock); 716 return mState != STATE_ACTIVE; 717} 718 719void AudioTrack::flush() 720{ 721 if (mSharedBuffer != 0) { 722 return; 723 } 724 AutoMutex lock(mLock); 725 if (mState == STATE_ACTIVE || mState == STATE_FLUSHED) { 726 return; 727 } 728 flush_l(); 729} 730 731void AudioTrack::flush_l() 732{ 733 ALOG_ASSERT(mState != STATE_ACTIVE); 734 735 // clear playback marker and periodic update counter 736 mMarkerPosition = 0; 737 mMarkerReached = false; 738 mUpdatePeriod = 0; 739 mRefreshRemaining = true; 740 741 mState = STATE_FLUSHED; 742 mReleased = 0; 743 if (isOffloaded_l()) { 744 mProxy->interrupt(); 745 } 746 mProxy->flush(); 747 mAudioTrack->flush(); 748} 749 750void AudioTrack::pause() 751{ 752 AutoMutex lock(mLock); 753 if (mState == STATE_ACTIVE) { 754 mState = STATE_PAUSED; 755 } else if (mState == STATE_STOPPING) { 756 mState = STATE_PAUSED_STOPPING; 757 } else { 758 return; 759 } 760 mProxy->interrupt(); 761 mAudioTrack->pause(); 762 763 if (isOffloaded_l()) { 764 if (mOutput != AUDIO_IO_HANDLE_NONE) { 765 // An offload output can be re-used between two audio tracks having 766 // the same configuration. A timestamp query for a paused track 767 // while the other is running would return an incorrect time. 768 // To fix this, cache the playback position on a pause() and return 769 // this time when requested until the track is resumed. 770 771 // OffloadThread sends HAL pause in its threadLoop. Time saved 772 // here can be slightly off. 773 774 // TODO: check return code for getRenderPosition. 775 776 uint32_t halFrames; 777 AudioSystem::getRenderPosition(mOutput, &halFrames, &mPausedPosition); 778 ALOGV("AudioTrack::pause for offload, cache current position %u", mPausedPosition); 779 } 780 } 781} 782 783status_t AudioTrack::setVolume(float left, float right) 784{ 785 // This duplicates a test by AudioTrack JNI, but that is not the only caller 786 if (isnanf(left) || left < GAIN_FLOAT_ZERO || left > GAIN_FLOAT_UNITY || 787 isnanf(right) || right < GAIN_FLOAT_ZERO || right > GAIN_FLOAT_UNITY) { 788 return BAD_VALUE; 789 } 790 791 AutoMutex lock(mLock); 792 mVolume[AUDIO_INTERLEAVE_LEFT] = left; 793 mVolume[AUDIO_INTERLEAVE_RIGHT] = right; 794 795 mProxy->setVolumeLR(gain_minifloat_pack(gain_from_float(left), gain_from_float(right))); 796 797 if (isOffloaded_l()) { 798 mAudioTrack->signal(); 799 } 800 return NO_ERROR; 801} 802 803status_t AudioTrack::setVolume(float volume) 804{ 805 return setVolume(volume, volume); 806} 807 808status_t AudioTrack::setAuxEffectSendLevel(float level) 809{ 810 // This duplicates a test by AudioTrack JNI, but that is not the only caller 811 if (isnanf(level) || level < GAIN_FLOAT_ZERO || level > GAIN_FLOAT_UNITY) { 812 return BAD_VALUE; 813 } 814 815 AutoMutex lock(mLock); 816 mSendLevel = level; 817 mProxy->setSendLevel(level); 818 819 return NO_ERROR; 820} 821 822void AudioTrack::getAuxEffectSendLevel(float* level) const 823{ 824 if (level != NULL) { 825 *level = mSendLevel; 826 } 827} 828 829status_t AudioTrack::setSampleRate(uint32_t rate) 830{ 831 AutoMutex lock(mLock); 832 if (rate == mSampleRate) { 833 return NO_ERROR; 834 } 835 if (isOffloadedOrDirect_l() || (mFlags & AUDIO_OUTPUT_FLAG_FAST)) { 836 return INVALID_OPERATION; 837 } 838 if (mOutput == AUDIO_IO_HANDLE_NONE) { 839 return NO_INIT; 840 } 841 // NOTE: it is theoretically possible, but highly unlikely, that a device change 842 // could mean a previously allowed sampling rate is no longer allowed. 843 uint32_t afSamplingRate; 844 if (AudioSystem::getSamplingRate(mOutput, &afSamplingRate) != NO_ERROR) { 845 return NO_INIT; 846 } 847 // pitch is emulated by adjusting speed and sampleRate 848 const uint32_t effectiveSampleRate = adjustSampleRate(rate, mPlaybackRate.mPitch); 849 if (rate == 0 || effectiveSampleRate > afSamplingRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) { 850 return BAD_VALUE; 851 } 852 // TODO: Should we also check if the buffer size is compatible? 853 854 mSampleRate = rate; 855 mProxy->setSampleRate(effectiveSampleRate); 856 857 return NO_ERROR; 858} 859 860uint32_t AudioTrack::getSampleRate() const 861{ 862 AutoMutex lock(mLock); 863 864 // sample rate can be updated during playback by the offloaded decoder so we need to 865 // query the HAL and update if needed. 866// FIXME use Proxy return channel to update the rate from server and avoid polling here 867 if (isOffloadedOrDirect_l()) { 868 if (mOutput != AUDIO_IO_HANDLE_NONE) { 869 uint32_t sampleRate = 0; 870 status_t status = AudioSystem::getSamplingRate(mOutput, &sampleRate); 871 if (status == NO_ERROR) { 872 mSampleRate = sampleRate; 873 } 874 } 875 } 876 return mSampleRate; 877} 878 879uint32_t AudioTrack::getOriginalSampleRate() const 880{ 881 return mOriginalSampleRate; 882} 883 884status_t AudioTrack::setPlaybackRate(const AudioPlaybackRate &playbackRate) 885{ 886 AutoMutex lock(mLock); 887 if (isAudioPlaybackRateEqual(playbackRate, mPlaybackRate)) { 888 return NO_ERROR; 889 } 890 if (isOffloadedOrDirect_l()) { 891 return INVALID_OPERATION; 892 } 893 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 894 return INVALID_OPERATION; 895 } 896 897 ALOGV("setPlaybackRate (input): mSampleRate:%u mSpeed:%f mPitch:%f", 898 mSampleRate, playbackRate.mSpeed, playbackRate.mPitch); 899 // pitch is emulated by adjusting speed and sampleRate 900 const uint32_t effectiveRate = adjustSampleRate(mSampleRate, playbackRate.mPitch); 901 const float effectiveSpeed = adjustSpeed(playbackRate.mSpeed, playbackRate.mPitch); 902 const float effectivePitch = adjustPitch(playbackRate.mPitch); 903 AudioPlaybackRate playbackRateTemp = playbackRate; 904 playbackRateTemp.mSpeed = effectiveSpeed; 905 playbackRateTemp.mPitch = effectivePitch; 906 907 ALOGV("setPlaybackRate (effective): mSampleRate:%u mSpeed:%f mPitch:%f", 908 effectiveRate, effectiveSpeed, effectivePitch); 909 910 if (!isAudioPlaybackRateValid(playbackRateTemp)) { 911 ALOGW("setPlaybackRate(%f, %f) failed (effective rate out of bounds)", 912 playbackRate.mSpeed, playbackRate.mPitch); 913 return BAD_VALUE; 914 } 915 // Check if the buffer size is compatible. 916 if (!isSampleRateSpeedAllowed_l(effectiveRate, effectiveSpeed)) { 917 ALOGW("setPlaybackRate(%f, %f) failed (buffer size)", 918 playbackRate.mSpeed, playbackRate.mPitch); 919 return BAD_VALUE; 920 } 921 922 // Check resampler ratios are within bounds 923 if ((uint64_t)effectiveRate > (uint64_t)mSampleRate * 924 (uint64_t)AUDIO_RESAMPLER_DOWN_RATIO_MAX) { 925 ALOGW("setPlaybackRate(%f, %f) failed. Resample rate exceeds max accepted value", 926 playbackRate.mSpeed, playbackRate.mPitch); 927 return BAD_VALUE; 928 } 929 930 if ((uint64_t)effectiveRate * (uint64_t)AUDIO_RESAMPLER_UP_RATIO_MAX < (uint64_t)mSampleRate) { 931 ALOGW("setPlaybackRate(%f, %f) failed. Resample rate below min accepted value", 932 playbackRate.mSpeed, playbackRate.mPitch); 933 return BAD_VALUE; 934 } 935 mPlaybackRate = playbackRate; 936 //set effective rates 937 mProxy->setPlaybackRate(playbackRateTemp); 938 mProxy->setSampleRate(effectiveRate); // FIXME: not quite "atomic" with setPlaybackRate 939 return NO_ERROR; 940} 941 942const AudioPlaybackRate& AudioTrack::getPlaybackRate() const 943{ 944 AutoMutex lock(mLock); 945 return mPlaybackRate; 946} 947 948ssize_t AudioTrack::getBufferSizeInFrames() 949{ 950 AutoMutex lock(mLock); 951 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) { 952 return NO_INIT; 953 } 954 return (ssize_t) mProxy->getBufferSizeInFrames(); 955} 956 957status_t AudioTrack::getBufferDurationInUs(int64_t *duration) 958{ 959 if (duration == nullptr) { 960 return BAD_VALUE; 961 } 962 AutoMutex lock(mLock); 963 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) { 964 return NO_INIT; 965 } 966 ssize_t bufferSizeInFrames = (ssize_t) mProxy->getBufferSizeInFrames(); 967 if (bufferSizeInFrames < 0) { 968 return (status_t)bufferSizeInFrames; 969 } 970 *duration = (int64_t)((double)bufferSizeInFrames * 1000000 971 / ((double)mSampleRate * mPlaybackRate.mSpeed)); 972 return NO_ERROR; 973} 974 975ssize_t AudioTrack::setBufferSizeInFrames(size_t bufferSizeInFrames) 976{ 977 AutoMutex lock(mLock); 978 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) { 979 return NO_INIT; 980 } 981 // Reject if timed track or compressed audio. 982 if (!audio_is_linear_pcm(mFormat)) { 983 return INVALID_OPERATION; 984 } 985 return (ssize_t) mProxy->setBufferSizeInFrames((uint32_t) bufferSizeInFrames); 986} 987 988status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount) 989{ 990 if (mSharedBuffer == 0 || isOffloadedOrDirect()) { 991 return INVALID_OPERATION; 992 } 993 994 if (loopCount == 0) { 995 ; 996 } else if (loopCount >= -1 && loopStart < loopEnd && loopEnd <= mFrameCount && 997 loopEnd - loopStart >= MIN_LOOP) { 998 ; 999 } else { 1000 return BAD_VALUE; 1001 } 1002 1003 AutoMutex lock(mLock); 1004 // See setPosition() regarding setting parameters such as loop points or position while active 1005 if (mState == STATE_ACTIVE) { 1006 return INVALID_OPERATION; 1007 } 1008 setLoop_l(loopStart, loopEnd, loopCount); 1009 return NO_ERROR; 1010} 1011 1012void AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount) 1013{ 1014 // We do not update the periodic notification point. 1015 // mNewPosition = updateAndGetPosition_l() + mUpdatePeriod; 1016 mLoopCount = loopCount; 1017 mLoopEnd = loopEnd; 1018 mLoopStart = loopStart; 1019 mLoopCountNotified = loopCount; 1020 mStaticProxy->setLoop(loopStart, loopEnd, loopCount); 1021 1022 // Waking the AudioTrackThread is not needed as this cannot be called when active. 1023} 1024 1025status_t AudioTrack::setMarkerPosition(uint32_t marker) 1026{ 1027 // The only purpose of setting marker position is to get a callback 1028 if (mCbf == NULL || isOffloadedOrDirect()) { 1029 return INVALID_OPERATION; 1030 } 1031 1032 AutoMutex lock(mLock); 1033 mMarkerPosition = marker; 1034 mMarkerReached = false; 1035 1036 sp<AudioTrackThread> t = mAudioTrackThread; 1037 if (t != 0) { 1038 t->wake(); 1039 } 1040 return NO_ERROR; 1041} 1042 1043status_t AudioTrack::getMarkerPosition(uint32_t *marker) const 1044{ 1045 if (isOffloadedOrDirect()) { 1046 return INVALID_OPERATION; 1047 } 1048 if (marker == NULL) { 1049 return BAD_VALUE; 1050 } 1051 1052 AutoMutex lock(mLock); 1053 mMarkerPosition.getValue(marker); 1054 1055 return NO_ERROR; 1056} 1057 1058status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod) 1059{ 1060 // The only purpose of setting position update period is to get a callback 1061 if (mCbf == NULL || isOffloadedOrDirect()) { 1062 return INVALID_OPERATION; 1063 } 1064 1065 AutoMutex lock(mLock); 1066 mNewPosition = updateAndGetPosition_l() + updatePeriod; 1067 mUpdatePeriod = updatePeriod; 1068 1069 sp<AudioTrackThread> t = mAudioTrackThread; 1070 if (t != 0) { 1071 t->wake(); 1072 } 1073 return NO_ERROR; 1074} 1075 1076status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const 1077{ 1078 if (isOffloadedOrDirect()) { 1079 return INVALID_OPERATION; 1080 } 1081 if (updatePeriod == NULL) { 1082 return BAD_VALUE; 1083 } 1084 1085 AutoMutex lock(mLock); 1086 *updatePeriod = mUpdatePeriod; 1087 1088 return NO_ERROR; 1089} 1090 1091status_t AudioTrack::setPosition(uint32_t position) 1092{ 1093 if (mSharedBuffer == 0 || isOffloadedOrDirect()) { 1094 return INVALID_OPERATION; 1095 } 1096 if (position > mFrameCount) { 1097 return BAD_VALUE; 1098 } 1099 1100 AutoMutex lock(mLock); 1101 // Currently we require that the player is inactive before setting parameters such as position 1102 // or loop points. Otherwise, there could be a race condition: the application could read the 1103 // current position, compute a new position or loop parameters, and then set that position or 1104 // loop parameters but it would do the "wrong" thing since the position has continued to advance 1105 // in the mean time. If we ever provide a sequencer in server, we could allow a way for the app 1106 // to specify how it wants to handle such scenarios. 1107 if (mState == STATE_ACTIVE) { 1108 return INVALID_OPERATION; 1109 } 1110 // After setting the position, use full update period before notification. 1111 mNewPosition = updateAndGetPosition_l() + mUpdatePeriod; 1112 mStaticProxy->setBufferPosition(position); 1113 1114 // Waking the AudioTrackThread is not needed as this cannot be called when active. 1115 return NO_ERROR; 1116} 1117 1118status_t AudioTrack::getPosition(uint32_t *position) 1119{ 1120 if (position == NULL) { 1121 return BAD_VALUE; 1122 } 1123 1124 AutoMutex lock(mLock); 1125 // FIXME: offloaded and direct tracks call into the HAL for render positions 1126 // for compressed/synced data; however, we use proxy position for pure linear pcm data 1127 // as we do not know the capability of the HAL for pcm position support and standby. 1128 // There may be some latency differences between the HAL position and the proxy position. 1129 if (isOffloadedOrDirect_l() && !isPurePcmData_l()) { 1130 uint32_t dspFrames = 0; 1131 1132 if (isOffloaded_l() && ((mState == STATE_PAUSED) || (mState == STATE_PAUSED_STOPPING))) { 1133 ALOGV("getPosition called in paused state, return cached position %u", mPausedPosition); 1134 *position = mPausedPosition; 1135 return NO_ERROR; 1136 } 1137 1138 if (mOutput != AUDIO_IO_HANDLE_NONE) { 1139 uint32_t halFrames; // actually unused 1140 (void) AudioSystem::getRenderPosition(mOutput, &halFrames, &dspFrames); 1141 // FIXME: on getRenderPosition() error, we return OK with frame position 0. 1142 } 1143 // FIXME: dspFrames may not be zero in (mState == STATE_STOPPED || mState == STATE_FLUSHED) 1144 // due to hardware latency. We leave this behavior for now. 1145 *position = dspFrames; 1146 } else { 1147 if (mCblk->mFlags & CBLK_INVALID) { 1148 (void) restoreTrack_l("getPosition"); 1149 // FIXME: for compatibility with the Java API we ignore the restoreTrack_l() 1150 // error here (e.g. DEAD_OBJECT) and return OK with the last recorded server position. 1151 } 1152 1153 // IAudioTrack::stop() isn't synchronous; we don't know when presentation completes 1154 *position = (mState == STATE_STOPPED || mState == STATE_FLUSHED) ? 1155 0 : updateAndGetPosition_l().value(); 1156 } 1157 return NO_ERROR; 1158} 1159 1160status_t AudioTrack::getBufferPosition(uint32_t *position) 1161{ 1162 if (mSharedBuffer == 0) { 1163 return INVALID_OPERATION; 1164 } 1165 if (position == NULL) { 1166 return BAD_VALUE; 1167 } 1168 1169 AutoMutex lock(mLock); 1170 *position = mStaticProxy->getBufferPosition(); 1171 return NO_ERROR; 1172} 1173 1174status_t AudioTrack::reload() 1175{ 1176 if (mSharedBuffer == 0 || isOffloadedOrDirect()) { 1177 return INVALID_OPERATION; 1178 } 1179 1180 AutoMutex lock(mLock); 1181 // See setPosition() regarding setting parameters such as loop points or position while active 1182 if (mState == STATE_ACTIVE) { 1183 return INVALID_OPERATION; 1184 } 1185 mNewPosition = mUpdatePeriod; 1186 (void) updateAndGetPosition_l(); 1187 mPosition = 0; 1188 mPreviousTimestampValid = false; 1189#if 0 1190 // The documentation is not clear on the behavior of reload() and the restoration 1191 // of loop count. Historically we have not restored loop count, start, end, 1192 // but it makes sense if one desires to repeat playing a particular sound. 1193 if (mLoopCount != 0) { 1194 mLoopCountNotified = mLoopCount; 1195 mStaticProxy->setLoop(mLoopStart, mLoopEnd, mLoopCount); 1196 } 1197#endif 1198 mStaticProxy->setBufferPosition(0); 1199 return NO_ERROR; 1200} 1201 1202audio_io_handle_t AudioTrack::getOutput() const 1203{ 1204 AutoMutex lock(mLock); 1205 return mOutput; 1206} 1207 1208status_t AudioTrack::setOutputDevice(audio_port_handle_t deviceId) { 1209 AutoMutex lock(mLock); 1210 if (mSelectedDeviceId != deviceId) { 1211 mSelectedDeviceId = deviceId; 1212 android_atomic_or(CBLK_INVALID, &mCblk->mFlags); 1213 } 1214 return NO_ERROR; 1215} 1216 1217audio_port_handle_t AudioTrack::getOutputDevice() { 1218 AutoMutex lock(mLock); 1219 return mSelectedDeviceId; 1220} 1221 1222audio_port_handle_t AudioTrack::getRoutedDeviceId() { 1223 AutoMutex lock(mLock); 1224 if (mOutput == AUDIO_IO_HANDLE_NONE) { 1225 return AUDIO_PORT_HANDLE_NONE; 1226 } 1227 return AudioSystem::getDeviceIdForIo(mOutput); 1228} 1229 1230status_t AudioTrack::attachAuxEffect(int effectId) 1231{ 1232 AutoMutex lock(mLock); 1233 status_t status = mAudioTrack->attachAuxEffect(effectId); 1234 if (status == NO_ERROR) { 1235 mAuxEffectId = effectId; 1236 } 1237 return status; 1238} 1239 1240audio_stream_type_t AudioTrack::streamType() const 1241{ 1242 if (mStreamType == AUDIO_STREAM_DEFAULT) { 1243 return audio_attributes_to_stream_type(&mAttributes); 1244 } 1245 return mStreamType; 1246} 1247 1248// ------------------------------------------------------------------------- 1249 1250// must be called with mLock held 1251status_t AudioTrack::createTrack_l() 1252{ 1253 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); 1254 if (audioFlinger == 0) { 1255 ALOGE("Could not get audioflinger"); 1256 return NO_INIT; 1257 } 1258 1259 if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) { 1260 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput); 1261 } 1262 audio_io_handle_t output; 1263 audio_stream_type_t streamType = mStreamType; 1264 audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL; 1265 1266 // mFlags (not mOrigFlags) is modified depending on whether fast request is accepted. 1267 // After fast request is denied, we will request again if IAudioTrack is re-created. 1268 1269 status_t status; 1270 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 1271 config.sample_rate = mSampleRate; 1272 config.channel_mask = mChannelMask; 1273 config.format = mFormat; 1274 config.offload_info = mOffloadInfoCopy; 1275 status = AudioSystem::getOutputForAttr(attr, &output, 1276 mSessionId, &streamType, mClientUid, 1277 &config, 1278 mFlags, mSelectedDeviceId, &mPortId); 1279 1280 if (status != NO_ERROR || output == AUDIO_IO_HANDLE_NONE) { 1281 ALOGE("Could not get audio output for session %d, stream type %d, usage %d, sample rate %u," 1282 " format %#x, channel mask %#x, flags %#x", 1283 mSessionId, streamType, mAttributes.usage, mSampleRate, mFormat, mChannelMask, 1284 mFlags); 1285 return BAD_VALUE; 1286 } 1287 { 1288 // Now that we have a reference to an I/O handle and have not yet handed it off to AudioFlinger, 1289 // we must release it ourselves if anything goes wrong. 1290 1291 // Not all of these values are needed under all conditions, but it is easier to get them all 1292 status = AudioSystem::getLatency(output, &mAfLatency); 1293 if (status != NO_ERROR) { 1294 ALOGE("getLatency(%d) failed status %d", output, status); 1295 goto release; 1296 } 1297 ALOGV("createTrack_l() output %d afLatency %u", output, mAfLatency); 1298 1299 status = AudioSystem::getFrameCount(output, &mAfFrameCount); 1300 if (status != NO_ERROR) { 1301 ALOGE("getFrameCount(output=%d) status %d", output, status); 1302 goto release; 1303 } 1304 1305 // TODO consider making this a member variable if there are other uses for it later 1306 size_t afFrameCountHAL; 1307 status = AudioSystem::getFrameCountHAL(output, &afFrameCountHAL); 1308 if (status != NO_ERROR) { 1309 ALOGE("getFrameCountHAL(output=%d) status %d", output, status); 1310 goto release; 1311 } 1312 ALOG_ASSERT(afFrameCountHAL > 0); 1313 1314 status = AudioSystem::getSamplingRate(output, &mAfSampleRate); 1315 if (status != NO_ERROR) { 1316 ALOGE("getSamplingRate(output=%d) status %d", output, status); 1317 goto release; 1318 } 1319 if (mSampleRate == 0) { 1320 mSampleRate = mAfSampleRate; 1321 mOriginalSampleRate = mAfSampleRate; 1322 } 1323 1324 // Client can only express a preference for FAST. Server will perform additional tests. 1325 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 1326 bool useCaseAllowed = 1327 // either of these use cases: 1328 // use case 1: shared buffer 1329 (mSharedBuffer != 0) || 1330 // use case 2: callback transfer mode 1331 (mTransfer == TRANSFER_CALLBACK) || 1332 // use case 3: obtain/release mode 1333 (mTransfer == TRANSFER_OBTAIN) || 1334 // use case 4: synchronous write 1335 ((mTransfer == TRANSFER_SYNC) && mThreadCanCallJava); 1336 // sample rates must also match 1337 bool fastAllowed = useCaseAllowed && (mSampleRate == mAfSampleRate); 1338 if (!fastAllowed) { 1339 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client; transfer %d, " 1340 "track %u Hz, output %u Hz", 1341 mTransfer, mSampleRate, mAfSampleRate); 1342 mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST); 1343 } 1344 } 1345 1346 mNotificationFramesAct = mNotificationFramesReq; 1347 1348 size_t frameCount = mReqFrameCount; 1349 if (!audio_has_proportional_frames(mFormat)) { 1350 1351 if (mSharedBuffer != 0) { 1352 // Same comment as below about ignoring frameCount parameter for set() 1353 frameCount = mSharedBuffer->size(); 1354 } else if (frameCount == 0) { 1355 frameCount = mAfFrameCount; 1356 } 1357 if (mNotificationFramesAct != frameCount) { 1358 mNotificationFramesAct = frameCount; 1359 } 1360 } else if (mSharedBuffer != 0) { 1361 // FIXME: Ensure client side memory buffers need 1362 // not have additional alignment beyond sample 1363 // (e.g. 16 bit stereo accessed as 32 bit frame). 1364 size_t alignment = audio_bytes_per_sample(mFormat); 1365 if (alignment & 1) { 1366 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java). 1367 alignment = 1; 1368 } 1369 if (mChannelCount > 1) { 1370 // More than 2 channels does not require stronger alignment than stereo 1371 alignment <<= 1; 1372 } 1373 if (((uintptr_t)mSharedBuffer->pointer() & (alignment - 1)) != 0) { 1374 ALOGE("Invalid buffer alignment: address %p, channel count %u", 1375 mSharedBuffer->pointer(), mChannelCount); 1376 status = BAD_VALUE; 1377 goto release; 1378 } 1379 1380 // When initializing a shared buffer AudioTrack via constructors, 1381 // there's no frameCount parameter. 1382 // But when initializing a shared buffer AudioTrack via set(), 1383 // there _is_ a frameCount parameter. We silently ignore it. 1384 frameCount = mSharedBuffer->size() / mFrameSize; 1385 } else { 1386 size_t minFrameCount = 0; 1387 // For fast tracks the frame count calculations and checks are mostly done by server, 1388 // but we try to respect the application's request for notifications per buffer. 1389 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 1390 if (mNotificationsPerBufferReq > 0) { 1391 // Avoid possible arithmetic overflow during multiplication. 1392 // mNotificationsPerBuffer is clamped to a small integer earlier, so it is unlikely. 1393 if (mNotificationsPerBufferReq > SIZE_MAX / afFrameCountHAL) { 1394 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu", 1395 mNotificationsPerBufferReq, afFrameCountHAL); 1396 } else { 1397 minFrameCount = afFrameCountHAL * mNotificationsPerBufferReq; 1398 } 1399 } 1400 } else { 1401 // for normal tracks precompute the frame count based on speed. 1402 const float speed = !isPurePcmData_l() || isOffloadedOrDirect_l() ? 1.0f : 1403 max(mMaxRequiredSpeed, mPlaybackRate.mSpeed); 1404 minFrameCount = calculateMinFrameCount( 1405 mAfLatency, mAfFrameCount, mAfSampleRate, mSampleRate, 1406 speed /*, 0 mNotificationsPerBufferReq*/); 1407 } 1408 if (frameCount < minFrameCount) { 1409 frameCount = minFrameCount; 1410 } 1411 } 1412 1413 audio_output_flags_t flags = mFlags; 1414 1415 pid_t tid = -1; 1416 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 1417 if (mAudioTrackThread != 0 && !mThreadCanCallJava) { 1418 tid = mAudioTrackThread->getTid(); 1419 } 1420 } 1421 1422 size_t temp = frameCount; // temp may be replaced by a revised value of frameCount, 1423 // but we will still need the original value also 1424 audio_session_t originalSessionId = mSessionId; 1425 sp<IAudioTrack> track = audioFlinger->createTrack(streamType, 1426 mSampleRate, 1427 mFormat, 1428 mChannelMask, 1429 &temp, 1430 &flags, 1431 mSharedBuffer, 1432 output, 1433 mClientPid, 1434 tid, 1435 &mSessionId, 1436 mClientUid, 1437 &status, 1438 mPortId); 1439 ALOGE_IF(originalSessionId != AUDIO_SESSION_ALLOCATE && mSessionId != originalSessionId, 1440 "session ID changed from %d to %d", originalSessionId, mSessionId); 1441 1442 if (status != NO_ERROR) { 1443 ALOGE("AudioFlinger could not create track, status: %d", status); 1444 goto release; 1445 } 1446 ALOG_ASSERT(track != 0); 1447 1448 // AudioFlinger now owns the reference to the I/O handle, 1449 // so we are no longer responsible for releasing it. 1450 1451 // FIXME compare to AudioRecord 1452 sp<IMemory> iMem = track->getCblk(); 1453 if (iMem == 0) { 1454 ALOGE("Could not get control block"); 1455 return NO_INIT; 1456 } 1457 void *iMemPointer = iMem->pointer(); 1458 if (iMemPointer == NULL) { 1459 ALOGE("Could not get control block pointer"); 1460 return NO_INIT; 1461 } 1462 // invariant that mAudioTrack != 0 is true only after set() returns successfully 1463 if (mAudioTrack != 0) { 1464 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this); 1465 mDeathNotifier.clear(); 1466 } 1467 mAudioTrack = track; 1468 mCblkMemory = iMem; 1469 IPCThreadState::self()->flushCommands(); 1470 1471 audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer); 1472 mCblk = cblk; 1473 // note that temp is the (possibly revised) value of frameCount 1474 if (temp < frameCount || (frameCount == 0 && temp == 0)) { 1475 // In current design, AudioTrack client checks and ensures frame count validity before 1476 // passing it to AudioFlinger so AudioFlinger should not return a different value except 1477 // for fast track as it uses a special method of assigning frame count. 1478 ALOGW("Requested frameCount %zu but received frameCount %zu", frameCount, temp); 1479 } 1480 frameCount = temp; 1481 1482 mAwaitBoost = false; 1483 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 1484 if (flags & AUDIO_OUTPUT_FLAG_FAST) { 1485 ALOGI("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %zu -> %zu", frameCount, temp); 1486 if (!mThreadCanCallJava) { 1487 mAwaitBoost = true; 1488 } 1489 } else { 1490 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu -> %zu", frameCount, 1491 temp); 1492 } 1493 } 1494 mFlags = flags; 1495 1496 // Make sure that application is notified with sufficient margin before underrun. 1497 // The client can divide the AudioTrack buffer into sub-buffers, 1498 // and expresses its desire to server as the notification frame count. 1499 if (mSharedBuffer == 0 && audio_is_linear_pcm(mFormat)) { 1500 size_t maxNotificationFrames; 1501 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) { 1502 // notify every HAL buffer, regardless of the size of the track buffer 1503 maxNotificationFrames = afFrameCountHAL; 1504 } else { 1505 // For normal tracks, use at least double-buffering if no sample rate conversion, 1506 // or at least triple-buffering if there is sample rate conversion 1507 const int nBuffering = mOriginalSampleRate == mAfSampleRate ? 2 : 3; 1508 maxNotificationFrames = frameCount / nBuffering; 1509 } 1510 if (mNotificationFramesAct == 0 || mNotificationFramesAct > maxNotificationFrames) { 1511 if (mNotificationFramesAct == 0) { 1512 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu", 1513 maxNotificationFrames, frameCount); 1514 } else { 1515 ALOGW("Client adjusted notificationFrames from %u to %zu for frameCount %zu", 1516 mNotificationFramesAct, maxNotificationFrames, frameCount); 1517 } 1518 mNotificationFramesAct = (uint32_t) maxNotificationFrames; 1519 } 1520 } 1521 1522 // We retain a copy of the I/O handle, but don't own the reference 1523 mOutput = output; 1524 mRefreshRemaining = true; 1525 1526 // Starting address of buffers in shared memory. If there is a shared buffer, buffers 1527 // is the value of pointer() for the shared buffer, otherwise buffers points 1528 // immediately after the control block. This address is for the mapping within client 1529 // address space. AudioFlinger::TrackBase::mBuffer is for the server address space. 1530 void* buffers; 1531 if (mSharedBuffer == 0) { 1532 buffers = cblk + 1; 1533 } else { 1534 buffers = mSharedBuffer->pointer(); 1535 if (buffers == NULL) { 1536 ALOGE("Could not get buffer pointer"); 1537 return NO_INIT; 1538 } 1539 } 1540 1541 mAudioTrack->attachAuxEffect(mAuxEffectId); 1542 // FIXME doesn't take into account speed or future sample rate changes (until restoreTrack) 1543 // FIXME don't believe this lie 1544 mLatency = mAfLatency + (1000*frameCount) / mSampleRate; 1545 1546 mFrameCount = frameCount; 1547 // If IAudioTrack is re-created, don't let the requested frameCount 1548 // decrease. This can confuse clients that cache frameCount(). 1549 if (frameCount > mReqFrameCount) { 1550 mReqFrameCount = frameCount; 1551 } 1552 1553 // reset server position to 0 as we have new cblk. 1554 mServer = 0; 1555 1556 // update proxy 1557 if (mSharedBuffer == 0) { 1558 mStaticProxy.clear(); 1559 mProxy = new AudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize); 1560 } else { 1561 mStaticProxy = new StaticAudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize); 1562 mProxy = mStaticProxy; 1563 } 1564 1565 mProxy->setVolumeLR(gain_minifloat_pack( 1566 gain_from_float(mVolume[AUDIO_INTERLEAVE_LEFT]), 1567 gain_from_float(mVolume[AUDIO_INTERLEAVE_RIGHT]))); 1568 1569 mProxy->setSendLevel(mSendLevel); 1570 const uint32_t effectiveSampleRate = adjustSampleRate(mSampleRate, mPlaybackRate.mPitch); 1571 const float effectiveSpeed = adjustSpeed(mPlaybackRate.mSpeed, mPlaybackRate.mPitch); 1572 const float effectivePitch = adjustPitch(mPlaybackRate.mPitch); 1573 mProxy->setSampleRate(effectiveSampleRate); 1574 1575 AudioPlaybackRate playbackRateTemp = mPlaybackRate; 1576 playbackRateTemp.mSpeed = effectiveSpeed; 1577 playbackRateTemp.mPitch = effectivePitch; 1578 mProxy->setPlaybackRate(playbackRateTemp); 1579 mProxy->setMinimum(mNotificationFramesAct); 1580 1581 mDeathNotifier = new DeathNotifier(this); 1582 IInterface::asBinder(mAudioTrack)->linkToDeath(mDeathNotifier, this); 1583 1584 if (mDeviceCallback != 0) { 1585 AudioSystem::addAudioDeviceCallback(mDeviceCallback, mOutput); 1586 } 1587 1588 return NO_ERROR; 1589 } 1590 1591release: 1592 AudioSystem::releaseOutput(output, streamType, mSessionId); 1593 if (status == NO_ERROR) { 1594 status = NO_INIT; 1595 } 1596 return status; 1597} 1598 1599status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount, size_t *nonContig) 1600{ 1601 if (audioBuffer == NULL) { 1602 if (nonContig != NULL) { 1603 *nonContig = 0; 1604 } 1605 return BAD_VALUE; 1606 } 1607 if (mTransfer != TRANSFER_OBTAIN) { 1608 audioBuffer->frameCount = 0; 1609 audioBuffer->size = 0; 1610 audioBuffer->raw = NULL; 1611 if (nonContig != NULL) { 1612 *nonContig = 0; 1613 } 1614 return INVALID_OPERATION; 1615 } 1616 1617 const struct timespec *requested; 1618 struct timespec timeout; 1619 if (waitCount == -1) { 1620 requested = &ClientProxy::kForever; 1621 } else if (waitCount == 0) { 1622 requested = &ClientProxy::kNonBlocking; 1623 } else if (waitCount > 0) { 1624 long long ms = WAIT_PERIOD_MS * (long long) waitCount; 1625 timeout.tv_sec = ms / 1000; 1626 timeout.tv_nsec = (int) (ms % 1000) * 1000000; 1627 requested = &timeout; 1628 } else { 1629 ALOGE("%s invalid waitCount %d", __func__, waitCount); 1630 requested = NULL; 1631 } 1632 return obtainBuffer(audioBuffer, requested, NULL /*elapsed*/, nonContig); 1633} 1634 1635status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, const struct timespec *requested, 1636 struct timespec *elapsed, size_t *nonContig) 1637{ 1638 // previous and new IAudioTrack sequence numbers are used to detect track re-creation 1639 uint32_t oldSequence = 0; 1640 uint32_t newSequence; 1641 1642 Proxy::Buffer buffer; 1643 status_t status = NO_ERROR; 1644 1645 static const int32_t kMaxTries = 5; 1646 int32_t tryCounter = kMaxTries; 1647 1648 do { 1649 // obtainBuffer() is called with mutex unlocked, so keep extra references to these fields to 1650 // keep them from going away if another thread re-creates the track during obtainBuffer() 1651 sp<AudioTrackClientProxy> proxy; 1652 sp<IMemory> iMem; 1653 1654 { // start of lock scope 1655 AutoMutex lock(mLock); 1656 1657 newSequence = mSequence; 1658 // did previous obtainBuffer() fail due to media server death or voluntary invalidation? 1659 if (status == DEAD_OBJECT) { 1660 // re-create track, unless someone else has already done so 1661 if (newSequence == oldSequence) { 1662 status = restoreTrack_l("obtainBuffer"); 1663 if (status != NO_ERROR) { 1664 buffer.mFrameCount = 0; 1665 buffer.mRaw = NULL; 1666 buffer.mNonContig = 0; 1667 break; 1668 } 1669 } 1670 } 1671 oldSequence = newSequence; 1672 1673 if (status == NOT_ENOUGH_DATA) { 1674 restartIfDisabled(); 1675 } 1676 1677 // Keep the extra references 1678 proxy = mProxy; 1679 iMem = mCblkMemory; 1680 1681 if (mState == STATE_STOPPING) { 1682 status = -EINTR; 1683 buffer.mFrameCount = 0; 1684 buffer.mRaw = NULL; 1685 buffer.mNonContig = 0; 1686 break; 1687 } 1688 1689 // Non-blocking if track is stopped or paused 1690 if (mState != STATE_ACTIVE) { 1691 requested = &ClientProxy::kNonBlocking; 1692 } 1693 1694 } // end of lock scope 1695 1696 buffer.mFrameCount = audioBuffer->frameCount; 1697 // FIXME starts the requested timeout and elapsed over from scratch 1698 status = proxy->obtainBuffer(&buffer, requested, elapsed); 1699 } while (((status == DEAD_OBJECT) || (status == NOT_ENOUGH_DATA)) && (tryCounter-- > 0)); 1700 1701 audioBuffer->frameCount = buffer.mFrameCount; 1702 audioBuffer->size = buffer.mFrameCount * mFrameSize; 1703 audioBuffer->raw = buffer.mRaw; 1704 if (nonContig != NULL) { 1705 *nonContig = buffer.mNonContig; 1706 } 1707 return status; 1708} 1709 1710void AudioTrack::releaseBuffer(const Buffer* audioBuffer) 1711{ 1712 // FIXME add error checking on mode, by adding an internal version 1713 if (mTransfer == TRANSFER_SHARED) { 1714 return; 1715 } 1716 1717 size_t stepCount = audioBuffer->size / mFrameSize; 1718 if (stepCount == 0) { 1719 return; 1720 } 1721 1722 Proxy::Buffer buffer; 1723 buffer.mFrameCount = stepCount; 1724 buffer.mRaw = audioBuffer->raw; 1725 1726 AutoMutex lock(mLock); 1727 mReleased += stepCount; 1728 mInUnderrun = false; 1729 mProxy->releaseBuffer(&buffer); 1730 1731 // restart track if it was disabled by audioflinger due to previous underrun 1732 restartIfDisabled(); 1733} 1734 1735void AudioTrack::restartIfDisabled() 1736{ 1737 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags); 1738 if ((mState == STATE_ACTIVE) && (flags & CBLK_DISABLED)) { 1739 ALOGW("releaseBuffer() track %p disabled due to previous underrun, restarting", this); 1740 // FIXME ignoring status 1741 mAudioTrack->start(); 1742 } 1743} 1744 1745// ------------------------------------------------------------------------- 1746 1747ssize_t AudioTrack::write(const void* buffer, size_t userSize, bool blocking) 1748{ 1749 if (mTransfer != TRANSFER_SYNC) { 1750 return INVALID_OPERATION; 1751 } 1752 1753 if (isDirect()) { 1754 AutoMutex lock(mLock); 1755 int32_t flags = android_atomic_and( 1756 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END), 1757 &mCblk->mFlags); 1758 if (flags & CBLK_INVALID) { 1759 return DEAD_OBJECT; 1760 } 1761 } 1762 1763 if (ssize_t(userSize) < 0 || (buffer == NULL && userSize != 0)) { 1764 // Sanity-check: user is most-likely passing an error code, and it would 1765 // make the return value ambiguous (actualSize vs error). 1766 ALOGE("AudioTrack::write(buffer=%p, size=%zu (%zd)", buffer, userSize, userSize); 1767 return BAD_VALUE; 1768 } 1769 1770 size_t written = 0; 1771 Buffer audioBuffer; 1772 1773 while (userSize >= mFrameSize) { 1774 audioBuffer.frameCount = userSize / mFrameSize; 1775 1776 status_t err = obtainBuffer(&audioBuffer, 1777 blocking ? &ClientProxy::kForever : &ClientProxy::kNonBlocking); 1778 if (err < 0) { 1779 if (written > 0) { 1780 break; 1781 } 1782 if (err == TIMED_OUT || err == -EINTR) { 1783 err = WOULD_BLOCK; 1784 } 1785 return ssize_t(err); 1786 } 1787 1788 size_t toWrite = audioBuffer.size; 1789 memcpy(audioBuffer.i8, buffer, toWrite); 1790 buffer = ((const char *) buffer) + toWrite; 1791 userSize -= toWrite; 1792 written += toWrite; 1793 1794 releaseBuffer(&audioBuffer); 1795 } 1796 1797 if (written > 0) { 1798 mFramesWritten += written / mFrameSize; 1799 } 1800 return written; 1801} 1802 1803// ------------------------------------------------------------------------- 1804 1805nsecs_t AudioTrack::processAudioBuffer() 1806{ 1807 // Currently the AudioTrack thread is not created if there are no callbacks. 1808 // Would it ever make sense to run the thread, even without callbacks? 1809 // If so, then replace this by checks at each use for mCbf != NULL. 1810 LOG_ALWAYS_FATAL_IF(mCblk == NULL); 1811 1812 mLock.lock(); 1813 if (mAwaitBoost) { 1814 mAwaitBoost = false; 1815 mLock.unlock(); 1816 static const int32_t kMaxTries = 5; 1817 int32_t tryCounter = kMaxTries; 1818 uint32_t pollUs = 10000; 1819 do { 1820 int policy = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK; 1821 if (policy == SCHED_FIFO || policy == SCHED_RR) { 1822 break; 1823 } 1824 usleep(pollUs); 1825 pollUs <<= 1; 1826 } while (tryCounter-- > 0); 1827 if (tryCounter < 0) { 1828 ALOGE("did not receive expected priority boost on time"); 1829 } 1830 // Run again immediately 1831 return 0; 1832 } 1833 1834 // Can only reference mCblk while locked 1835 int32_t flags = android_atomic_and( 1836 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END), &mCblk->mFlags); 1837 1838 // Check for track invalidation 1839 if (flags & CBLK_INVALID) { 1840 // for offloaded tracks restoreTrack_l() will just update the sequence and clear 1841 // AudioSystem cache. We should not exit here but after calling the callback so 1842 // that the upper layers can recreate the track 1843 if (!isOffloadedOrDirect_l() || (mSequence == mObservedSequence)) { 1844 status_t status __unused = restoreTrack_l("processAudioBuffer"); 1845 // FIXME unused status 1846 // after restoration, continue below to make sure that the loop and buffer events 1847 // are notified because they have been cleared from mCblk->mFlags above. 1848 } 1849 } 1850 1851 bool waitStreamEnd = mState == STATE_STOPPING; 1852 bool active = mState == STATE_ACTIVE; 1853 1854 // Manage underrun callback, must be done under lock to avoid race with releaseBuffer() 1855 bool newUnderrun = false; 1856 if (flags & CBLK_UNDERRUN) { 1857#if 0 1858 // Currently in shared buffer mode, when the server reaches the end of buffer, 1859 // the track stays active in continuous underrun state. It's up to the application 1860 // to pause or stop the track, or set the position to a new offset within buffer. 1861 // This was some experimental code to auto-pause on underrun. Keeping it here 1862 // in "if 0" so we can re-visit this if we add a real sequencer for shared memory content. 1863 if (mTransfer == TRANSFER_SHARED) { 1864 mState = STATE_PAUSED; 1865 active = false; 1866 } 1867#endif 1868 if (!mInUnderrun) { 1869 mInUnderrun = true; 1870 newUnderrun = true; 1871 } 1872 } 1873 1874 // Get current position of server 1875 Modulo<uint32_t> position(updateAndGetPosition_l()); 1876 1877 // Manage marker callback 1878 bool markerReached = false; 1879 Modulo<uint32_t> markerPosition(mMarkerPosition); 1880 // uses 32 bit wraparound for comparison with position. 1881 if (!mMarkerReached && markerPosition.value() > 0 && position >= markerPosition) { 1882 mMarkerReached = markerReached = true; 1883 } 1884 1885 // Determine number of new position callback(s) that will be needed, while locked 1886 size_t newPosCount = 0; 1887 Modulo<uint32_t> newPosition(mNewPosition); 1888 uint32_t updatePeriod = mUpdatePeriod; 1889 // FIXME fails for wraparound, need 64 bits 1890 if (updatePeriod > 0 && position >= newPosition) { 1891 newPosCount = ((position - newPosition).value() / updatePeriod) + 1; 1892 mNewPosition += updatePeriod * newPosCount; 1893 } 1894 1895 // Cache other fields that will be needed soon 1896 uint32_t sampleRate = mSampleRate; 1897 float speed = mPlaybackRate.mSpeed; 1898 const uint32_t notificationFrames = mNotificationFramesAct; 1899 if (mRefreshRemaining) { 1900 mRefreshRemaining = false; 1901 mRemainingFrames = notificationFrames; 1902 mRetryOnPartialBuffer = false; 1903 } 1904 size_t misalignment = mProxy->getMisalignment(); 1905 uint32_t sequence = mSequence; 1906 sp<AudioTrackClientProxy> proxy = mProxy; 1907 1908 // Determine the number of new loop callback(s) that will be needed, while locked. 1909 int loopCountNotifications = 0; 1910 uint32_t loopPeriod = 0; // time in frames for next EVENT_LOOP_END or EVENT_BUFFER_END 1911 1912 if (mLoopCount > 0) { 1913 int loopCount; 1914 size_t bufferPosition; 1915 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount); 1916 loopPeriod = ((loopCount > 0) ? mLoopEnd : mFrameCount) - bufferPosition; 1917 loopCountNotifications = min(mLoopCountNotified - loopCount, kMaxLoopCountNotifications); 1918 mLoopCountNotified = loopCount; // discard any excess notifications 1919 } else if (mLoopCount < 0) { 1920 // FIXME: We're not accurate with notification count and position with infinite looping 1921 // since loopCount from server side will always return -1 (we could decrement it). 1922 size_t bufferPosition = mStaticProxy->getBufferPosition(); 1923 loopCountNotifications = int((flags & (CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL)) != 0); 1924 loopPeriod = mLoopEnd - bufferPosition; 1925 } else if (/* mLoopCount == 0 && */ mSharedBuffer != 0) { 1926 size_t bufferPosition = mStaticProxy->getBufferPosition(); 1927 loopPeriod = mFrameCount - bufferPosition; 1928 } 1929 1930 // These fields don't need to be cached, because they are assigned only by set(): 1931 // mTransfer, mCbf, mUserData, mFormat, mFrameSize, mFlags 1932 // mFlags is also assigned by createTrack_l(), but not the bit we care about. 1933 1934 mLock.unlock(); 1935 1936 // get anchor time to account for callbacks. 1937 const nsecs_t timeBeforeCallbacks = systemTime(); 1938 1939 if (waitStreamEnd) { 1940 // FIXME: Instead of blocking in proxy->waitStreamEndDone(), Callback thread 1941 // should wait on proxy futex and handle CBLK_STREAM_END_DONE within this function 1942 // (and make sure we don't callback for more data while we're stopping). 1943 // This helps with position, marker notifications, and track invalidation. 1944 struct timespec timeout; 1945 timeout.tv_sec = WAIT_STREAM_END_TIMEOUT_SEC; 1946 timeout.tv_nsec = 0; 1947 1948 status_t status = proxy->waitStreamEndDone(&timeout); 1949 switch (status) { 1950 case NO_ERROR: 1951 case DEAD_OBJECT: 1952 case TIMED_OUT: 1953 if (status != DEAD_OBJECT) { 1954 // for DEAD_OBJECT, we do not send a EVENT_STREAM_END after stop(); 1955 // instead, the application should handle the EVENT_NEW_IAUDIOTRACK. 1956 mCbf(EVENT_STREAM_END, mUserData, NULL); 1957 } 1958 { 1959 AutoMutex lock(mLock); 1960 // The previously assigned value of waitStreamEnd is no longer valid, 1961 // since the mutex has been unlocked and either the callback handler 1962 // or another thread could have re-started the AudioTrack during that time. 1963 waitStreamEnd = mState == STATE_STOPPING; 1964 if (waitStreamEnd) { 1965 mState = STATE_STOPPED; 1966 mReleased = 0; 1967 } 1968 } 1969 if (waitStreamEnd && status != DEAD_OBJECT) { 1970 return NS_INACTIVE; 1971 } 1972 break; 1973 } 1974 return 0; 1975 } 1976 1977 // perform callbacks while unlocked 1978 if (newUnderrun) { 1979 mCbf(EVENT_UNDERRUN, mUserData, NULL); 1980 } 1981 while (loopCountNotifications > 0) { 1982 mCbf(EVENT_LOOP_END, mUserData, NULL); 1983 --loopCountNotifications; 1984 } 1985 if (flags & CBLK_BUFFER_END) { 1986 mCbf(EVENT_BUFFER_END, mUserData, NULL); 1987 } 1988 if (markerReached) { 1989 mCbf(EVENT_MARKER, mUserData, &markerPosition); 1990 } 1991 while (newPosCount > 0) { 1992 size_t temp = newPosition.value(); // FIXME size_t != uint32_t 1993 mCbf(EVENT_NEW_POS, mUserData, &temp); 1994 newPosition += updatePeriod; 1995 newPosCount--; 1996 } 1997 1998 if (mObservedSequence != sequence) { 1999 mObservedSequence = sequence; 2000 mCbf(EVENT_NEW_IAUDIOTRACK, mUserData, NULL); 2001 // for offloaded tracks, just wait for the upper layers to recreate the track 2002 if (isOffloadedOrDirect()) { 2003 return NS_INACTIVE; 2004 } 2005 } 2006 2007 // if inactive, then don't run me again until re-started 2008 if (!active) { 2009 return NS_INACTIVE; 2010 } 2011 2012 // Compute the estimated time until the next timed event (position, markers, loops) 2013 // FIXME only for non-compressed audio 2014 uint32_t minFrames = ~0; 2015 if (!markerReached && position < markerPosition) { 2016 minFrames = (markerPosition - position).value(); 2017 } 2018 if (loopPeriod > 0 && loopPeriod < minFrames) { 2019 // loopPeriod is already adjusted for actual position. 2020 minFrames = loopPeriod; 2021 } 2022 if (updatePeriod > 0) { 2023 minFrames = min(minFrames, (newPosition - position).value()); 2024 } 2025 2026 // If > 0, poll periodically to recover from a stuck server. A good value is 2. 2027 static const uint32_t kPoll = 0; 2028 if (kPoll > 0 && mTransfer == TRANSFER_CALLBACK && kPoll * notificationFrames < minFrames) { 2029 minFrames = kPoll * notificationFrames; 2030 } 2031 2032 // This "fudge factor" avoids soaking CPU, and compensates for late progress by server 2033 static const nsecs_t kWaitPeriodNs = WAIT_PERIOD_MS * 1000000LL; 2034 const nsecs_t timeAfterCallbacks = systemTime(); 2035 2036 // Convert frame units to time units 2037 nsecs_t ns = NS_WHENEVER; 2038 if (minFrames != (uint32_t) ~0) { 2039 ns = framesToNanoseconds(minFrames, sampleRate, speed) + kWaitPeriodNs; 2040 ns -= (timeAfterCallbacks - timeBeforeCallbacks); // account for callback time 2041 // TODO: Should we warn if the callback time is too long? 2042 if (ns < 0) ns = 0; 2043 } 2044 2045 // If not supplying data by EVENT_MORE_DATA, then we're done 2046 if (mTransfer != TRANSFER_CALLBACK) { 2047 return ns; 2048 } 2049 2050 // EVENT_MORE_DATA callback handling. 2051 // Timing for linear pcm audio data formats can be derived directly from the 2052 // buffer fill level. 2053 // Timing for compressed data is not directly available from the buffer fill level, 2054 // rather indirectly from waiting for blocking mode callbacks or waiting for obtain() 2055 // to return a certain fill level. 2056 2057 struct timespec timeout; 2058 const struct timespec *requested = &ClientProxy::kForever; 2059 if (ns != NS_WHENEVER) { 2060 timeout.tv_sec = ns / 1000000000LL; 2061 timeout.tv_nsec = ns % 1000000000LL; 2062 ALOGV("timeout %ld.%03d", timeout.tv_sec, (int) timeout.tv_nsec / 1000000); 2063 requested = &timeout; 2064 } 2065 2066 size_t writtenFrames = 0; 2067 while (mRemainingFrames > 0) { 2068 2069 Buffer audioBuffer; 2070 audioBuffer.frameCount = mRemainingFrames; 2071 size_t nonContig; 2072 status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig); 2073 LOG_ALWAYS_FATAL_IF((err != NO_ERROR) != (audioBuffer.frameCount == 0), 2074 "obtainBuffer() err=%d frameCount=%zu", err, audioBuffer.frameCount); 2075 requested = &ClientProxy::kNonBlocking; 2076 size_t avail = audioBuffer.frameCount + nonContig; 2077 ALOGV("obtainBuffer(%u) returned %zu = %zu + %zu err %d", 2078 mRemainingFrames, avail, audioBuffer.frameCount, nonContig, err); 2079 if (err != NO_ERROR) { 2080 if (err == TIMED_OUT || err == WOULD_BLOCK || err == -EINTR || 2081 (isOffloaded() && (err == DEAD_OBJECT))) { 2082 // FIXME bug 25195759 2083 return 1000000; 2084 } 2085 ALOGE("Error %d obtaining an audio buffer, giving up.", err); 2086 return NS_NEVER; 2087 } 2088 2089 if (mRetryOnPartialBuffer && audio_has_proportional_frames(mFormat)) { 2090 mRetryOnPartialBuffer = false; 2091 if (avail < mRemainingFrames) { 2092 if (ns > 0) { // account for obtain time 2093 const nsecs_t timeNow = systemTime(); 2094 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks)); 2095 } 2096 nsecs_t myns = framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed); 2097 if (ns < 0 /* NS_WHENEVER */ || myns < ns) { 2098 ns = myns; 2099 } 2100 return ns; 2101 } 2102 } 2103 2104 size_t reqSize = audioBuffer.size; 2105 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer); 2106 size_t writtenSize = audioBuffer.size; 2107 2108 // Sanity check on returned size 2109 if (ssize_t(writtenSize) < 0 || writtenSize > reqSize) { 2110 ALOGE("EVENT_MORE_DATA requested %zu bytes but callback returned %zd bytes", 2111 reqSize, ssize_t(writtenSize)); 2112 return NS_NEVER; 2113 } 2114 2115 if (writtenSize == 0) { 2116 // The callback is done filling buffers 2117 // Keep this thread going to handle timed events and 2118 // still try to get more data in intervals of WAIT_PERIOD_MS 2119 // but don't just loop and block the CPU, so wait 2120 2121 // mCbf(EVENT_MORE_DATA, ...) might either 2122 // (1) Block until it can fill the buffer, returning 0 size on EOS. 2123 // (2) Block until it can fill the buffer, returning 0 data (silence) on EOS. 2124 // (3) Return 0 size when no data is available, does not wait for more data. 2125 // 2126 // (1) and (2) occurs with AudioPlayer/AwesomePlayer; (3) occurs with NuPlayer. 2127 // We try to compute the wait time to avoid a tight sleep-wait cycle, 2128 // especially for case (3). 2129 // 2130 // The decision to support (1) and (2) affect the sizing of mRemainingFrames 2131 // and this loop; whereas for case (3) we could simply check once with the full 2132 // buffer size and skip the loop entirely. 2133 2134 nsecs_t myns; 2135 if (audio_has_proportional_frames(mFormat)) { 2136 // time to wait based on buffer occupancy 2137 const nsecs_t datans = mRemainingFrames <= avail ? 0 : 2138 framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed); 2139 // audio flinger thread buffer size (TODO: adjust for fast tracks) 2140 // FIXME: use mAfFrameCountHAL instead of mAfFrameCount below for fast tracks. 2141 const nsecs_t afns = framesToNanoseconds(mAfFrameCount, mAfSampleRate, speed); 2142 // add a half the AudioFlinger buffer time to avoid soaking CPU if datans is 0. 2143 myns = datans + (afns / 2); 2144 } else { 2145 // FIXME: This could ping quite a bit if the buffer isn't full. 2146 // Note that when mState is stopping we waitStreamEnd, so it never gets here. 2147 myns = kWaitPeriodNs; 2148 } 2149 if (ns > 0) { // account for obtain and callback time 2150 const nsecs_t timeNow = systemTime(); 2151 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks)); 2152 } 2153 if (ns < 0 /* NS_WHENEVER */ || myns < ns) { 2154 ns = myns; 2155 } 2156 return ns; 2157 } 2158 2159 size_t releasedFrames = writtenSize / mFrameSize; 2160 audioBuffer.frameCount = releasedFrames; 2161 mRemainingFrames -= releasedFrames; 2162 if (misalignment >= releasedFrames) { 2163 misalignment -= releasedFrames; 2164 } else { 2165 misalignment = 0; 2166 } 2167 2168 releaseBuffer(&audioBuffer); 2169 writtenFrames += releasedFrames; 2170 2171 // FIXME here is where we would repeat EVENT_MORE_DATA again on same advanced buffer 2172 // if callback doesn't like to accept the full chunk 2173 if (writtenSize < reqSize) { 2174 continue; 2175 } 2176 2177 // There could be enough non-contiguous frames available to satisfy the remaining request 2178 if (mRemainingFrames <= nonContig) { 2179 continue; 2180 } 2181 2182#if 0 2183 // This heuristic tries to collapse a series of EVENT_MORE_DATA that would total to a 2184 // sum <= notificationFrames. It replaces that series by at most two EVENT_MORE_DATA 2185 // that total to a sum == notificationFrames. 2186 if (0 < misalignment && misalignment <= mRemainingFrames) { 2187 mRemainingFrames = misalignment; 2188 return ((double)mRemainingFrames * 1100000000) / ((double)sampleRate * speed); 2189 } 2190#endif 2191 2192 } 2193 if (writtenFrames > 0) { 2194 AutoMutex lock(mLock); 2195 mFramesWritten += writtenFrames; 2196 } 2197 mRemainingFrames = notificationFrames; 2198 mRetryOnPartialBuffer = true; 2199 2200 // A lot has transpired since ns was calculated, so run again immediately and re-calculate 2201 return 0; 2202} 2203 2204status_t AudioTrack::restoreTrack_l(const char *from) 2205{ 2206 ALOGW("dead IAudioTrack, %s, creating a new one from %s()", 2207 isOffloadedOrDirect_l() ? "Offloaded or Direct" : "PCM", from); 2208 ++mSequence; 2209 2210 // refresh the audio configuration cache in this process to make sure we get new 2211 // output parameters and new IAudioFlinger in createTrack_l() 2212 AudioSystem::clearAudioConfigCache(); 2213 2214 if (isOffloadedOrDirect_l() || mDoNotReconnect) { 2215 // FIXME re-creation of offloaded and direct tracks is not yet implemented; 2216 // reconsider enabling for linear PCM encodings when position can be preserved. 2217 return DEAD_OBJECT; 2218 } 2219 2220 // Save so we can return count since creation. 2221 mUnderrunCountOffset = getUnderrunCount_l(); 2222 2223 // save the old static buffer position 2224 uint32_t staticPosition = 0; 2225 size_t bufferPosition = 0; 2226 int loopCount = 0; 2227 if (mStaticProxy != 0) { 2228 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount); 2229 staticPosition = mStaticProxy->getPosition().unsignedValue(); 2230 } 2231 2232 mFlags = mOrigFlags; 2233 2234 // If a new IAudioTrack is successfully created, createTrack_l() will modify the 2235 // following member variables: mAudioTrack, mCblkMemory and mCblk. 2236 // It will also delete the strong references on previous IAudioTrack and IMemory. 2237 // If a new IAudioTrack cannot be created, the previous (dead) instance will be left intact. 2238 status_t result = createTrack_l(); 2239 2240 if (result == NO_ERROR) { 2241 // take the frames that will be lost by track recreation into account in saved position 2242 // For streaming tracks, this is the amount we obtained from the user/client 2243 // (not the number actually consumed at the server - those are already lost). 2244 if (mStaticProxy == 0) { 2245 mPosition = mReleased; 2246 } 2247 // Continue playback from last known position and restore loop. 2248 if (mStaticProxy != 0) { 2249 if (loopCount != 0) { 2250 mStaticProxy->setBufferPositionAndLoop(bufferPosition, 2251 mLoopStart, mLoopEnd, loopCount); 2252 } else { 2253 mStaticProxy->setBufferPosition(bufferPosition); 2254 if (bufferPosition == mFrameCount) { 2255 ALOGD("restoring track at end of static buffer"); 2256 } 2257 } 2258 } 2259 // restore volume handler 2260 mVolumeHandler->forall([this](const VolumeShaper &shaper) -> VolumeShaper::Status { 2261 sp<VolumeShaper::Operation> operationToEnd = 2262 new VolumeShaper::Operation(shaper.mOperation); 2263 // TODO: Ideally we would restore to the exact xOffset position 2264 // as returned by getVolumeShaperState(), but we don't have that 2265 // information when restoring at the client unless we periodically poll 2266 // the server or create shared memory state. 2267 // 2268 // For now, we simply advance to the end of the VolumeShaper effect 2269 // if it has been started. 2270 if (shaper.isStarted()) { 2271 operationToEnd->setNormalizedTime(1.f); 2272 } 2273 return mAudioTrack->applyVolumeShaper(shaper.mConfiguration, operationToEnd); 2274 }); 2275 2276 if (mState == STATE_ACTIVE) { 2277 result = mAudioTrack->start(); 2278 } 2279 // server resets to zero so we offset 2280 mFramesWrittenServerOffset = 2281 mStaticProxy.get() != nullptr ? staticPosition : mFramesWritten; 2282 mFramesWrittenAtRestore = mFramesWrittenServerOffset; 2283 } 2284 if (result != NO_ERROR) { 2285 ALOGW("restoreTrack_l() failed status %d", result); 2286 mState = STATE_STOPPED; 2287 mReleased = 0; 2288 } 2289 2290 return result; 2291} 2292 2293Modulo<uint32_t> AudioTrack::updateAndGetPosition_l() 2294{ 2295 // This is the sole place to read server consumed frames 2296 Modulo<uint32_t> newServer(mProxy->getPosition()); 2297 const int32_t delta = (newServer - mServer).signedValue(); 2298 // TODO There is controversy about whether there can be "negative jitter" in server position. 2299 // This should be investigated further, and if possible, it should be addressed. 2300 // A more definite failure mode is infrequent polling by client. 2301 // One could call (void)getPosition_l() in releaseBuffer(), 2302 // so mReleased and mPosition are always lock-step as best possible. 2303 // That should ensure delta never goes negative for infrequent polling 2304 // unless the server has more than 2^31 frames in its buffer, 2305 // in which case the use of uint32_t for these counters has bigger issues. 2306 ALOGE_IF(delta < 0, 2307 "detected illegal retrograde motion by the server: mServer advanced by %d", 2308 delta); 2309 mServer = newServer; 2310 if (delta > 0) { // avoid retrograde 2311 mPosition += delta; 2312 } 2313 return mPosition; 2314} 2315 2316bool AudioTrack::isSampleRateSpeedAllowed_l(uint32_t sampleRate, float speed) const 2317{ 2318 // applicable for mixing tracks only (not offloaded or direct) 2319 if (mStaticProxy != 0) { 2320 return true; // static tracks do not have issues with buffer sizing. 2321 } 2322 const size_t minFrameCount = 2323 calculateMinFrameCount(mAfLatency, mAfFrameCount, mAfSampleRate, sampleRate, speed 2324 /*, 0 mNotificationsPerBufferReq*/); 2325 ALOGV("isSampleRateSpeedAllowed_l mFrameCount %zu minFrameCount %zu", 2326 mFrameCount, minFrameCount); 2327 return mFrameCount >= minFrameCount; 2328} 2329 2330status_t AudioTrack::setParameters(const String8& keyValuePairs) 2331{ 2332 AutoMutex lock(mLock); 2333 return mAudioTrack->setParameters(keyValuePairs); 2334} 2335 2336VolumeShaper::Status AudioTrack::applyVolumeShaper( 2337 const sp<VolumeShaper::Configuration>& configuration, 2338 const sp<VolumeShaper::Operation>& operation) 2339{ 2340 AutoMutex lock(mLock); 2341 mVolumeHandler->setIdIfNecessary(configuration); 2342 VolumeShaper::Status status = mAudioTrack->applyVolumeShaper(configuration, operation); 2343 2344 if (status == DEAD_OBJECT) { 2345 if (restoreTrack_l("applyVolumeShaper") == OK) { 2346 status = mAudioTrack->applyVolumeShaper(configuration, operation); 2347 } 2348 } 2349 if (status >= 0) { 2350 // save VolumeShaper for restore 2351 mVolumeHandler->applyVolumeShaper(configuration, operation); 2352 if (mState == STATE_ACTIVE || mState == STATE_STOPPING) { 2353 mVolumeHandler->setStarted(); 2354 } 2355 } else { 2356 // warn only if not an expected restore failure. 2357 ALOGW_IF(!((isOffloadedOrDirect_l() || mDoNotReconnect) && status == DEAD_OBJECT), 2358 "applyVolumeShaper failed: %d", status); 2359 } 2360 return status; 2361} 2362 2363sp<VolumeShaper::State> AudioTrack::getVolumeShaperState(int id) 2364{ 2365 AutoMutex lock(mLock); 2366 sp<VolumeShaper::State> state = mAudioTrack->getVolumeShaperState(id); 2367 if (state.get() == nullptr && (mCblk->mFlags & CBLK_INVALID) != 0) { 2368 if (restoreTrack_l("getVolumeShaperState") == OK) { 2369 state = mAudioTrack->getVolumeShaperState(id); 2370 } 2371 } 2372 return state; 2373} 2374 2375status_t AudioTrack::getTimestamp(ExtendedTimestamp *timestamp) 2376{ 2377 if (timestamp == nullptr) { 2378 return BAD_VALUE; 2379 } 2380 AutoMutex lock(mLock); 2381 return getTimestamp_l(timestamp); 2382} 2383 2384status_t AudioTrack::getTimestamp_l(ExtendedTimestamp *timestamp) 2385{ 2386 if (mCblk->mFlags & CBLK_INVALID) { 2387 const status_t status = restoreTrack_l("getTimestampExtended"); 2388 if (status != OK) { 2389 // per getTimestamp() API doc in header, we return DEAD_OBJECT here, 2390 // recommending that the track be recreated. 2391 return DEAD_OBJECT; 2392 } 2393 } 2394 // check for offloaded/direct here in case restoring somehow changed those flags. 2395 if (isOffloadedOrDirect_l()) { 2396 return INVALID_OPERATION; // not supported 2397 } 2398 status_t status = mProxy->getTimestamp(timestamp); 2399 LOG_ALWAYS_FATAL_IF(status != OK, "status %d not allowed from proxy getTimestamp", status); 2400 bool found = false; 2401 timestamp->mPosition[ExtendedTimestamp::LOCATION_CLIENT] = mFramesWritten; 2402 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_CLIENT] = 0; 2403 // server side frame offset in case AudioTrack has been restored. 2404 for (int i = ExtendedTimestamp::LOCATION_SERVER; 2405 i < ExtendedTimestamp::LOCATION_MAX; ++i) { 2406 if (timestamp->mTimeNs[i] >= 0) { 2407 // apply server offset (frames flushed is ignored 2408 // so we don't report the jump when the flush occurs). 2409 timestamp->mPosition[i] += mFramesWrittenServerOffset; 2410 found = true; 2411 } 2412 } 2413 return found ? OK : WOULD_BLOCK; 2414} 2415 2416status_t AudioTrack::getTimestamp(AudioTimestamp& timestamp) 2417{ 2418 AutoMutex lock(mLock); 2419 return getTimestamp_l(timestamp); 2420} 2421 2422status_t AudioTrack::getTimestamp_l(AudioTimestamp& timestamp) 2423{ 2424 bool previousTimestampValid = mPreviousTimestampValid; 2425 // Set false here to cover all the error return cases. 2426 mPreviousTimestampValid = false; 2427 2428 switch (mState) { 2429 case STATE_ACTIVE: 2430 case STATE_PAUSED: 2431 break; // handle below 2432 case STATE_FLUSHED: 2433 case STATE_STOPPED: 2434 return WOULD_BLOCK; 2435 case STATE_STOPPING: 2436 case STATE_PAUSED_STOPPING: 2437 if (!isOffloaded_l()) { 2438 return INVALID_OPERATION; 2439 } 2440 break; // offloaded tracks handled below 2441 default: 2442 LOG_ALWAYS_FATAL("Invalid mState in getTimestamp(): %d", mState); 2443 break; 2444 } 2445 2446 if (mCblk->mFlags & CBLK_INVALID) { 2447 const status_t status = restoreTrack_l("getTimestamp"); 2448 if (status != OK) { 2449 // per getTimestamp() API doc in header, we return DEAD_OBJECT here, 2450 // recommending that the track be recreated. 2451 return DEAD_OBJECT; 2452 } 2453 } 2454 2455 // The presented frame count must always lag behind the consumed frame count. 2456 // To avoid a race, read the presented frames first. This ensures that presented <= consumed. 2457 2458 status_t status; 2459 if (isOffloadedOrDirect_l()) { 2460 // use Binder to get timestamp 2461 status = mAudioTrack->getTimestamp(timestamp); 2462 } else { 2463 // read timestamp from shared memory 2464 ExtendedTimestamp ets; 2465 status = mProxy->getTimestamp(&ets); 2466 if (status == OK) { 2467 ExtendedTimestamp::Location location; 2468 status = ets.getBestTimestamp(×tamp, &location); 2469 2470 if (status == OK) { 2471 // It is possible that the best location has moved from the kernel to the server. 2472 // In this case we adjust the position from the previous computed latency. 2473 if (location == ExtendedTimestamp::LOCATION_SERVER) { 2474 ALOGW_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_KERNEL, 2475 "getTimestamp() location moved from kernel to server"); 2476 // check that the last kernel OK time info exists and the positions 2477 // are valid (if they predate the current track, the positions may 2478 // be zero or negative). 2479 const int64_t frames = 2480 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 || 2481 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0 || 2482 ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] <= 0 || 2483 ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] <= 0) 2484 ? 2485 int64_t((double)mAfLatency * mSampleRate * mPlaybackRate.mSpeed 2486 / 1000) 2487 : 2488 (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] 2489 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK]); 2490 ALOGV("frame adjustment:%lld timestamp:%s", 2491 (long long)frames, ets.toString().c_str()); 2492 if (frames >= ets.mPosition[location]) { 2493 timestamp.mPosition = 0; 2494 } else { 2495 timestamp.mPosition = (uint32_t)(ets.mPosition[location] - frames); 2496 } 2497 } else if (location == ExtendedTimestamp::LOCATION_KERNEL) { 2498 ALOGV_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_SERVER, 2499 "getTimestamp() location moved from server to kernel"); 2500 } 2501 2502 // We update the timestamp time even when paused. 2503 if (mState == STATE_PAUSED /* not needed: STATE_PAUSED_STOPPING */) { 2504 const int64_t now = systemTime(); 2505 const int64_t at = convertTimespecToNs(timestamp.mTime); 2506 const int64_t lag = 2507 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 || 2508 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0) 2509 ? int64_t(mAfLatency * 1000000LL) 2510 : (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] 2511 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK]) 2512 * NANOS_PER_SECOND / mSampleRate; 2513 const int64_t limit = now - lag; // no earlier than this limit 2514 if (at < limit) { 2515 ALOGV("timestamp pause lag:%lld adjusting from %lld to %lld", 2516 (long long)lag, (long long)at, (long long)limit); 2517 timestamp.mTime.tv_sec = limit / NANOS_PER_SECOND; 2518 timestamp.mTime.tv_nsec = limit % NANOS_PER_SECOND; // compiler opt. 2519 } 2520 } 2521 mPreviousLocation = location; 2522 } else { 2523 // right after AudioTrack is started, one may not find a timestamp 2524 ALOGV("getBestTimestamp did not find timestamp"); 2525 } 2526 } 2527 if (status == INVALID_OPERATION) { 2528 // INVALID_OPERATION occurs when no timestamp has been issued by the server; 2529 // other failures are signaled by a negative time. 2530 // If we come out of FLUSHED or STOPPED where the position is known 2531 // to be zero we convert this to WOULD_BLOCK (with the implicit meaning of 2532 // "zero" for NuPlayer). We don't convert for track restoration as position 2533 // does not reset. 2534 ALOGV("timestamp server offset:%lld restore frames:%lld", 2535 (long long)mFramesWrittenServerOffset, (long long)mFramesWrittenAtRestore); 2536 if (mFramesWrittenServerOffset != mFramesWrittenAtRestore) { 2537 status = WOULD_BLOCK; 2538 } 2539 } 2540 } 2541 if (status != NO_ERROR) { 2542 ALOGV_IF(status != WOULD_BLOCK, "getTimestamp error:%#x", status); 2543 return status; 2544 } 2545 if (isOffloadedOrDirect_l()) { 2546 if (isOffloaded_l() && (mState == STATE_PAUSED || mState == STATE_PAUSED_STOPPING)) { 2547 // use cached paused position in case another offloaded track is running. 2548 timestamp.mPosition = mPausedPosition; 2549 clock_gettime(CLOCK_MONOTONIC, ×tamp.mTime); 2550 // TODO: adjust for delay 2551 return NO_ERROR; 2552 } 2553 2554 // Check whether a pending flush or stop has completed, as those commands may 2555 // be asynchronous or return near finish or exhibit glitchy behavior. 2556 // 2557 // Originally this showed up as the first timestamp being a continuation of 2558 // the previous song under gapless playback. 2559 // However, we sometimes see zero timestamps, then a glitch of 2560 // the previous song's position, and then correct timestamps afterwards. 2561 if (mStartUs != 0 && mSampleRate != 0) { 2562 static const int kTimeJitterUs = 100000; // 100 ms 2563 static const int k1SecUs = 1000000; 2564 2565 const int64_t timeNow = getNowUs(); 2566 2567 if (timeNow < mStartUs + k1SecUs) { // within first second of starting 2568 const int64_t timestampTimeUs = convertTimespecToUs(timestamp.mTime); 2569 if (timestampTimeUs < mStartUs) { 2570 return WOULD_BLOCK; // stale timestamp time, occurs before start. 2571 } 2572 const int64_t deltaTimeUs = timestampTimeUs - mStartUs; 2573 const int64_t deltaPositionByUs = (double)timestamp.mPosition * 1000000 2574 / ((double)mSampleRate * mPlaybackRate.mSpeed); 2575 2576 if (deltaPositionByUs > deltaTimeUs + kTimeJitterUs) { 2577 // Verify that the counter can't count faster than the sample rate 2578 // since the start time. If greater, then that means we may have failed 2579 // to completely flush or stop the previous playing track. 2580 ALOGW_IF(!mTimestampStartupGlitchReported, 2581 "getTimestamp startup glitch detected" 2582 " deltaTimeUs(%lld) deltaPositionUs(%lld) tsmPosition(%u)", 2583 (long long)deltaTimeUs, (long long)deltaPositionByUs, 2584 timestamp.mPosition); 2585 mTimestampStartupGlitchReported = true; 2586 if (previousTimestampValid 2587 && mPreviousTimestamp.mPosition == 0 /* should be true if valid */) { 2588 timestamp = mPreviousTimestamp; 2589 mPreviousTimestampValid = true; 2590 return NO_ERROR; 2591 } 2592 return WOULD_BLOCK; 2593 } 2594 if (deltaPositionByUs != 0) { 2595 mStartUs = 0; // don't check again, we got valid nonzero position. 2596 } 2597 } else { 2598 mStartUs = 0; // don't check again, start time expired. 2599 } 2600 mTimestampStartupGlitchReported = false; 2601 } 2602 } else { 2603 // Update the mapping between local consumed (mPosition) and server consumed (mServer) 2604 (void) updateAndGetPosition_l(); 2605 // Server consumed (mServer) and presented both use the same server time base, 2606 // and server consumed is always >= presented. 2607 // The delta between these represents the number of frames in the buffer pipeline. 2608 // If this delta between these is greater than the client position, it means that 2609 // actually presented is still stuck at the starting line (figuratively speaking), 2610 // waiting for the first frame to go by. So we can't report a valid timestamp yet. 2611 // Note: We explicitly use non-Modulo comparison here - potential wrap issue when 2612 // mPosition exceeds 32 bits. 2613 // TODO Remove when timestamp is updated to contain pipeline status info. 2614 const int32_t pipelineDepthInFrames = (mServer - timestamp.mPosition).signedValue(); 2615 if (pipelineDepthInFrames > 0 /* should be true, but we check anyways */ 2616 && (uint32_t)pipelineDepthInFrames > mPosition.value()) { 2617 return INVALID_OPERATION; 2618 } 2619 // Convert timestamp position from server time base to client time base. 2620 // TODO The following code should work OK now because timestamp.mPosition is 32-bit. 2621 // But if we change it to 64-bit then this could fail. 2622 // Use Modulo computation here. 2623 timestamp.mPosition = (mPosition - mServer + timestamp.mPosition).value(); 2624 // Immediately after a call to getPosition_l(), mPosition and 2625 // mServer both represent the same frame position. mPosition is 2626 // in client's point of view, and mServer is in server's point of 2627 // view. So the difference between them is the "fudge factor" 2628 // between client and server views due to stop() and/or new 2629 // IAudioTrack. And timestamp.mPosition is initially in server's 2630 // point of view, so we need to apply the same fudge factor to it. 2631 } 2632 2633 // Prevent retrograde motion in timestamp. 2634 // This is sometimes caused by erratic reports of the available space in the ALSA drivers. 2635 if (status == NO_ERROR) { 2636 if (previousTimestampValid) { 2637 const int64_t previousTimeNanos = convertTimespecToNs(mPreviousTimestamp.mTime); 2638 const int64_t currentTimeNanos = convertTimespecToNs(timestamp.mTime); 2639 if (currentTimeNanos < previousTimeNanos) { 2640 ALOGW("retrograde timestamp time corrected, %lld < %lld", 2641 (long long)currentTimeNanos, (long long)previousTimeNanos); 2642 timestamp.mTime = mPreviousTimestamp.mTime; 2643 } 2644 2645 // Looking at signed delta will work even when the timestamps 2646 // are wrapping around. 2647 int32_t deltaPosition = (Modulo<uint32_t>(timestamp.mPosition) 2648 - mPreviousTimestamp.mPosition).signedValue(); 2649 if (deltaPosition < 0) { 2650 // Only report once per position instead of spamming the log. 2651 if (!mRetrogradeMotionReported) { 2652 ALOGW("retrograde timestamp position corrected, %d = %u - %u", 2653 deltaPosition, 2654 timestamp.mPosition, 2655 mPreviousTimestamp.mPosition); 2656 mRetrogradeMotionReported = true; 2657 } 2658 } else { 2659 mRetrogradeMotionReported = false; 2660 } 2661 if (deltaPosition < 0) { 2662 timestamp.mPosition = mPreviousTimestamp.mPosition; 2663 deltaPosition = 0; 2664 } 2665#if 0 2666 // Uncomment this to verify audio timestamp rate. 2667 const int64_t deltaTime = 2668 convertTimespecToNs(timestamp.mTime) - previousTimeNanos; 2669 if (deltaTime != 0) { 2670 const int64_t computedSampleRate = 2671 deltaPosition * (long long)NANOS_PER_SECOND / deltaTime; 2672 ALOGD("computedSampleRate:%u sampleRate:%u", 2673 (unsigned)computedSampleRate, mSampleRate); 2674 } 2675#endif 2676 } 2677 mPreviousTimestamp = timestamp; 2678 mPreviousTimestampValid = true; 2679 } 2680 2681 return status; 2682} 2683 2684String8 AudioTrack::getParameters(const String8& keys) 2685{ 2686 audio_io_handle_t output = getOutput(); 2687 if (output != AUDIO_IO_HANDLE_NONE) { 2688 return AudioSystem::getParameters(output, keys); 2689 } else { 2690 return String8::empty(); 2691 } 2692} 2693 2694bool AudioTrack::isOffloaded() const 2695{ 2696 AutoMutex lock(mLock); 2697 return isOffloaded_l(); 2698} 2699 2700bool AudioTrack::isDirect() const 2701{ 2702 AutoMutex lock(mLock); 2703 return isDirect_l(); 2704} 2705 2706bool AudioTrack::isOffloadedOrDirect() const 2707{ 2708 AutoMutex lock(mLock); 2709 return isOffloadedOrDirect_l(); 2710} 2711 2712 2713status_t AudioTrack::dump(int fd, const Vector<String16>& args __unused) const 2714{ 2715 2716 const size_t SIZE = 256; 2717 char buffer[SIZE]; 2718 String8 result; 2719 2720 result.append(" AudioTrack::dump\n"); 2721 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", mStreamType, 2722 mVolume[AUDIO_INTERLEAVE_LEFT], mVolume[AUDIO_INTERLEAVE_RIGHT]); 2723 result.append(buffer); 2724 snprintf(buffer, 255, " format(%d), channel count(%d), frame count(%zu)\n", mFormat, 2725 mChannelCount, mFrameCount); 2726 result.append(buffer); 2727 snprintf(buffer, 255, " sample rate(%u), speed(%f), status(%d)\n", 2728 mSampleRate, mPlaybackRate.mSpeed, mStatus); 2729 result.append(buffer); 2730 snprintf(buffer, 255, " state(%d), latency (%d)\n", mState, mLatency); 2731 result.append(buffer); 2732 ::write(fd, result.string(), result.size()); 2733 return NO_ERROR; 2734} 2735 2736uint32_t AudioTrack::getUnderrunCount() const 2737{ 2738 AutoMutex lock(mLock); 2739 return getUnderrunCount_l(); 2740} 2741 2742uint32_t AudioTrack::getUnderrunCount_l() const 2743{ 2744 return mProxy->getUnderrunCount() + mUnderrunCountOffset; 2745} 2746 2747uint32_t AudioTrack::getUnderrunFrames() const 2748{ 2749 AutoMutex lock(mLock); 2750 return mProxy->getUnderrunFrames(); 2751} 2752 2753status_t AudioTrack::addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback) 2754{ 2755 if (callback == 0) { 2756 ALOGW("%s adding NULL callback!", __FUNCTION__); 2757 return BAD_VALUE; 2758 } 2759 AutoMutex lock(mLock); 2760 if (mDeviceCallback == callback) { 2761 ALOGW("%s adding same callback!", __FUNCTION__); 2762 return INVALID_OPERATION; 2763 } 2764 status_t status = NO_ERROR; 2765 if (mOutput != AUDIO_IO_HANDLE_NONE) { 2766 if (mDeviceCallback != 0) { 2767 ALOGW("%s callback already present!", __FUNCTION__); 2768 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput); 2769 } 2770 status = AudioSystem::addAudioDeviceCallback(callback, mOutput); 2771 } 2772 mDeviceCallback = callback; 2773 return status; 2774} 2775 2776status_t AudioTrack::removeAudioDeviceCallback( 2777 const sp<AudioSystem::AudioDeviceCallback>& callback) 2778{ 2779 if (callback == 0) { 2780 ALOGW("%s removing NULL callback!", __FUNCTION__); 2781 return BAD_VALUE; 2782 } 2783 AutoMutex lock(mLock); 2784 if (mDeviceCallback != callback) { 2785 ALOGW("%s removing different callback!", __FUNCTION__); 2786 return INVALID_OPERATION; 2787 } 2788 if (mOutput != AUDIO_IO_HANDLE_NONE) { 2789 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput); 2790 } 2791 mDeviceCallback = 0; 2792 return NO_ERROR; 2793} 2794 2795status_t AudioTrack::pendingDuration(int32_t *msec, ExtendedTimestamp::Location location) 2796{ 2797 if (msec == nullptr || 2798 (location != ExtendedTimestamp::LOCATION_SERVER 2799 && location != ExtendedTimestamp::LOCATION_KERNEL)) { 2800 return BAD_VALUE; 2801 } 2802 AutoMutex lock(mLock); 2803 // inclusive of offloaded and direct tracks. 2804 // 2805 // It is possible, but not enabled, to allow duration computation for non-pcm 2806 // audio_has_proportional_frames() formats because currently they have 2807 // the drain rate equivalent to the pcm sample rate * framesize. 2808 if (!isPurePcmData_l()) { 2809 return INVALID_OPERATION; 2810 } 2811 ExtendedTimestamp ets; 2812 if (getTimestamp_l(&ets) == OK 2813 && ets.mTimeNs[location] > 0) { 2814 int64_t diff = ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT] 2815 - ets.mPosition[location]; 2816 if (diff < 0) { 2817 *msec = 0; 2818 } else { 2819 // ms is the playback time by frames 2820 int64_t ms = (int64_t)((double)diff * 1000 / 2821 ((double)mSampleRate * mPlaybackRate.mSpeed)); 2822 // clockdiff is the timestamp age (negative) 2823 int64_t clockdiff = (mState != STATE_ACTIVE) ? 0 : 2824 ets.mTimeNs[location] 2825 + ets.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_MONOTONIC] 2826 - systemTime(SYSTEM_TIME_MONOTONIC); 2827 2828 //ALOGV("ms: %lld clockdiff: %lld", (long long)ms, (long long)clockdiff); 2829 static const int NANOS_PER_MILLIS = 1000000; 2830 *msec = (int32_t)(ms + clockdiff / NANOS_PER_MILLIS); 2831 } 2832 return NO_ERROR; 2833 } 2834 if (location != ExtendedTimestamp::LOCATION_SERVER) { 2835 return INVALID_OPERATION; // LOCATION_KERNEL is not available 2836 } 2837 // use server position directly (offloaded and direct arrive here) 2838 updateAndGetPosition_l(); 2839 int32_t diff = (Modulo<uint32_t>(mFramesWritten) - mPosition).signedValue(); 2840 *msec = (diff <= 0) ? 0 2841 : (int32_t)((double)diff * 1000 / ((double)mSampleRate * mPlaybackRate.mSpeed)); 2842 return NO_ERROR; 2843} 2844 2845bool AudioTrack::hasStarted() 2846{ 2847 AutoMutex lock(mLock); 2848 switch (mState) { 2849 case STATE_STOPPED: 2850 if (isOffloadedOrDirect_l()) { 2851 // check if we have started in the past to return true. 2852 return mStartUs > 0; 2853 } 2854 // A normal audio track may still be draining, so 2855 // check if stream has ended. This covers fasttrack position 2856 // instability and start/stop without any data written. 2857 if (mProxy->getStreamEndDone()) { 2858 return true; 2859 } 2860 // fall through 2861 case STATE_ACTIVE: 2862 case STATE_STOPPING: 2863 break; 2864 case STATE_PAUSED: 2865 case STATE_PAUSED_STOPPING: 2866 case STATE_FLUSHED: 2867 return false; // we're not active 2868 default: 2869 LOG_ALWAYS_FATAL("Invalid mState in hasStarted(): %d", mState); 2870 break; 2871 } 2872 2873 // wait indicates whether we need to wait for a timestamp. 2874 // This is conservatively figured - if we encounter an unexpected error 2875 // then we will not wait. 2876 bool wait = false; 2877 if (isOffloadedOrDirect_l()) { 2878 AudioTimestamp ts; 2879 status_t status = getTimestamp_l(ts); 2880 if (status == WOULD_BLOCK) { 2881 wait = true; 2882 } else if (status == OK) { 2883 wait = (ts.mPosition == 0 || ts.mPosition == mStartTs.mPosition); 2884 } 2885 ALOGV("hasStarted wait:%d ts:%u start position:%lld", 2886 (int)wait, 2887 ts.mPosition, 2888 (long long)mStartTs.mPosition); 2889 } else { 2890 int location = ExtendedTimestamp::LOCATION_SERVER; // for ALOG 2891 ExtendedTimestamp ets; 2892 status_t status = getTimestamp_l(&ets); 2893 if (status == WOULD_BLOCK) { // no SERVER or KERNEL frame info in ets 2894 wait = true; 2895 } else if (status == OK) { 2896 for (location = ExtendedTimestamp::LOCATION_KERNEL; 2897 location >= ExtendedTimestamp::LOCATION_SERVER; --location) { 2898 if (ets.mTimeNs[location] < 0 || mStartEts.mTimeNs[location] < 0) { 2899 continue; 2900 } 2901 wait = ets.mPosition[location] == 0 2902 || ets.mPosition[location] == mStartEts.mPosition[location]; 2903 break; 2904 } 2905 } 2906 ALOGV("hasStarted wait:%d ets:%lld start position:%lld", 2907 (int)wait, 2908 (long long)ets.mPosition[location], 2909 (long long)mStartEts.mPosition[location]); 2910 } 2911 return !wait; 2912} 2913 2914// ========================================================================= 2915 2916void AudioTrack::DeathNotifier::binderDied(const wp<IBinder>& who __unused) 2917{ 2918 sp<AudioTrack> audioTrack = mAudioTrack.promote(); 2919 if (audioTrack != 0) { 2920 AutoMutex lock(audioTrack->mLock); 2921 audioTrack->mProxy->binderDied(); 2922 } 2923} 2924 2925// ========================================================================= 2926 2927AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava) 2928 : Thread(bCanCallJava), mReceiver(receiver), mPaused(true), mPausedInt(false), mPausedNs(0LL), 2929 mIgnoreNextPausedInt(false) 2930{ 2931} 2932 2933AudioTrack::AudioTrackThread::~AudioTrackThread() 2934{ 2935} 2936 2937bool AudioTrack::AudioTrackThread::threadLoop() 2938{ 2939 { 2940 AutoMutex _l(mMyLock); 2941 if (mPaused) { 2942 mMyCond.wait(mMyLock); 2943 // caller will check for exitPending() 2944 return true; 2945 } 2946 if (mIgnoreNextPausedInt) { 2947 mIgnoreNextPausedInt = false; 2948 mPausedInt = false; 2949 } 2950 if (mPausedInt) { 2951 if (mPausedNs > 0) { 2952 (void) mMyCond.waitRelative(mMyLock, mPausedNs); 2953 } else { 2954 mMyCond.wait(mMyLock); 2955 } 2956 mPausedInt = false; 2957 return true; 2958 } 2959 } 2960 if (exitPending()) { 2961 return false; 2962 } 2963 nsecs_t ns = mReceiver.processAudioBuffer(); 2964 switch (ns) { 2965 case 0: 2966 return true; 2967 case NS_INACTIVE: 2968 pauseInternal(); 2969 return true; 2970 case NS_NEVER: 2971 return false; 2972 case NS_WHENEVER: 2973 // Event driven: call wake() when callback notifications conditions change. 2974 ns = INT64_MAX; 2975 // fall through 2976 default: 2977 LOG_ALWAYS_FATAL_IF(ns < 0, "processAudioBuffer() returned %" PRId64, ns); 2978 pauseInternal(ns); 2979 return true; 2980 } 2981} 2982 2983void AudioTrack::AudioTrackThread::requestExit() 2984{ 2985 // must be in this order to avoid a race condition 2986 Thread::requestExit(); 2987 resume(); 2988} 2989 2990void AudioTrack::AudioTrackThread::pause() 2991{ 2992 AutoMutex _l(mMyLock); 2993 mPaused = true; 2994} 2995 2996void AudioTrack::AudioTrackThread::resume() 2997{ 2998 AutoMutex _l(mMyLock); 2999 mIgnoreNextPausedInt = true; 3000 if (mPaused || mPausedInt) { 3001 mPaused = false; 3002 mPausedInt = false; 3003 mMyCond.signal(); 3004 } 3005} 3006 3007void AudioTrack::AudioTrackThread::wake() 3008{ 3009 AutoMutex _l(mMyLock); 3010 if (!mPaused) { 3011 // wake() might be called while servicing a callback - ignore the next 3012 // pause time and call processAudioBuffer. 3013 mIgnoreNextPausedInt = true; 3014 if (mPausedInt && mPausedNs > 0) { 3015 // audio track is active and internally paused with timeout. 3016 mPausedInt = false; 3017 mMyCond.signal(); 3018 } 3019 } 3020} 3021 3022void AudioTrack::AudioTrackThread::pauseInternal(nsecs_t ns) 3023{ 3024 AutoMutex _l(mMyLock); 3025 mPausedInt = true; 3026 mPausedNs = ns; 3027} 3028 3029} // namespace android 3030