AudioTrack.cpp revision a42ff007a17d63df22c60dd5e5fd811ee45ca1b3
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 19//#define LOG_NDEBUG 0 20#define LOG_TAG "AudioTrack" 21 22#include <stdint.h> 23#include <sys/types.h> 24#include <limits.h> 25 26#include <sched.h> 27#include <sys/resource.h> 28 29#include <private/media/AudioTrackShared.h> 30 31#include <media/AudioSystem.h> 32#include <media/AudioTrack.h> 33 34#include <utils/Log.h> 35#include <binder/Parcel.h> 36#include <binder/IPCThreadState.h> 37#include <utils/Timers.h> 38#include <utils/Atomic.h> 39 40#include <cutils/bitops.h> 41#include <cutils/compiler.h> 42 43#include <system/audio.h> 44#include <system/audio_policy.h> 45 46#include <audio_utils/primitives.h> 47 48namespace android { 49// --------------------------------------------------------------------------- 50 51// static 52status_t AudioTrack::getMinFrameCount( 53 size_t* frameCount, 54 audio_stream_type_t streamType, 55 uint32_t sampleRate) 56{ 57 if (frameCount == NULL) { 58 return BAD_VALUE; 59 } 60 61 // default to 0 in case of error 62 *frameCount = 0; 63 64 // FIXME merge with similar code in createTrack_l(), except we're missing 65 // some information here that is available in createTrack_l(): 66 // audio_io_handle_t output 67 // audio_format_t format 68 // audio_channel_mask_t channelMask 69 // audio_output_flags_t flags 70 uint32_t afSampleRate; 71 if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) { 72 return NO_INIT; 73 } 74 size_t afFrameCount; 75 if (AudioSystem::getOutputFrameCount(&afFrameCount, streamType) != NO_ERROR) { 76 return NO_INIT; 77 } 78 uint32_t afLatency; 79 if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) { 80 return NO_INIT; 81 } 82 83 // Ensure that buffer depth covers at least audio hardware latency 84 uint32_t minBufCount = afLatency / ((1000 * afFrameCount) / afSampleRate); 85 if (minBufCount < 2) minBufCount = 2; 86 87 *frameCount = (sampleRate == 0) ? afFrameCount * minBufCount : 88 afFrameCount * minBufCount * sampleRate / afSampleRate; 89 ALOGV("getMinFrameCount=%d: afFrameCount=%d, minBufCount=%d, afSampleRate=%d, afLatency=%d", 90 *frameCount, afFrameCount, minBufCount, afSampleRate, afLatency); 91 return NO_ERROR; 92} 93 94// --------------------------------------------------------------------------- 95 96AudioTrack::AudioTrack() 97 : mStatus(NO_INIT), 98 mIsTimed(false), 99 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 100 mPreviousSchedulingGroup(SP_DEFAULT) 101{ 102} 103 104AudioTrack::AudioTrack( 105 audio_stream_type_t streamType, 106 uint32_t sampleRate, 107 audio_format_t format, 108 audio_channel_mask_t channelMask, 109 int frameCount, 110 audio_output_flags_t flags, 111 callback_t cbf, 112 void* user, 113 int notificationFrames, 114 int sessionId) 115 : mStatus(NO_INIT), 116 mIsTimed(false), 117 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 118 mPreviousSchedulingGroup(SP_DEFAULT) 119{ 120 mStatus = set(streamType, sampleRate, format, channelMask, 121 frameCount, flags, cbf, user, notificationFrames, 122 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId); 123} 124 125AudioTrack::AudioTrack( 126 audio_stream_type_t streamType, 127 uint32_t sampleRate, 128 audio_format_t format, 129 audio_channel_mask_t channelMask, 130 const sp<IMemory>& sharedBuffer, 131 audio_output_flags_t flags, 132 callback_t cbf, 133 void* user, 134 int notificationFrames, 135 int sessionId) 136 : mStatus(NO_INIT), 137 mIsTimed(false), 138 mPreviousPriority(ANDROID_PRIORITY_NORMAL), 139 mPreviousSchedulingGroup(SP_DEFAULT) 140{ 141 mStatus = set(streamType, sampleRate, format, channelMask, 142 0 /*frameCount*/, flags, cbf, user, notificationFrames, 143 sharedBuffer, false /*threadCanCallJava*/, sessionId); 144} 145 146AudioTrack::~AudioTrack() 147{ 148 ALOGV_IF(mSharedBuffer != 0, "Destructor sharedBuffer: %p", mSharedBuffer->pointer()); 149 150 if (mStatus == NO_ERROR) { 151 // Make sure that callback function exits in the case where 152 // it is looping on buffer full condition in obtainBuffer(). 153 // Otherwise the callback thread will never exit. 154 stop(); 155 if (mAudioTrackThread != 0) { 156 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h 157 mAudioTrackThread->requestExitAndWait(); 158 mAudioTrackThread.clear(); 159 } 160 mAudioTrack.clear(); 161 IPCThreadState::self()->flushCommands(); 162 AudioSystem::releaseAudioSessionId(mSessionId); 163 } 164} 165 166status_t AudioTrack::set( 167 audio_stream_type_t streamType, 168 uint32_t sampleRate, 169 audio_format_t format, 170 audio_channel_mask_t channelMask, 171 int frameCountInt, 172 audio_output_flags_t flags, 173 callback_t cbf, 174 void* user, 175 int notificationFrames, 176 const sp<IMemory>& sharedBuffer, 177 bool threadCanCallJava, 178 int sessionId) 179{ 180 // FIXME "int" here is legacy and will be replaced by size_t later 181 if (frameCountInt < 0) { 182 ALOGE("Invalid frame count %d", frameCountInt); 183 return BAD_VALUE; 184 } 185 size_t frameCount = frameCountInt; 186 187 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), 188 sharedBuffer->size()); 189 190 ALOGV("set() streamType %d frameCount %u flags %04x", streamType, frameCount, flags); 191 192 AutoMutex lock(mLock); 193 if (mAudioTrack != 0) { 194 ALOGE("Track already in use"); 195 return INVALID_OPERATION; 196 } 197 198 // handle default values first. 199 if (streamType == AUDIO_STREAM_DEFAULT) { 200 streamType = AUDIO_STREAM_MUSIC; 201 } 202 203 if (sampleRate == 0) { 204 uint32_t afSampleRate; 205 if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) { 206 return NO_INIT; 207 } 208 sampleRate = afSampleRate; 209 } 210 211 // these below should probably come from the audioFlinger too... 212 if (format == AUDIO_FORMAT_DEFAULT) { 213 format = AUDIO_FORMAT_PCM_16_BIT; 214 } 215 if (channelMask == 0) { 216 channelMask = AUDIO_CHANNEL_OUT_STEREO; 217 } 218 219 // validate parameters 220 if (!audio_is_valid_format(format)) { 221 ALOGE("Invalid format"); 222 return BAD_VALUE; 223 } 224 225 // AudioFlinger does not currently support 8-bit data in shared memory 226 if (format == AUDIO_FORMAT_PCM_8_BIT && sharedBuffer != 0) { 227 ALOGE("8-bit data in shared memory is not supported"); 228 return BAD_VALUE; 229 } 230 231 // force direct flag if format is not linear PCM 232 if (!audio_is_linear_pcm(format)) { 233 flags = (audio_output_flags_t) 234 // FIXME why can't we allow direct AND fast? 235 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST); 236 } 237 // only allow deep buffering for music stream type 238 if (streamType != AUDIO_STREAM_MUSIC) { 239 flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER); 240 } 241 242 if (!audio_is_output_channel(channelMask)) { 243 ALOGE("Invalid channel mask %#x", channelMask); 244 return BAD_VALUE; 245 } 246 mChannelMask = channelMask; 247 uint32_t channelCount = popcount(channelMask); 248 mChannelCount = channelCount; 249 250 audio_io_handle_t output = AudioSystem::getOutput( 251 streamType, 252 sampleRate, format, channelMask, 253 flags); 254 255 if (output == 0) { 256 ALOGE("Could not get audio output for stream type %d", streamType); 257 return BAD_VALUE; 258 } 259 260 mVolume[LEFT] = 1.0f; 261 mVolume[RIGHT] = 1.0f; 262 mSendLevel = 0.0f; 263 mFrameCount = frameCount; 264 mReqFrameCount = frameCount; 265 mNotificationFramesReq = notificationFrames; 266 mSessionId = sessionId; 267 mAuxEffectId = 0; 268 mFlags = flags; 269 mCbf = cbf; 270 271 if (cbf != NULL) { 272 mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava); 273 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/); 274 } 275 276 // create the IAudioTrack 277 status_t status = createTrack_l(streamType, 278 sampleRate, 279 format, 280 frameCount, 281 flags, 282 sharedBuffer, 283 output); 284 285 if (status != NO_ERROR) { 286 if (mAudioTrackThread != 0) { 287 mAudioTrackThread->requestExit(); 288 mAudioTrackThread.clear(); 289 } 290 return status; 291 } 292 293 mStatus = NO_ERROR; 294 295 mStreamType = streamType; 296 mFormat = format; 297 298 if (audio_is_linear_pcm(format)) { 299 mFrameSize = channelCount * audio_bytes_per_sample(format); 300 mFrameSizeAF = channelCount * sizeof(int16_t); 301 } else { 302 mFrameSize = sizeof(uint8_t); 303 mFrameSizeAF = sizeof(uint8_t); 304 } 305 306 mSharedBuffer = sharedBuffer; 307 mMuted = false; 308 mActive = false; 309 mUserData = user; 310 mLoopCount = 0; 311 mMarkerPosition = 0; 312 mMarkerReached = false; 313 mNewPosition = 0; 314 mUpdatePeriod = 0; 315 mFlushed = false; 316 AudioSystem::acquireAudioSessionId(mSessionId); 317 return NO_ERROR; 318} 319 320status_t AudioTrack::initCheck() const 321{ 322 return mStatus; 323} 324 325// ------------------------------------------------------------------------- 326 327uint32_t AudioTrack::latency() const 328{ 329 return mLatency; 330} 331 332audio_stream_type_t AudioTrack::streamType() const 333{ 334 return mStreamType; 335} 336 337audio_format_t AudioTrack::format() const 338{ 339 return mFormat; 340} 341 342uint32_t AudioTrack::channelCount() const 343{ 344 return mChannelCount; 345} 346 347size_t AudioTrack::frameCount() const 348{ 349 return mFrameCount; 350} 351 352sp<IMemory>& AudioTrack::sharedBuffer() 353{ 354 return mSharedBuffer; 355} 356 357// ------------------------------------------------------------------------- 358 359void AudioTrack::start() 360{ 361 sp<AudioTrackThread> t = mAudioTrackThread; 362 363 ALOGV("start %p", this); 364 365 AutoMutex lock(mLock); 366 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed 367 // while we are accessing the cblk 368 sp<IAudioTrack> audioTrack = mAudioTrack; 369 sp<IMemory> iMem = mCblkMemory; 370 audio_track_cblk_t* cblk = mCblk; 371 372 if (!mActive) { 373 mFlushed = false; 374 mActive = true; 375 mNewPosition = cblk->server + mUpdatePeriod; 376 cblk->lock.lock(); 377 cblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS; 378 cblk->waitTimeMs = 0; 379 android_atomic_and(~CBLK_DISABLED, &cblk->flags); 380 if (t != 0) { 381 t->resume(); 382 } else { 383 mPreviousPriority = getpriority(PRIO_PROCESS, 0); 384 get_sched_policy(0, &mPreviousSchedulingGroup); 385 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO); 386 } 387 388 ALOGV("start %p before lock cblk %p", this, cblk); 389 status_t status = NO_ERROR; 390 if (!(cblk->flags & CBLK_INVALID)) { 391 cblk->lock.unlock(); 392 ALOGV("mAudioTrack->start()"); 393 status = mAudioTrack->start(); 394 cblk->lock.lock(); 395 if (status == DEAD_OBJECT) { 396 android_atomic_or(CBLK_INVALID, &cblk->flags); 397 } 398 } 399 if (cblk->flags & CBLK_INVALID) { 400 audio_track_cblk_t* temp = cblk; 401 status = restoreTrack_l(temp, true /*fromStart*/); 402 cblk = temp; 403 } 404 cblk->lock.unlock(); 405 if (status != NO_ERROR) { 406 ALOGV("start() failed"); 407 mActive = false; 408 if (t != 0) { 409 t->pause(); 410 } else { 411 setpriority(PRIO_PROCESS, 0, mPreviousPriority); 412 set_sched_policy(0, mPreviousSchedulingGroup); 413 } 414 } 415 } 416 417} 418 419void AudioTrack::stop() 420{ 421 sp<AudioTrackThread> t = mAudioTrackThread; 422 423 ALOGV("stop %p", this); 424 425 AutoMutex lock(mLock); 426 if (mActive) { 427 mActive = false; 428 mCblk->cv.signal(); 429 mAudioTrack->stop(); 430 // Cancel loops (If we are in the middle of a loop, playback 431 // would not stop until loopCount reaches 0). 432 setLoop_l(0, 0, 0); 433 // the playback head position will reset to 0, so if a marker is set, we need 434 // to activate it again 435 mMarkerReached = false; 436 // Force flush if a shared buffer is used otherwise audioflinger 437 // will not stop before end of buffer is reached. 438 if (mSharedBuffer != 0) { 439 flush_l(); 440 } 441 if (t != 0) { 442 t->pause(); 443 } else { 444 setpriority(PRIO_PROCESS, 0, mPreviousPriority); 445 set_sched_policy(0, mPreviousSchedulingGroup); 446 } 447 } 448 449} 450 451bool AudioTrack::stopped() const 452{ 453 AutoMutex lock(mLock); 454 return stopped_l(); 455} 456 457void AudioTrack::flush() 458{ 459 AutoMutex lock(mLock); 460 flush_l(); 461} 462 463// must be called with mLock held 464void AudioTrack::flush_l() 465{ 466 ALOGV("flush"); 467 468 // clear playback marker and periodic update counter 469 mMarkerPosition = 0; 470 mMarkerReached = false; 471 mUpdatePeriod = 0; 472 473 if (!mActive) { 474 mFlushed = true; 475 mAudioTrack->flush(); 476 // Release AudioTrack callback thread in case it was waiting for new buffers 477 // in AudioTrack::obtainBuffer() 478 mCblk->cv.signal(); 479 } 480} 481 482void AudioTrack::pause() 483{ 484 ALOGV("pause"); 485 AutoMutex lock(mLock); 486 if (mActive) { 487 mActive = false; 488 mCblk->cv.signal(); 489 mAudioTrack->pause(); 490 } 491} 492 493void AudioTrack::mute(bool e) 494{ 495 mAudioTrack->mute(e); 496 mMuted = e; 497} 498 499bool AudioTrack::muted() const 500{ 501 return mMuted; 502} 503 504status_t AudioTrack::setVolume(float left, float right) 505{ 506 if (left < 0.0f || left > 1.0f || right < 0.0f || right > 1.0f) { 507 return BAD_VALUE; 508 } 509 510 AutoMutex lock(mLock); 511 mVolume[LEFT] = left; 512 mVolume[RIGHT] = right; 513 514 mCblk->setVolumeLR((uint32_t(uint16_t(right * 0x1000)) << 16) | uint16_t(left * 0x1000)); 515 516 return NO_ERROR; 517} 518 519status_t AudioTrack::setVolume(float volume) 520{ 521 return setVolume(volume, volume); 522} 523 524status_t AudioTrack::setAuxEffectSendLevel(float level) 525{ 526 ALOGV("setAuxEffectSendLevel(%f)", level); 527 if (level < 0.0f || level > 1.0f) { 528 return BAD_VALUE; 529 } 530 AutoMutex lock(mLock); 531 532 mSendLevel = level; 533 534 mCblk->setSendLevel(level); 535 536 return NO_ERROR; 537} 538 539void AudioTrack::getAuxEffectSendLevel(float* level) const 540{ 541 if (level != NULL) { 542 *level = mSendLevel; 543 } 544} 545 546status_t AudioTrack::setSampleRate(uint32_t rate) 547{ 548 uint32_t afSamplingRate; 549 550 if (mIsTimed) { 551 return INVALID_OPERATION; 552 } 553 554 if (AudioSystem::getOutputSamplingRate(&afSamplingRate, mStreamType) != NO_ERROR) { 555 return NO_INIT; 556 } 557 // Resampler implementation limits input sampling rate to 2 x output sampling rate. 558 if (rate == 0 || rate > afSamplingRate*2 ) { 559 return BAD_VALUE; 560 } 561 562 AutoMutex lock(mLock); 563 mCblk->sampleRate = rate; 564 return NO_ERROR; 565} 566 567uint32_t AudioTrack::getSampleRate() const 568{ 569 if (mIsTimed) { 570 return 0; 571 } 572 573 AutoMutex lock(mLock); 574 return mCblk->sampleRate; 575} 576 577status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount) 578{ 579 AutoMutex lock(mLock); 580 return setLoop_l(loopStart, loopEnd, loopCount); 581} 582 583// must be called with mLock held 584status_t AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount) 585{ 586 audio_track_cblk_t* cblk = mCblk; 587 588 Mutex::Autolock _l(cblk->lock); 589 590 if (loopCount == 0) { 591 cblk->loopStart = UINT_MAX; 592 cblk->loopEnd = UINT_MAX; 593 cblk->loopCount = 0; 594 mLoopCount = 0; 595 return NO_ERROR; 596 } 597 598 if (mIsTimed) { 599 return INVALID_OPERATION; 600 } 601 602 if (loopStart >= loopEnd || 603 loopEnd - loopStart > mFrameCount || 604 cblk->server > loopStart) { 605 ALOGE("setLoop invalid value: loopStart %d, loopEnd %d, loopCount %d, framecount %d, " 606 "user %d", loopStart, loopEnd, loopCount, mFrameCount, cblk->user); 607 return BAD_VALUE; 608 } 609 610 if ((mSharedBuffer != 0) && (loopEnd > mFrameCount)) { 611 ALOGE("setLoop invalid value: loop markers beyond data: loopStart %d, loopEnd %d, " 612 "framecount %d", 613 loopStart, loopEnd, mFrameCount); 614 return BAD_VALUE; 615 } 616 617 cblk->loopStart = loopStart; 618 cblk->loopEnd = loopEnd; 619 cblk->loopCount = loopCount; 620 mLoopCount = loopCount; 621 622 return NO_ERROR; 623} 624 625status_t AudioTrack::setMarkerPosition(uint32_t marker) 626{ 627 if (mCbf == NULL) { 628 return INVALID_OPERATION; 629 } 630 631 mMarkerPosition = marker; 632 mMarkerReached = false; 633 634 return NO_ERROR; 635} 636 637status_t AudioTrack::getMarkerPosition(uint32_t *marker) const 638{ 639 if (marker == NULL) { 640 return BAD_VALUE; 641 } 642 643 *marker = mMarkerPosition; 644 645 return NO_ERROR; 646} 647 648status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod) 649{ 650 if (mCbf == NULL) { 651 return INVALID_OPERATION; 652 } 653 654 uint32_t curPosition; 655 getPosition(&curPosition); 656 mNewPosition = curPosition + updatePeriod; 657 mUpdatePeriod = updatePeriod; 658 659 return NO_ERROR; 660} 661 662status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const 663{ 664 if (updatePeriod == NULL) { 665 return BAD_VALUE; 666 } 667 668 *updatePeriod = mUpdatePeriod; 669 670 return NO_ERROR; 671} 672 673status_t AudioTrack::setPosition(uint32_t position) 674{ 675 if (mIsTimed) { 676 return INVALID_OPERATION; 677 } 678 679 AutoMutex lock(mLock); 680 681 if (!stopped_l()) { 682 return INVALID_OPERATION; 683 } 684 685 audio_track_cblk_t* cblk = mCblk; 686 Mutex::Autolock _l(cblk->lock); 687 688 if (position > cblk->user) { 689 return BAD_VALUE; 690 } 691 692 cblk->server = position; 693 android_atomic_or(CBLK_FORCEREADY, &cblk->flags); 694 695 return NO_ERROR; 696} 697 698status_t AudioTrack::getPosition(uint32_t *position) 699{ 700 if (position == NULL) { 701 return BAD_VALUE; 702 } 703 AutoMutex lock(mLock); 704 *position = mFlushed ? 0 : mCblk->server; 705 706 return NO_ERROR; 707} 708 709status_t AudioTrack::reload() 710{ 711 AutoMutex lock(mLock); 712 713 if (!stopped_l()) { 714 return INVALID_OPERATION; 715 } 716 717 flush_l(); 718 719 audio_track_cblk_t* cblk = mCblk; 720 cblk->stepUserOut(mFrameCount, mFrameCount); 721 722 return NO_ERROR; 723} 724 725audio_io_handle_t AudioTrack::getOutput() 726{ 727 AutoMutex lock(mLock); 728 return getOutput_l(); 729} 730 731// must be called with mLock held 732audio_io_handle_t AudioTrack::getOutput_l() 733{ 734 return AudioSystem::getOutput(mStreamType, 735 mCblk->sampleRate, mFormat, mChannelMask, mFlags); 736} 737 738int AudioTrack::getSessionId() const 739{ 740 return mSessionId; 741} 742 743status_t AudioTrack::attachAuxEffect(int effectId) 744{ 745 ALOGV("attachAuxEffect(%d)", effectId); 746 status_t status = mAudioTrack->attachAuxEffect(effectId); 747 if (status == NO_ERROR) { 748 mAuxEffectId = effectId; 749 } 750 return status; 751} 752 753// ------------------------------------------------------------------------- 754 755// must be called with mLock held 756status_t AudioTrack::createTrack_l( 757 audio_stream_type_t streamType, 758 uint32_t sampleRate, 759 audio_format_t format, 760 size_t frameCount, 761 audio_output_flags_t flags, 762 const sp<IMemory>& sharedBuffer, 763 audio_io_handle_t output) 764{ 765 status_t status; 766 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); 767 if (audioFlinger == 0) { 768 ALOGE("Could not get audioflinger"); 769 return NO_INIT; 770 } 771 772 uint32_t afLatency; 773 if (AudioSystem::getLatency(output, streamType, &afLatency) != NO_ERROR) { 774 return NO_INIT; 775 } 776 777 // Client decides whether the track is TIMED (see below), but can only express a preference 778 // for FAST. Server will perform additional tests. 779 if ((flags & AUDIO_OUTPUT_FLAG_FAST) && !( 780 // either of these use cases: 781 // use case 1: shared buffer 782 (sharedBuffer != 0) || 783 // use case 2: callback handler 784 (mCbf != NULL))) { 785 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client"); 786 // once denied, do not request again if IAudioTrack is re-created 787 flags = (audio_output_flags_t) (flags & ~AUDIO_OUTPUT_FLAG_FAST); 788 mFlags = flags; 789 } 790 ALOGV("createTrack_l() output %d afLatency %d", output, afLatency); 791 792 mNotificationFramesAct = mNotificationFramesReq; 793 794 if (!audio_is_linear_pcm(format)) { 795 796 if (sharedBuffer != 0) { 797 // Same comment as below about ignoring frameCount parameter for set() 798 frameCount = sharedBuffer->size(); 799 } else if (frameCount == 0) { 800 size_t afFrameCount; 801 if (AudioSystem::getFrameCount(output, streamType, &afFrameCount) != NO_ERROR) { 802 return NO_INIT; 803 } 804 frameCount = afFrameCount; 805 } 806 807 } else if (sharedBuffer != 0) { 808 809 // Ensure that buffer alignment matches channel count 810 // 8-bit data in shared memory is not currently supported by AudioFlinger 811 size_t alignment = /* format == AUDIO_FORMAT_PCM_8_BIT ? 1 : */ 2; 812 if (mChannelCount > 1) { 813 // More than 2 channels does not require stronger alignment than stereo 814 alignment <<= 1; 815 } 816 if (((size_t)sharedBuffer->pointer() & (alignment - 1)) != 0) { 817 ALOGE("Invalid buffer alignment: address %p, channel count %u", 818 sharedBuffer->pointer(), mChannelCount); 819 return BAD_VALUE; 820 } 821 822 // When initializing a shared buffer AudioTrack via constructors, 823 // there's no frameCount parameter. 824 // But when initializing a shared buffer AudioTrack via set(), 825 // there _is_ a frameCount parameter. We silently ignore it. 826 frameCount = sharedBuffer->size()/mChannelCount/sizeof(int16_t); 827 828 } else if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) { 829 830 // FIXME move these calculations and associated checks to server 831 uint32_t afSampleRate; 832 if (AudioSystem::getSamplingRate(output, streamType, &afSampleRate) != NO_ERROR) { 833 return NO_INIT; 834 } 835 size_t afFrameCount; 836 if (AudioSystem::getFrameCount(output, streamType, &afFrameCount) != NO_ERROR) { 837 return NO_INIT; 838 } 839 840 // Ensure that buffer depth covers at least audio hardware latency 841 uint32_t minBufCount = afLatency / ((1000 * afFrameCount)/afSampleRate); 842 if (minBufCount < 2) minBufCount = 2; 843 844 size_t minFrameCount = (afFrameCount*sampleRate*minBufCount)/afSampleRate; 845 ALOGV("minFrameCount: %u, afFrameCount=%d, minBufCount=%d, sampleRate=%u, afSampleRate=%u" 846 ", afLatency=%d", 847 minFrameCount, afFrameCount, minBufCount, sampleRate, afSampleRate, afLatency); 848 849 if (frameCount == 0) { 850 frameCount = minFrameCount; 851 } 852 if (mNotificationFramesAct == 0) { 853 mNotificationFramesAct = frameCount/2; 854 } 855 // Make sure that application is notified with sufficient margin 856 // before underrun 857 if (mNotificationFramesAct > frameCount/2) { 858 mNotificationFramesAct = frameCount/2; 859 } 860 if (frameCount < minFrameCount) { 861 // not ALOGW because it happens all the time when playing key clicks over A2DP 862 ALOGV("Minimum buffer size corrected from %d to %d", 863 frameCount, minFrameCount); 864 frameCount = minFrameCount; 865 } 866 867 } else { 868 // For fast tracks, the frame count calculations and checks are done by server 869 } 870 871 IAudioFlinger::track_flags_t trackFlags = IAudioFlinger::TRACK_DEFAULT; 872 if (mIsTimed) { 873 trackFlags |= IAudioFlinger::TRACK_TIMED; 874 } 875 876 pid_t tid = -1; 877 if (flags & AUDIO_OUTPUT_FLAG_FAST) { 878 trackFlags |= IAudioFlinger::TRACK_FAST; 879 if (mAudioTrackThread != 0) { 880 tid = mAudioTrackThread->getTid(); 881 } 882 } 883 884 sp<IAudioTrack> track = audioFlinger->createTrack(getpid(), 885 streamType, 886 sampleRate, 887 // AudioFlinger only sees 16-bit PCM 888 format == AUDIO_FORMAT_PCM_8_BIT ? 889 AUDIO_FORMAT_PCM_16_BIT : format, 890 mChannelMask, 891 frameCount, 892 &trackFlags, 893 sharedBuffer, 894 output, 895 tid, 896 &mSessionId, 897 &status); 898 899 if (track == 0) { 900 ALOGE("AudioFlinger could not create track, status: %d", status); 901 return status; 902 } 903 sp<IMemory> iMem = track->getCblk(); 904 if (iMem == 0) { 905 ALOGE("Could not get control block"); 906 return NO_INIT; 907 } 908 mAudioTrack = track; 909 mCblkMemory = iMem; 910 audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMem->pointer()); 911 mCblk = cblk; 912 size_t temp = cblk->frameCount_; 913 if (temp < frameCount || (frameCount == 0 && temp == 0)) { 914 // In current design, AudioTrack client checks and ensures frame count validity before 915 // passing it to AudioFlinger so AudioFlinger should not return a different value except 916 // for fast track as it uses a special method of assigning frame count. 917 ALOGW("Requested frameCount %u but received frameCount %u", frameCount, temp); 918 } 919 frameCount = temp; 920 if (flags & AUDIO_OUTPUT_FLAG_FAST) { 921 if (trackFlags & IAudioFlinger::TRACK_FAST) { 922 ALOGV("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %u", frameCount); 923 } else { 924 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %u", frameCount); 925 // once denied, do not request again if IAudioTrack is re-created 926 flags = (audio_output_flags_t) (flags & ~AUDIO_OUTPUT_FLAG_FAST); 927 mFlags = flags; 928 } 929 if (sharedBuffer == 0) { 930 mNotificationFramesAct = frameCount/2; 931 } 932 } 933 if (sharedBuffer == 0) { 934 mBuffers = (char*)cblk + sizeof(audio_track_cblk_t); 935 } else { 936 mBuffers = sharedBuffer->pointer(); 937 // Force buffer full condition as data is already present in shared memory 938 cblk->stepUserOut(frameCount, frameCount); 939 } 940 941 cblk->setVolumeLR((uint32_t(uint16_t(mVolume[RIGHT] * 0x1000)) << 16) | 942 uint16_t(mVolume[LEFT] * 0x1000)); 943 cblk->setSendLevel(mSendLevel); 944 mAudioTrack->attachAuxEffect(mAuxEffectId); 945 cblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS; 946 cblk->waitTimeMs = 0; 947 mRemainingFrames = mNotificationFramesAct; 948 // FIXME don't believe this lie 949 mLatency = afLatency + (1000*frameCount) / sampleRate; 950 mFrameCount = frameCount; 951 // If IAudioTrack is re-created, don't let the requested frameCount 952 // decrease. This can confuse clients that cache frameCount(). 953 if (frameCount > mReqFrameCount) { 954 mReqFrameCount = frameCount; 955 } 956 return NO_ERROR; 957} 958 959status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount) 960{ 961 AutoMutex lock(mLock); 962 bool active; 963 status_t result = NO_ERROR; 964 audio_track_cblk_t* cblk = mCblk; 965 uint32_t framesReq = audioBuffer->frameCount; 966 uint32_t waitTimeMs = (waitCount < 0) ? cblk->bufferTimeoutMs : WAIT_PERIOD_MS; 967 968 audioBuffer->frameCount = 0; 969 audioBuffer->size = 0; 970 971 uint32_t framesAvail = cblk->framesAvailableOut(mFrameCount); 972 973 cblk->lock.lock(); 974 if (cblk->flags & CBLK_INVALID) { 975 goto create_new_track; 976 } 977 cblk->lock.unlock(); 978 979 if (framesAvail == 0) { 980 cblk->lock.lock(); 981 goto start_loop_here; 982 while (framesAvail == 0) { 983 active = mActive; 984 if (CC_UNLIKELY(!active)) { 985 ALOGV("Not active and NO_MORE_BUFFERS"); 986 cblk->lock.unlock(); 987 return NO_MORE_BUFFERS; 988 } 989 if (CC_UNLIKELY(!waitCount)) { 990 cblk->lock.unlock(); 991 return WOULD_BLOCK; 992 } 993 if (!(cblk->flags & CBLK_INVALID)) { 994 mLock.unlock(); 995 // this condition is in shared memory, so if IAudioTrack and control block 996 // are replaced due to mediaserver death or IAudioTrack invalidation then 997 // cv won't be signalled, but fortunately the timeout will limit the wait 998 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs)); 999 cblk->lock.unlock(); 1000 mLock.lock(); 1001 if (!mActive) { 1002 return status_t(STOPPED); 1003 } 1004 // IAudioTrack may have been re-created while mLock was unlocked 1005 cblk = mCblk; 1006 cblk->lock.lock(); 1007 } 1008 1009 if (cblk->flags & CBLK_INVALID) { 1010 goto create_new_track; 1011 } 1012 if (CC_UNLIKELY(result != NO_ERROR)) { 1013 cblk->waitTimeMs += waitTimeMs; 1014 if (cblk->waitTimeMs >= cblk->bufferTimeoutMs) { 1015 // timing out when a loop has been set and we have already written upto loop end 1016 // is a normal condition: no need to wake AudioFlinger up. 1017 if (cblk->user < cblk->loopEnd) { 1018 ALOGW("obtainBuffer timed out (is the CPU pegged?) %p name=%#x user=%08x, " 1019 "server=%08x", this, cblk->mName, cblk->user, cblk->server); 1020 //unlock cblk mutex before calling mAudioTrack->start() (see issue #1617140) 1021 cblk->lock.unlock(); 1022 result = mAudioTrack->start(); 1023 cblk->lock.lock(); 1024 if (result == DEAD_OBJECT) { 1025 android_atomic_or(CBLK_INVALID, &cblk->flags); 1026create_new_track: 1027 audio_track_cblk_t* temp = cblk; 1028 result = restoreTrack_l(temp, false /*fromStart*/); 1029 cblk = temp; 1030 } 1031 if (result != NO_ERROR) { 1032 ALOGW("obtainBuffer create Track error %d", result); 1033 cblk->lock.unlock(); 1034 return result; 1035 } 1036 } 1037 cblk->waitTimeMs = 0; 1038 } 1039 1040 if (--waitCount == 0) { 1041 cblk->lock.unlock(); 1042 return TIMED_OUT; 1043 } 1044 } 1045 // read the server count again 1046 start_loop_here: 1047 framesAvail = cblk->framesAvailableOut_l(mFrameCount); 1048 } 1049 cblk->lock.unlock(); 1050 } 1051 1052 cblk->waitTimeMs = 0; 1053 1054 if (framesReq > framesAvail) { 1055 framesReq = framesAvail; 1056 } 1057 1058 uint32_t u = cblk->user; 1059 uint32_t bufferEnd = cblk->userBase + mFrameCount; 1060 1061 if (framesReq > bufferEnd - u) { 1062 framesReq = bufferEnd - u; 1063 } 1064 1065 audioBuffer->frameCount = framesReq; 1066 audioBuffer->size = framesReq * mFrameSizeAF; 1067 audioBuffer->raw = cblk->buffer(mBuffers, mFrameSizeAF, u); 1068 active = mActive; 1069 return active ? status_t(NO_ERROR) : status_t(STOPPED); 1070} 1071 1072void AudioTrack::releaseBuffer(Buffer* audioBuffer) 1073{ 1074 AutoMutex lock(mLock); 1075 audio_track_cblk_t* cblk = mCblk; 1076 cblk->stepUserOut(audioBuffer->frameCount, mFrameCount); 1077 if (audioBuffer->frameCount > 0) { 1078 // restart track if it was disabled by audioflinger due to previous underrun 1079 if (mActive && (cblk->flags & CBLK_DISABLED)) { 1080 android_atomic_and(~CBLK_DISABLED, &cblk->flags); 1081 ALOGW("releaseBuffer() track %p name=%#x disabled, restarting", this, cblk->mName); 1082 mAudioTrack->start(); 1083 } 1084 } 1085} 1086 1087// ------------------------------------------------------------------------- 1088 1089ssize_t AudioTrack::write(const void* buffer, size_t userSize) 1090{ 1091 1092 if (mSharedBuffer != 0) { 1093 return INVALID_OPERATION; 1094 } 1095 if (mIsTimed) { 1096 return INVALID_OPERATION; 1097 } 1098 1099 if (ssize_t(userSize) < 0) { 1100 // Sanity-check: user is most-likely passing an error code, and it would 1101 // make the return value ambiguous (actualSize vs error). 1102 ALOGE("AudioTrack::write(buffer=%p, size=%u (%d)", 1103 buffer, userSize, userSize); 1104 return BAD_VALUE; 1105 } 1106 1107 ALOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive); 1108 1109 if (userSize == 0) { 1110 return 0; 1111 } 1112 1113 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed 1114 // while we are accessing the cblk 1115 mLock.lock(); 1116 sp<IAudioTrack> audioTrack = mAudioTrack; 1117 sp<IMemory> iMem = mCblkMemory; 1118 mLock.unlock(); 1119 1120 // since mLock is unlocked the IAudioTrack and shared memory may be re-created, 1121 // so all cblk references might still refer to old shared memory, but that should be benign 1122 1123 ssize_t written = 0; 1124 const int8_t *src = (const int8_t *)buffer; 1125 Buffer audioBuffer; 1126 size_t frameSz = frameSize(); 1127 1128 do { 1129 audioBuffer.frameCount = userSize/frameSz; 1130 1131 status_t err = obtainBuffer(&audioBuffer, -1); 1132 if (err < 0) { 1133 // out of buffers, return #bytes written 1134 if (err == status_t(NO_MORE_BUFFERS)) { 1135 break; 1136 } 1137 return ssize_t(err); 1138 } 1139 1140 size_t toWrite; 1141 1142 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) { 1143 // Divide capacity by 2 to take expansion into account 1144 toWrite = audioBuffer.size>>1; 1145 memcpy_to_i16_from_u8(audioBuffer.i16, (const uint8_t *) src, toWrite); 1146 } else { 1147 toWrite = audioBuffer.size; 1148 memcpy(audioBuffer.i8, src, toWrite); 1149 } 1150 src += toWrite; 1151 userSize -= toWrite; 1152 written += toWrite; 1153 1154 releaseBuffer(&audioBuffer); 1155 } while (userSize >= frameSz); 1156 1157 return written; 1158} 1159 1160// ------------------------------------------------------------------------- 1161 1162TimedAudioTrack::TimedAudioTrack() { 1163 mIsTimed = true; 1164} 1165 1166status_t TimedAudioTrack::allocateTimedBuffer(size_t size, sp<IMemory>* buffer) 1167{ 1168 AutoMutex lock(mLock); 1169 status_t result = UNKNOWN_ERROR; 1170 1171 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed 1172 // while we are accessing the cblk 1173 sp<IAudioTrack> audioTrack = mAudioTrack; 1174 sp<IMemory> iMem = mCblkMemory; 1175 1176 // If the track is not invalid already, try to allocate a buffer. alloc 1177 // fails indicating that the server is dead, flag the track as invalid so 1178 // we can attempt to restore in just a bit. 1179 audio_track_cblk_t* cblk = mCblk; 1180 if (!(cblk->flags & CBLK_INVALID)) { 1181 result = mAudioTrack->allocateTimedBuffer(size, buffer); 1182 if (result == DEAD_OBJECT) { 1183 android_atomic_or(CBLK_INVALID, &cblk->flags); 1184 } 1185 } 1186 1187 // If the track is invalid at this point, attempt to restore it. and try the 1188 // allocation one more time. 1189 if (cblk->flags & CBLK_INVALID) { 1190 cblk->lock.lock(); 1191 audio_track_cblk_t* temp = cblk; 1192 result = restoreTrack_l(temp, false /*fromStart*/); 1193 cblk = temp; 1194 cblk->lock.unlock(); 1195 1196 if (result == OK) { 1197 result = mAudioTrack->allocateTimedBuffer(size, buffer); 1198 } 1199 } 1200 1201 return result; 1202} 1203 1204status_t TimedAudioTrack::queueTimedBuffer(const sp<IMemory>& buffer, 1205 int64_t pts) 1206{ 1207 status_t status = mAudioTrack->queueTimedBuffer(buffer, pts); 1208 { 1209 AutoMutex lock(mLock); 1210 audio_track_cblk_t* cblk = mCblk; 1211 // restart track if it was disabled by audioflinger due to previous underrun 1212 if (buffer->size() != 0 && status == NO_ERROR && 1213 mActive && (cblk->flags & CBLK_DISABLED)) { 1214 android_atomic_and(~CBLK_DISABLED, &cblk->flags); 1215 ALOGW("queueTimedBuffer() track %p disabled, restarting", this); 1216 mAudioTrack->start(); 1217 } 1218 } 1219 return status; 1220} 1221 1222status_t TimedAudioTrack::setMediaTimeTransform(const LinearTransform& xform, 1223 TargetTimeline target) 1224{ 1225 return mAudioTrack->setMediaTimeTransform(xform, target); 1226} 1227 1228// ------------------------------------------------------------------------- 1229 1230bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread) 1231{ 1232 Buffer audioBuffer; 1233 uint32_t frames; 1234 size_t writtenSize; 1235 1236 mLock.lock(); 1237 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed 1238 // while we are accessing the cblk 1239 sp<IAudioTrack> audioTrack = mAudioTrack; 1240 sp<IMemory> iMem = mCblkMemory; 1241 audio_track_cblk_t* cblk = mCblk; 1242 bool active = mActive; 1243 mLock.unlock(); 1244 1245 // since mLock is unlocked the IAudioTrack and shared memory may be re-created, 1246 // so all cblk references might still refer to old shared memory, but that should be benign 1247 1248 // Manage underrun callback 1249 if (active && (cblk->framesAvailableOut(mFrameCount) == mFrameCount)) { 1250 ALOGV("Underrun user: %x, server: %x, flags %04x", cblk->user, cblk->server, cblk->flags); 1251 if (!(android_atomic_or(CBLK_UNDERRUN, &cblk->flags) & CBLK_UNDERRUN)) { 1252 mCbf(EVENT_UNDERRUN, mUserData, 0); 1253 if (cblk->server == mFrameCount) { 1254 mCbf(EVENT_BUFFER_END, mUserData, 0); 1255 } 1256 if (mSharedBuffer != 0) { 1257 return false; 1258 } 1259 } 1260 } 1261 1262 // Manage loop end callback 1263 while (mLoopCount > cblk->loopCount) { 1264 int loopCount = -1; 1265 mLoopCount--; 1266 if (mLoopCount >= 0) loopCount = mLoopCount; 1267 1268 mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount); 1269 } 1270 1271 // Manage marker callback 1272 if (!mMarkerReached && (mMarkerPosition > 0)) { 1273 if (cblk->server >= mMarkerPosition) { 1274 mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition); 1275 mMarkerReached = true; 1276 } 1277 } 1278 1279 // Manage new position callback 1280 if (mUpdatePeriod > 0) { 1281 while (cblk->server >= mNewPosition) { 1282 mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition); 1283 mNewPosition += mUpdatePeriod; 1284 } 1285 } 1286 1287 // If Shared buffer is used, no data is requested from client. 1288 if (mSharedBuffer != 0) { 1289 frames = 0; 1290 } else { 1291 frames = mRemainingFrames; 1292 } 1293 1294 // See description of waitCount parameter at declaration of obtainBuffer(). 1295 // The logic below prevents us from being stuck below at obtainBuffer() 1296 // not being able to handle timed events (position, markers, loops). 1297 int32_t waitCount = -1; 1298 if (mUpdatePeriod || (!mMarkerReached && mMarkerPosition) || mLoopCount) { 1299 waitCount = 1; 1300 } 1301 1302 do { 1303 1304 audioBuffer.frameCount = frames; 1305 1306 status_t err = obtainBuffer(&audioBuffer, waitCount); 1307 if (err < NO_ERROR) { 1308 if (err != TIMED_OUT) { 1309 ALOGE_IF(err != status_t(NO_MORE_BUFFERS), 1310 "Error obtaining an audio buffer, giving up."); 1311 return false; 1312 } 1313 break; 1314 } 1315 if (err == status_t(STOPPED)) { 1316 return false; 1317 } 1318 1319 // Divide buffer size by 2 to take into account the expansion 1320 // due to 8 to 16 bit conversion: the callback must fill only half 1321 // of the destination buffer 1322 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) { 1323 audioBuffer.size >>= 1; 1324 } 1325 1326 size_t reqSize = audioBuffer.size; 1327 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer); 1328 writtenSize = audioBuffer.size; 1329 1330 // Sanity check on returned size 1331 if (ssize_t(writtenSize) <= 0) { 1332 // The callback is done filling buffers 1333 // Keep this thread going to handle timed events and 1334 // still try to get more data in intervals of WAIT_PERIOD_MS 1335 // but don't just loop and block the CPU, so wait 1336 usleep(WAIT_PERIOD_MS*1000); 1337 break; 1338 } 1339 1340 if (writtenSize > reqSize) { 1341 writtenSize = reqSize; 1342 } 1343 1344 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) { 1345 // 8 to 16 bit conversion, note that source and destination are the same address 1346 memcpy_to_i16_from_u8(audioBuffer.i16, (const uint8_t *) audioBuffer.i8, writtenSize); 1347 writtenSize <<= 1; 1348 } 1349 1350 audioBuffer.size = writtenSize; 1351 // NOTE: cblk->frameSize is not equal to AudioTrack::frameSize() for 1352 // 8 bit PCM data: in this case, cblk->frameSize is based on a sample size of 1353 // 16 bit. 1354 audioBuffer.frameCount = writtenSize / mFrameSizeAF; 1355 1356 frames -= audioBuffer.frameCount; 1357 1358 releaseBuffer(&audioBuffer); 1359 } 1360 while (frames); 1361 1362 if (frames == 0) { 1363 mRemainingFrames = mNotificationFramesAct; 1364 } else { 1365 mRemainingFrames = frames; 1366 } 1367 return true; 1368} 1369 1370// must be called with mLock and refCblk.lock held. Callers must also hold strong references on 1371// the IAudioTrack and IMemory in case they are recreated here. 1372// If the IAudioTrack is successfully restored, the refCblk pointer is updated 1373// FIXME Don't depend on caller to hold strong references. 1374status_t AudioTrack::restoreTrack_l(audio_track_cblk_t*& refCblk, bool fromStart) 1375{ 1376 status_t result; 1377 1378 audio_track_cblk_t* cblk = refCblk; 1379 audio_track_cblk_t* newCblk = cblk; 1380 ALOGW("dead IAudioTrack, creating a new one from %s", 1381 fromStart ? "start()" : "obtainBuffer()"); 1382 1383 // signal old cblk condition so that other threads waiting for available buffers stop 1384 // waiting now 1385 cblk->cv.broadcast(); 1386 cblk->lock.unlock(); 1387 1388 // refresh the audio configuration cache in this process to make sure we get new 1389 // output parameters in getOutput_l() and createTrack_l() 1390 AudioSystem::clearAudioConfigCache(); 1391 1392 // if the new IAudioTrack is created, createTrack_l() will modify the 1393 // following member variables: mAudioTrack, mCblkMemory and mCblk. 1394 // It will also delete the strong references on previous IAudioTrack and IMemory 1395 result = createTrack_l(mStreamType, 1396 cblk->sampleRate, 1397 mFormat, 1398 mReqFrameCount, // so that frame count never goes down 1399 mFlags, 1400 mSharedBuffer, 1401 getOutput_l()); 1402 1403 if (result == NO_ERROR) { 1404 uint32_t user = cblk->user; 1405 uint32_t server = cblk->server; 1406 // restore write index and set other indexes to reflect empty buffer status 1407 newCblk = mCblk; 1408 newCblk->user = user; 1409 newCblk->server = user; 1410 newCblk->userBase = user; 1411 newCblk->serverBase = user; 1412 // restore loop: this is not guaranteed to succeed if new frame count is not 1413 // compatible with loop length 1414 setLoop_l(cblk->loopStart, cblk->loopEnd, cblk->loopCount); 1415 if (!fromStart) { 1416 newCblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS; 1417 // Make sure that a client relying on callback events indicating underrun or 1418 // the actual amount of audio frames played (e.g SoundPool) receives them. 1419 if (mSharedBuffer == 0) { 1420 uint32_t frames = 0; 1421 if (user > server) { 1422 frames = ((user - server) > mFrameCount) ? 1423 mFrameCount : (user - server); 1424 memset(mBuffers, 0, frames * mFrameSizeAF); 1425 } 1426 // restart playback even if buffer is not completely filled. 1427 android_atomic_or(CBLK_FORCEREADY, &newCblk->flags); 1428 // stepUser() clears CBLK_UNDERRUN flag enabling underrun callbacks to 1429 // the client 1430 newCblk->stepUserOut(frames, mFrameCount); 1431 } 1432 } 1433 if (mSharedBuffer != 0) { 1434 newCblk->stepUserOut(mFrameCount, mFrameCount); 1435 } 1436 if (mActive) { 1437 result = mAudioTrack->start(); 1438 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() start() failed status %d", result); 1439 } 1440 if (fromStart && result == NO_ERROR) { 1441 mNewPosition = newCblk->server + mUpdatePeriod; 1442 } 1443 } 1444 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() failed status %d", result); 1445 ALOGV("restoreTrack_l() status %d mActive %d cblk %p, old cblk %p flags %08x old flags %08x", 1446 result, mActive, newCblk, cblk, newCblk->flags, cblk->flags); 1447 1448 if (result == NO_ERROR) { 1449 // from now on we switch to the newly created cblk 1450 refCblk = newCblk; 1451 } 1452 newCblk->lock.lock(); 1453 1454 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() error %d", result); 1455 1456 return result; 1457} 1458 1459status_t AudioTrack::dump(int fd, const Vector<String16>& args) const 1460{ 1461 1462 const size_t SIZE = 256; 1463 char buffer[SIZE]; 1464 String8 result; 1465 1466 audio_track_cblk_t* cblk = mCblk; 1467 result.append(" AudioTrack::dump\n"); 1468 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", mStreamType, 1469 mVolume[0], mVolume[1]); 1470 result.append(buffer); 1471 snprintf(buffer, 255, " format(%d), channel count(%d), frame count(%d)\n", mFormat, 1472 mChannelCount, mFrameCount); 1473 result.append(buffer); 1474 snprintf(buffer, 255, " sample rate(%u), status(%d), muted(%d)\n", 1475 (cblk == 0) ? 0 : cblk->sampleRate, mStatus, mMuted); 1476 result.append(buffer); 1477 snprintf(buffer, 255, " active(%d), latency (%d)\n", mActive, mLatency); 1478 result.append(buffer); 1479 ::write(fd, result.string(), result.size()); 1480 return NO_ERROR; 1481} 1482 1483// ========================================================================= 1484 1485AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava) 1486 : Thread(bCanCallJava), mReceiver(receiver), mPaused(true) 1487{ 1488} 1489 1490AudioTrack::AudioTrackThread::~AudioTrackThread() 1491{ 1492} 1493 1494bool AudioTrack::AudioTrackThread::threadLoop() 1495{ 1496 { 1497 AutoMutex _l(mMyLock); 1498 if (mPaused) { 1499 mMyCond.wait(mMyLock); 1500 // caller will check for exitPending() 1501 return true; 1502 } 1503 } 1504 if (!mReceiver.processAudioBuffer(this)) { 1505 pause(); 1506 } 1507 return true; 1508} 1509 1510void AudioTrack::AudioTrackThread::requestExit() 1511{ 1512 // must be in this order to avoid a race condition 1513 Thread::requestExit(); 1514 resume(); 1515} 1516 1517void AudioTrack::AudioTrackThread::pause() 1518{ 1519 AutoMutex _l(mMyLock); 1520 mPaused = true; 1521} 1522 1523void AudioTrack::AudioTrackThread::resume() 1524{ 1525 AutoMutex _l(mMyLock); 1526 if (mPaused) { 1527 mPaused = false; 1528 mMyCond.signal(); 1529 } 1530} 1531 1532// ========================================================================= 1533 1534 1535audio_track_cblk_t::audio_track_cblk_t() 1536 : lock(Mutex::SHARED), cv(Condition::SHARED), user(0), server(0), 1537 userBase(0), serverBase(0), frameCount_(0), 1538 loopStart(UINT_MAX), loopEnd(UINT_MAX), loopCount(0), mVolumeLR(0x10001000), 1539 mSendLevel(0), flags(0) 1540{ 1541} 1542 1543uint32_t audio_track_cblk_t::stepUser(size_t stepCount, size_t frameCount, bool isOut) 1544{ 1545 ALOGV("stepuser %08x %08x %d", user, server, stepCount); 1546 1547 uint32_t u = user; 1548 u += stepCount; 1549 // Ensure that user is never ahead of server for AudioRecord 1550 if (isOut) { 1551 // If stepServer() has been called once, switch to normal obtainBuffer() timeout period 1552 if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS-1) { 1553 bufferTimeoutMs = MAX_RUN_TIMEOUT_MS; 1554 } 1555 } else if (u > server) { 1556 ALOGW("stepUser occurred after track reset"); 1557 u = server; 1558 } 1559 1560 if (u >= frameCount) { 1561 // common case, user didn't just wrap 1562 if (u - frameCount >= userBase ) { 1563 userBase += frameCount; 1564 } 1565 } else if (u >= userBase + frameCount) { 1566 // user just wrapped 1567 userBase += frameCount; 1568 } 1569 1570 user = u; 1571 1572 // Clear flow control error condition as new data has been written/read to/from buffer. 1573 if (flags & CBLK_UNDERRUN) { 1574 android_atomic_and(~CBLK_UNDERRUN, &flags); 1575 } 1576 1577 return u; 1578} 1579 1580bool audio_track_cblk_t::stepServer(size_t stepCount, size_t frameCount, bool isOut) 1581{ 1582 ALOGV("stepserver %08x %08x %d", user, server, stepCount); 1583 1584 if (!tryLock()) { 1585 ALOGW("stepServer() could not lock cblk"); 1586 return false; 1587 } 1588 1589 uint32_t s = server; 1590 bool flushed = (s == user); 1591 1592 s += stepCount; 1593 if (isOut) { 1594 // Mark that we have read the first buffer so that next time stepUser() is called 1595 // we switch to normal obtainBuffer() timeout period 1596 if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS) { 1597 bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS - 1; 1598 } 1599 // It is possible that we receive a flush() 1600 // while the mixer is processing a block: in this case, 1601 // stepServer() is called After the flush() has reset u & s and 1602 // we have s > u 1603 if (flushed) { 1604 ALOGW("stepServer occurred after track reset"); 1605 s = user; 1606 } 1607 } 1608 1609 if (s >= loopEnd) { 1610 ALOGW_IF(s > loopEnd, "stepServer: s %u > loopEnd %u", s, loopEnd); 1611 s = loopStart; 1612 if (--loopCount == 0) { 1613 loopEnd = UINT_MAX; 1614 loopStart = UINT_MAX; 1615 } 1616 } 1617 1618 if (s >= frameCount) { 1619 // common case, server didn't just wrap 1620 if (s - frameCount >= serverBase ) { 1621 serverBase += frameCount; 1622 } 1623 } else if (s >= serverBase + frameCount) { 1624 // server just wrapped 1625 serverBase += frameCount; 1626 } 1627 1628 server = s; 1629 1630 if (!(flags & CBLK_INVALID)) { 1631 cv.signal(); 1632 } 1633 lock.unlock(); 1634 return true; 1635} 1636 1637void* audio_track_cblk_t::buffer(void *buffers, size_t frameSize, uint32_t offset) const 1638{ 1639 return (int8_t *)buffers + (offset - userBase) * frameSize; 1640} 1641 1642uint32_t audio_track_cblk_t::framesAvailable(size_t frameCount, bool isOut) 1643{ 1644 Mutex::Autolock _l(lock); 1645 return framesAvailable_l(frameCount, isOut); 1646} 1647 1648uint32_t audio_track_cblk_t::framesAvailable_l(size_t frameCount, bool isOut) 1649{ 1650 uint32_t u = user; 1651 uint32_t s = server; 1652 1653 if (isOut) { 1654 uint32_t limit = (s < loopStart) ? s : loopStart; 1655 return limit + frameCount - u; 1656 } else { 1657 return frameCount + u - s; 1658 } 1659} 1660 1661uint32_t audio_track_cblk_t::framesReady(bool isOut) 1662{ 1663 uint32_t u = user; 1664 uint32_t s = server; 1665 1666 if (isOut) { 1667 if (u < loopEnd) { 1668 return u - s; 1669 } else { 1670 // do not block on mutex shared with client on AudioFlinger side 1671 if (!tryLock()) { 1672 ALOGW("framesReady() could not lock cblk"); 1673 return 0; 1674 } 1675 uint32_t frames = UINT_MAX; 1676 if (loopCount >= 0) { 1677 frames = (loopEnd - loopStart)*loopCount + u - s; 1678 } 1679 lock.unlock(); 1680 return frames; 1681 } 1682 } else { 1683 return s - u; 1684 } 1685} 1686 1687bool audio_track_cblk_t::tryLock() 1688{ 1689 // the code below simulates lock-with-timeout 1690 // we MUST do this to protect the AudioFlinger server 1691 // as this lock is shared with the client. 1692 status_t err; 1693 1694 err = lock.tryLock(); 1695 if (err == -EBUSY) { // just wait a bit 1696 usleep(1000); 1697 err = lock.tryLock(); 1698 } 1699 if (err != NO_ERROR) { 1700 // probably, the client just died. 1701 return false; 1702 } 1703 return true; 1704} 1705 1706// ------------------------------------------------------------------------- 1707 1708}; // namespace android 1709