1 /* 2 ** 3 ** Copyright 2012, 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_TAG "AudioFlinger" 20 //#define LOG_NDEBUG 0 21 22 #include "Configuration.h" 23 #include <linux/futex.h> 24 #include <math.h> 25 #include <sys/syscall.h> 26 #include <utils/Log.h> 27 28 #include <private/media/AudioTrackShared.h> 29 30 #include "AudioMixer.h" 31 #include "AudioFlinger.h" 32 #include "ServiceUtilities.h" 33 34 #include <media/nbaio/Pipe.h> 35 #include <media/nbaio/PipeReader.h> 36 #include <audio_utils/minifloat.h> 37 38 // ---------------------------------------------------------------------------- 39 40 // Note: the following macro is used for extremely verbose logging message. In 41 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to 42 // 0; but one side effect of this is to turn all LOGV's as well. Some messages 43 // are so verbose that we want to suppress them even when we have ALOG_ASSERT 44 // turned on. Do not uncomment the #def below unless you really know what you 45 // are doing and want to see all of the extremely verbose messages. 46 //#define VERY_VERY_VERBOSE_LOGGING 47 #ifdef VERY_VERY_VERBOSE_LOGGING 48 #define ALOGVV ALOGV 49 #else 50 #define ALOGVV(a...) do { } while(0) 51 #endif 52 53 // TODO move to a common header (Also shared with AudioTrack.cpp) 54 #define NANOS_PER_SECOND 1000000000 55 #define TIME_TO_NANOS(time) ((uint64_t)time.tv_sec * NANOS_PER_SECOND + time.tv_nsec) 56 57 namespace android { 58 59 // ---------------------------------------------------------------------------- 60 // TrackBase 61 // ---------------------------------------------------------------------------- 62 63 static volatile int32_t nextTrackId = 55; 64 65 // TrackBase constructor must be called with AudioFlinger::mLock held 66 AudioFlinger::ThreadBase::TrackBase::TrackBase( 67 ThreadBase *thread, 68 const sp<Client>& client, 69 uint32_t sampleRate, 70 audio_format_t format, 71 audio_channel_mask_t channelMask, 72 size_t frameCount, 73 void *buffer, 74 audio_session_t sessionId, 75 int clientUid, 76 bool isOut, 77 alloc_type alloc, 78 track_type type) 79 : RefBase(), 80 mThread(thread), 81 mClient(client), 82 mCblk(NULL), 83 // mBuffer 84 mState(IDLE), 85 mSampleRate(sampleRate), 86 mFormat(format), 87 mChannelMask(channelMask), 88 mChannelCount(isOut ? 89 audio_channel_count_from_out_mask(channelMask) : 90 audio_channel_count_from_in_mask(channelMask)), 91 mFrameSize(audio_has_proportional_frames(format) ? 92 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)), 93 mFrameCount(frameCount), 94 mSessionId(sessionId), 95 mIsOut(isOut), 96 mServerProxy(NULL), 97 mId(android_atomic_inc(&nextTrackId)), 98 mTerminated(false), 99 mType(type), 100 mThreadIoHandle(thread->id()) 101 { 102 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 103 if (!isTrustedCallingUid(callingUid) || clientUid == -1) { 104 ALOGW_IF(clientUid != -1 && clientUid != (int)callingUid, 105 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, clientUid); 106 clientUid = (int)callingUid; 107 } 108 // clientUid contains the uid of the app that is responsible for this track, so we can blame 109 // battery usage on it. 110 mUid = clientUid; 111 112 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize); 113 size_t size = sizeof(audio_track_cblk_t); 114 size_t bufferSize = (buffer == NULL ? roundup(frameCount) : frameCount) * mFrameSize; 115 if (buffer == NULL && alloc == ALLOC_CBLK) { 116 size += bufferSize; 117 } 118 119 if (client != 0) { 120 mCblkMemory = client->heap()->allocate(size); 121 if (mCblkMemory == 0 || 122 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) { 123 ALOGE("not enough memory for AudioTrack size=%zu", size); 124 client->heap()->dump("AudioTrack"); 125 mCblkMemory.clear(); 126 return; 127 } 128 } else { 129 // this syntax avoids calling the audio_track_cblk_t constructor twice 130 mCblk = (audio_track_cblk_t *) new uint8_t[size]; 131 // assume mCblk != NULL 132 } 133 134 // construct the shared structure in-place. 135 if (mCblk != NULL) { 136 new(mCblk) audio_track_cblk_t(); 137 switch (alloc) { 138 case ALLOC_READONLY: { 139 const sp<MemoryDealer> roHeap(thread->readOnlyHeap()); 140 if (roHeap == 0 || 141 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 || 142 (mBuffer = mBufferMemory->pointer()) == NULL) { 143 ALOGE("not enough memory for read-only buffer size=%zu", bufferSize); 144 if (roHeap != 0) { 145 roHeap->dump("buffer"); 146 } 147 mCblkMemory.clear(); 148 mBufferMemory.clear(); 149 return; 150 } 151 memset(mBuffer, 0, bufferSize); 152 } break; 153 case ALLOC_PIPE: 154 mBufferMemory = thread->pipeMemory(); 155 // mBuffer is the virtual address as seen from current process (mediaserver), 156 // and should normally be coming from mBufferMemory->pointer(). 157 // However in this case the TrackBase does not reference the buffer directly. 158 // It should references the buffer via the pipe. 159 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL. 160 mBuffer = NULL; 161 break; 162 case ALLOC_CBLK: 163 // clear all buffers 164 if (buffer == NULL) { 165 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 166 memset(mBuffer, 0, bufferSize); 167 } else { 168 mBuffer = buffer; 169 #if 0 170 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic 171 #endif 172 } 173 break; 174 case ALLOC_LOCAL: 175 mBuffer = calloc(1, bufferSize); 176 break; 177 case ALLOC_NONE: 178 mBuffer = buffer; 179 break; 180 } 181 182 #ifdef TEE_SINK 183 if (mTeeSinkTrackEnabled) { 184 NBAIO_Format pipeFormat = Format_from_SR_C(mSampleRate, mChannelCount, mFormat); 185 if (Format_isValid(pipeFormat)) { 186 Pipe *pipe = new Pipe(mTeeSinkTrackFrames, pipeFormat); 187 size_t numCounterOffers = 0; 188 const NBAIO_Format offers[1] = {pipeFormat}; 189 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers); 190 ALOG_ASSERT(index == 0); 191 PipeReader *pipeReader = new PipeReader(*pipe); 192 numCounterOffers = 0; 193 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers); 194 ALOG_ASSERT(index == 0); 195 mTeeSink = pipe; 196 mTeeSource = pipeReader; 197 } 198 } 199 #endif 200 201 } 202 } 203 204 status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const 205 { 206 status_t status; 207 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) { 208 status = cblk() != NULL ? NO_ERROR : NO_MEMORY; 209 } else { 210 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY; 211 } 212 return status; 213 } 214 215 AudioFlinger::ThreadBase::TrackBase::~TrackBase() 216 { 217 #ifdef TEE_SINK 218 dumpTee(-1, mTeeSource, mId); 219 #endif 220 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference 221 delete mServerProxy; 222 if (mCblk != NULL) { 223 if (mClient == 0) { 224 delete mCblk; 225 } else { 226 mCblk->~audio_track_cblk_t(); // destroy our shared-structure. 227 } 228 } 229 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to 230 if (mClient != 0) { 231 // Client destructor must run with AudioFlinger client mutex locked 232 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock); 233 // If the client's reference count drops to zero, the associated destructor 234 // must run with AudioFlinger lock held. Thus the explicit clear() rather than 235 // relying on the automatic clear() at end of scope. 236 mClient.clear(); 237 } 238 // flush the binder command buffer 239 IPCThreadState::self()->flushCommands(); 240 } 241 242 // AudioBufferProvider interface 243 // getNextBuffer() = 0; 244 // This implementation of releaseBuffer() is used by Track and RecordTrack 245 void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer) 246 { 247 #ifdef TEE_SINK 248 if (mTeeSink != 0) { 249 (void) mTeeSink->write(buffer->raw, buffer->frameCount); 250 } 251 #endif 252 253 ServerProxy::Buffer buf; 254 buf.mFrameCount = buffer->frameCount; 255 buf.mRaw = buffer->raw; 256 buffer->frameCount = 0; 257 buffer->raw = NULL; 258 mServerProxy->releaseBuffer(&buf); 259 } 260 261 status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event) 262 { 263 mSyncEvents.add(event); 264 return NO_ERROR; 265 } 266 267 // ---------------------------------------------------------------------------- 268 // Playback 269 // ---------------------------------------------------------------------------- 270 271 AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track) 272 : BnAudioTrack(), 273 mTrack(track) 274 { 275 } 276 277 AudioFlinger::TrackHandle::~TrackHandle() { 278 // just stop the track on deletion, associated resources 279 // will be freed from the main thread once all pending buffers have 280 // been played. Unless it's not in the active track list, in which 281 // case we free everything now... 282 mTrack->destroy(); 283 } 284 285 sp<IMemory> AudioFlinger::TrackHandle::getCblk() const { 286 return mTrack->getCblk(); 287 } 288 289 status_t AudioFlinger::TrackHandle::start() { 290 return mTrack->start(); 291 } 292 293 void AudioFlinger::TrackHandle::stop() { 294 mTrack->stop(); 295 } 296 297 void AudioFlinger::TrackHandle::flush() { 298 mTrack->flush(); 299 } 300 301 void AudioFlinger::TrackHandle::pause() { 302 mTrack->pause(); 303 } 304 305 status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId) 306 { 307 return mTrack->attachAuxEffect(EffectId); 308 } 309 310 status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) { 311 return mTrack->setParameters(keyValuePairs); 312 } 313 314 status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp) 315 { 316 return mTrack->getTimestamp(timestamp); 317 } 318 319 320 void AudioFlinger::TrackHandle::signal() 321 { 322 return mTrack->signal(); 323 } 324 325 status_t AudioFlinger::TrackHandle::onTransact( 326 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 327 { 328 return BnAudioTrack::onTransact(code, data, reply, flags); 329 } 330 331 // ---------------------------------------------------------------------------- 332 333 // Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 334 AudioFlinger::PlaybackThread::Track::Track( 335 PlaybackThread *thread, 336 const sp<Client>& client, 337 audio_stream_type_t streamType, 338 uint32_t sampleRate, 339 audio_format_t format, 340 audio_channel_mask_t channelMask, 341 size_t frameCount, 342 void *buffer, 343 const sp<IMemory>& sharedBuffer, 344 audio_session_t sessionId, 345 int uid, 346 audio_output_flags_t flags, 347 track_type type) 348 : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, 349 (sharedBuffer != 0) ? sharedBuffer->pointer() : buffer, 350 sessionId, uid, true /*isOut*/, 351 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK, 352 type), 353 mFillingUpStatus(FS_INVALID), 354 // mRetryCount initialized later when needed 355 mSharedBuffer(sharedBuffer), 356 mStreamType(streamType), 357 mName(-1), // see note below 358 mMainBuffer(thread->mixBuffer()), 359 mAuxBuffer(NULL), 360 mAuxEffectId(0), mHasVolumeController(false), 361 mPresentationCompleteFrames(0), 362 mFrameMap(16 /* sink-frame-to-track-frame map memory */), 363 // mSinkTimestamp 364 mFastIndex(-1), 365 mCachedVolume(1.0), 366 mIsInvalid(false), 367 mAudioTrackServerProxy(NULL), 368 mResumeToStopping(false), 369 mFlushHwPending(false), 370 mFlags(flags) 371 { 372 // client == 0 implies sharedBuffer == 0 373 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0)); 374 375 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(), 376 sharedBuffer->size()); 377 378 if (mCblk == NULL) { 379 return; 380 } 381 382 if (sharedBuffer == 0) { 383 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount, 384 mFrameSize, !isExternalTrack(), sampleRate); 385 } else { 386 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount, 387 mFrameSize); 388 } 389 mServerProxy = mAudioTrackServerProxy; 390 391 mName = thread->getTrackName_l(channelMask, format, sessionId, uid); 392 if (mName < 0) { 393 ALOGE("no more track names available"); 394 return; 395 } 396 // only allocate a fast track index if we were able to allocate a normal track name 397 if (flags & AUDIO_OUTPUT_FLAG_FAST) { 398 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential 399 // race with setSyncEvent(). However, if we call it, we cannot properly start 400 // static fast tracks (SoundPool) immediately after stopping. 401 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads(); 402 ALOG_ASSERT(thread->mFastTrackAvailMask != 0); 403 int i = __builtin_ctz(thread->mFastTrackAvailMask); 404 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks); 405 // FIXME This is too eager. We allocate a fast track index before the 406 // fast track becomes active. Since fast tracks are a scarce resource, 407 // this means we are potentially denying other more important fast tracks from 408 // being created. It would be better to allocate the index dynamically. 409 mFastIndex = i; 410 thread->mFastTrackAvailMask &= ~(1 << i); 411 } 412 } 413 414 AudioFlinger::PlaybackThread::Track::~Track() 415 { 416 ALOGV("PlaybackThread::Track destructor"); 417 418 // The destructor would clear mSharedBuffer, 419 // but it will not push the decremented reference count, 420 // leaving the client's IMemory dangling indefinitely. 421 // This prevents that leak. 422 if (mSharedBuffer != 0) { 423 mSharedBuffer.clear(); 424 } 425 } 426 427 status_t AudioFlinger::PlaybackThread::Track::initCheck() const 428 { 429 status_t status = TrackBase::initCheck(); 430 if (status == NO_ERROR && mName < 0) { 431 status = NO_MEMORY; 432 } 433 return status; 434 } 435 436 void AudioFlinger::PlaybackThread::Track::destroy() 437 { 438 // NOTE: destroyTrack_l() can remove a strong reference to this Track 439 // by removing it from mTracks vector, so there is a risk that this Tracks's 440 // destructor is called. As the destructor needs to lock mLock, 441 // we must acquire a strong reference on this Track before locking mLock 442 // here so that the destructor is called only when exiting this function. 443 // On the other hand, as long as Track::destroy() is only called by 444 // TrackHandle destructor, the TrackHandle still holds a strong ref on 445 // this Track with its member mTrack. 446 sp<Track> keep(this); 447 { // scope for mLock 448 bool wasActive = false; 449 sp<ThreadBase> thread = mThread.promote(); 450 if (thread != 0) { 451 Mutex::Autolock _l(thread->mLock); 452 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 453 wasActive = playbackThread->destroyTrack_l(this); 454 } 455 if (isExternalTrack() && !wasActive) { 456 AudioSystem::releaseOutput(mThreadIoHandle, mStreamType, mSessionId); 457 } 458 } 459 } 460 461 /*static*/ void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result) 462 { 463 result.append(" Name Active Client Type Fmt Chn mask Session fCount S F SRate " 464 "L dB R dB Server Main buf Aux Buf Flags UndFrmCnt\n"); 465 } 466 467 void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size, bool active) 468 { 469 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR(); 470 if (isFastTrack()) { 471 sprintf(buffer, " F %2d", mFastIndex); 472 } else if (mName >= AudioMixer::TRACK0) { 473 sprintf(buffer, " %4d", mName - AudioMixer::TRACK0); 474 } else { 475 sprintf(buffer, " none"); 476 } 477 track_state state = mState; 478 char stateChar; 479 if (isTerminated()) { 480 stateChar = 'T'; 481 } else { 482 switch (state) { 483 case IDLE: 484 stateChar = 'I'; 485 break; 486 case STOPPING_1: 487 stateChar = 's'; 488 break; 489 case STOPPING_2: 490 stateChar = '5'; 491 break; 492 case STOPPED: 493 stateChar = 'S'; 494 break; 495 case RESUMING: 496 stateChar = 'R'; 497 break; 498 case ACTIVE: 499 stateChar = 'A'; 500 break; 501 case PAUSING: 502 stateChar = 'p'; 503 break; 504 case PAUSED: 505 stateChar = 'P'; 506 break; 507 case FLUSHED: 508 stateChar = 'F'; 509 break; 510 default: 511 stateChar = '?'; 512 break; 513 } 514 } 515 char nowInUnderrun; 516 switch (mObservedUnderruns.mBitFields.mMostRecent) { 517 case UNDERRUN_FULL: 518 nowInUnderrun = ' '; 519 break; 520 case UNDERRUN_PARTIAL: 521 nowInUnderrun = '<'; 522 break; 523 case UNDERRUN_EMPTY: 524 nowInUnderrun = '*'; 525 break; 526 default: 527 nowInUnderrun = '?'; 528 break; 529 } 530 snprintf(&buffer[8], size-8, " %6s %6u %4u %08X %08X %7u %6zu %1c %1d %5u %5.2g %5.2g " 531 "%08X %p %p 0x%03X %9u%c\n", 532 active ? "yes" : "no", 533 (mClient == 0) ? getpid_cached : mClient->pid(), 534 mStreamType, 535 mFormat, 536 mChannelMask, 537 mSessionId, 538 mFrameCount, 539 stateChar, 540 mFillingUpStatus, 541 mAudioTrackServerProxy->getSampleRate(), 542 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))), 543 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))), 544 mCblk->mServer, 545 mMainBuffer, 546 mAuxBuffer, 547 mCblk->mFlags, 548 mAudioTrackServerProxy->getUnderrunFrames(), 549 nowInUnderrun); 550 } 551 552 uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const { 553 return mAudioTrackServerProxy->getSampleRate(); 554 } 555 556 // AudioBufferProvider interface 557 status_t AudioFlinger::PlaybackThread::Track::getNextBuffer( 558 AudioBufferProvider::Buffer* buffer) 559 { 560 ServerProxy::Buffer buf; 561 size_t desiredFrames = buffer->frameCount; 562 buf.mFrameCount = desiredFrames; 563 status_t status = mServerProxy->obtainBuffer(&buf); 564 buffer->frameCount = buf.mFrameCount; 565 buffer->raw = buf.mRaw; 566 if (buf.mFrameCount == 0) { 567 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames); 568 } else { 569 mAudioTrackServerProxy->tallyUnderrunFrames(0); 570 } 571 572 return status; 573 } 574 575 // releaseBuffer() is not overridden 576 577 // ExtendedAudioBufferProvider interface 578 579 // framesReady() may return an approximation of the number of frames if called 580 // from a different thread than the one calling Proxy->obtainBuffer() and 581 // Proxy->releaseBuffer(). Also note there is no mutual exclusion in the 582 // AudioTrackServerProxy so be especially careful calling with FastTracks. 583 size_t AudioFlinger::PlaybackThread::Track::framesReady() const { 584 if (mSharedBuffer != 0 && (isStopped() || isStopping())) { 585 // Static tracks return zero frames immediately upon stopping (for FastTracks). 586 // The remainder of the buffer is not drained. 587 return 0; 588 } 589 return mAudioTrackServerProxy->framesReady(); 590 } 591 592 int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const 593 { 594 return mAudioTrackServerProxy->framesReleased(); 595 } 596 597 void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp ×tamp) 598 { 599 // This call comes from a FastTrack and should be kept lockless. 600 // The server side frames are already translated to client frames. 601 mAudioTrackServerProxy->setTimestamp(timestamp); 602 603 // We do not set drained here, as FastTrack timestamp may not go to very last frame. 604 } 605 606 // Don't call for fast tracks; the framesReady() could result in priority inversion 607 bool AudioFlinger::PlaybackThread::Track::isReady() const { 608 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) { 609 return true; 610 } 611 612 if (isStopping()) { 613 if (framesReady() > 0) { 614 mFillingUpStatus = FS_FILLED; 615 } 616 return true; 617 } 618 619 if (framesReady() >= mServerProxy->getBufferSizeInFrames() || 620 (mCblk->mFlags & CBLK_FORCEREADY)) { 621 mFillingUpStatus = FS_FILLED; 622 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 623 return true; 624 } 625 return false; 626 } 627 628 status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused, 629 audio_session_t triggerSession __unused) 630 { 631 status_t status = NO_ERROR; 632 ALOGV("start(%d), calling pid %d session %d", 633 mName, IPCThreadState::self()->getCallingPid(), mSessionId); 634 635 sp<ThreadBase> thread = mThread.promote(); 636 if (thread != 0) { 637 if (isOffloaded()) { 638 Mutex::Autolock _laf(thread->mAudioFlinger->mLock); 639 Mutex::Autolock _lth(thread->mLock); 640 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId); 641 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() || 642 (ec != 0 && ec->isNonOffloadableEnabled())) { 643 invalidate(); 644 return PERMISSION_DENIED; 645 } 646 } 647 Mutex::Autolock _lth(thread->mLock); 648 track_state state = mState; 649 // here the track could be either new, or restarted 650 // in both cases "unstop" the track 651 652 // initial state-stopping. next state-pausing. 653 // What if resume is called ? 654 655 if (state == PAUSED || state == PAUSING) { 656 if (mResumeToStopping) { 657 // happened we need to resume to STOPPING_1 658 mState = TrackBase::STOPPING_1; 659 ALOGV("PAUSED => STOPPING_1 (%d) on thread %p", mName, this); 660 } else { 661 mState = TrackBase::RESUMING; 662 ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this); 663 } 664 } else { 665 mState = TrackBase::ACTIVE; 666 ALOGV("? => ACTIVE (%d) on thread %p", mName, this); 667 } 668 669 // states to reset position info for non-offloaded/direct tracks 670 if (!isOffloaded() && !isDirect() 671 && (state == IDLE || state == STOPPED || state == FLUSHED)) { 672 mFrameMap.reset(); 673 } 674 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 675 if (isFastTrack()) { 676 // refresh fast track underruns on start because that field is never cleared 677 // by the fast mixer; furthermore, the same track can be recycled, i.e. start 678 // after stop. 679 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex); 680 } 681 status = playbackThread->addTrack_l(this); 682 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) { 683 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 684 // restore previous state if start was rejected by policy manager 685 if (status == PERMISSION_DENIED) { 686 mState = state; 687 } 688 } 689 // track was already in the active list, not a problem 690 if (status == ALREADY_EXISTS) { 691 status = NO_ERROR; 692 } else { 693 // Acknowledge any pending flush(), so that subsequent new data isn't discarded. 694 // It is usually unsafe to access the server proxy from a binder thread. 695 // But in this case we know the mixer thread (whether normal mixer or fast mixer) 696 // isn't looking at this track yet: we still hold the normal mixer thread lock, 697 // and for fast tracks the track is not yet in the fast mixer thread's active set. 698 // For static tracks, this is used to acknowledge change in position or loop. 699 ServerProxy::Buffer buffer; 700 buffer.mFrameCount = 1; 701 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/); 702 } 703 } else { 704 status = BAD_VALUE; 705 } 706 return status; 707 } 708 709 void AudioFlinger::PlaybackThread::Track::stop() 710 { 711 ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 712 sp<ThreadBase> thread = mThread.promote(); 713 if (thread != 0) { 714 Mutex::Autolock _l(thread->mLock); 715 track_state state = mState; 716 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) { 717 // If the track is not active (PAUSED and buffers full), flush buffers 718 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 719 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 720 reset(); 721 mState = STOPPED; 722 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) { 723 mState = STOPPED; 724 } else { 725 // For fast tracks prepareTracks_l() will set state to STOPPING_2 726 // presentation is complete 727 // For an offloaded track this starts a drain and state will 728 // move to STOPPING_2 when drain completes and then STOPPED 729 mState = STOPPING_1; 730 if (isOffloaded()) { 731 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload; 732 } 733 } 734 playbackThread->broadcast_l(); 735 ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName, 736 playbackThread); 737 } 738 } 739 } 740 741 void AudioFlinger::PlaybackThread::Track::pause() 742 { 743 ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 744 sp<ThreadBase> thread = mThread.promote(); 745 if (thread != 0) { 746 Mutex::Autolock _l(thread->mLock); 747 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 748 switch (mState) { 749 case STOPPING_1: 750 case STOPPING_2: 751 if (!isOffloaded()) { 752 /* nothing to do if track is not offloaded */ 753 break; 754 } 755 756 // Offloaded track was draining, we need to carry on draining when resumed 757 mResumeToStopping = true; 758 // fall through... 759 case ACTIVE: 760 case RESUMING: 761 mState = PAUSING; 762 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get()); 763 playbackThread->broadcast_l(); 764 break; 765 766 default: 767 break; 768 } 769 } 770 } 771 772 void AudioFlinger::PlaybackThread::Track::flush() 773 { 774 ALOGV("flush(%d)", mName); 775 sp<ThreadBase> thread = mThread.promote(); 776 if (thread != 0) { 777 Mutex::Autolock _l(thread->mLock); 778 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 779 780 // Flush the ring buffer now if the track is not active in the PlaybackThread. 781 // Otherwise the flush would not be done until the track is resumed. 782 // Requires FastTrack removal be BLOCK_UNTIL_ACKED 783 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 784 (void)mServerProxy->flushBufferIfNeeded(); 785 } 786 787 if (isOffloaded()) { 788 // If offloaded we allow flush during any state except terminated 789 // and keep the track active to avoid problems if user is seeking 790 // rapidly and underlying hardware has a significant delay handling 791 // a pause 792 if (isTerminated()) { 793 return; 794 } 795 796 ALOGV("flush: offload flush"); 797 reset(); 798 799 if (mState == STOPPING_1 || mState == STOPPING_2) { 800 ALOGV("flushed in STOPPING_1 or 2 state, change state to ACTIVE"); 801 mState = ACTIVE; 802 } 803 804 mFlushHwPending = true; 805 mResumeToStopping = false; 806 } else { 807 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED && 808 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) { 809 return; 810 } 811 // No point remaining in PAUSED state after a flush => go to 812 // FLUSHED state 813 mState = FLUSHED; 814 // do not reset the track if it is still in the process of being stopped or paused. 815 // this will be done by prepareTracks_l() when the track is stopped. 816 // prepareTracks_l() will see mState == FLUSHED, then 817 // remove from active track list, reset(), and trigger presentation complete 818 if (isDirect()) { 819 mFlushHwPending = true; 820 } 821 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 822 reset(); 823 } 824 } 825 // Prevent flush being lost if the track is flushed and then resumed 826 // before mixer thread can run. This is important when offloading 827 // because the hardware buffer could hold a large amount of audio 828 playbackThread->broadcast_l(); 829 } 830 } 831 832 // must be called with thread lock held 833 void AudioFlinger::PlaybackThread::Track::flushAck() 834 { 835 if (!isOffloaded() && !isDirect()) 836 return; 837 838 // Clear the client ring buffer so that the app can prime the buffer while paused. 839 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called. 840 mServerProxy->flushBufferIfNeeded(); 841 842 mFlushHwPending = false; 843 } 844 845 void AudioFlinger::PlaybackThread::Track::reset() 846 { 847 // Do not reset twice to avoid discarding data written just after a flush and before 848 // the audioflinger thread detects the track is stopped. 849 if (!mResetDone) { 850 // Force underrun condition to avoid false underrun callback until first data is 851 // written to buffer 852 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 853 mFillingUpStatus = FS_FILLING; 854 mResetDone = true; 855 if (mState == FLUSHED) { 856 mState = IDLE; 857 } 858 } 859 } 860 861 status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs) 862 { 863 sp<ThreadBase> thread = mThread.promote(); 864 if (thread == 0) { 865 ALOGE("thread is dead"); 866 return FAILED_TRANSACTION; 867 } else if ((thread->type() == ThreadBase::DIRECT) || 868 (thread->type() == ThreadBase::OFFLOAD)) { 869 return thread->setParameters(keyValuePairs); 870 } else { 871 return PERMISSION_DENIED; 872 } 873 } 874 875 status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp) 876 { 877 if (!isOffloaded() && !isDirect()) { 878 return INVALID_OPERATION; // normal tracks handled through SSQ 879 } 880 sp<ThreadBase> thread = mThread.promote(); 881 if (thread == 0) { 882 return INVALID_OPERATION; 883 } 884 885 Mutex::Autolock _l(thread->mLock); 886 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 887 return playbackThread->getTimestamp_l(timestamp); 888 } 889 890 status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId) 891 { 892 status_t status = DEAD_OBJECT; 893 sp<ThreadBase> thread = mThread.promote(); 894 if (thread != 0) { 895 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 896 sp<AudioFlinger> af = mClient->audioFlinger(); 897 898 Mutex::Autolock _l(af->mLock); 899 900 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId); 901 902 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) { 903 Mutex::Autolock _dl(playbackThread->mLock); 904 Mutex::Autolock _sl(srcThread->mLock); 905 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); 906 if (chain == 0) { 907 return INVALID_OPERATION; 908 } 909 910 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId); 911 if (effect == 0) { 912 return INVALID_OPERATION; 913 } 914 srcThread->removeEffect_l(effect); 915 status = playbackThread->addEffect_l(effect); 916 if (status != NO_ERROR) { 917 srcThread->addEffect_l(effect); 918 return INVALID_OPERATION; 919 } 920 // removeEffect_l() has stopped the effect if it was active so it must be restarted 921 if (effect->state() == EffectModule::ACTIVE || 922 effect->state() == EffectModule::STOPPING) { 923 effect->start(); 924 } 925 926 sp<EffectChain> dstChain = effect->chain().promote(); 927 if (dstChain == 0) { 928 srcThread->addEffect_l(effect); 929 return INVALID_OPERATION; 930 } 931 AudioSystem::unregisterEffect(effect->id()); 932 AudioSystem::registerEffect(&effect->desc(), 933 srcThread->id(), 934 dstChain->strategy(), 935 AUDIO_SESSION_OUTPUT_MIX, 936 effect->id()); 937 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled()); 938 } 939 status = playbackThread->attachAuxEffect(this, EffectId); 940 } 941 return status; 942 } 943 944 void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer) 945 { 946 mAuxEffectId = EffectId; 947 mAuxBuffer = buffer; 948 } 949 950 bool AudioFlinger::PlaybackThread::Track::presentationComplete( 951 int64_t framesWritten, size_t audioHalFrames) 952 { 953 // TODO: improve this based on FrameMap if it exists, to ensure full drain. 954 // This assists in proper timestamp computation as well as wakelock management. 955 956 // a track is considered presented when the total number of frames written to audio HAL 957 // corresponds to the number of frames written when presentationComplete() is called for the 958 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time. 959 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used 960 // to detect when all frames have been played. In this case framesWritten isn't 961 // useful because it doesn't always reflect whether there is data in the h/w 962 // buffers, particularly if a track has been paused and resumed during draining 963 ALOGV("presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld", 964 (long long)mPresentationCompleteFrames, (long long)framesWritten); 965 if (mPresentationCompleteFrames == 0) { 966 mPresentationCompleteFrames = framesWritten + audioHalFrames; 967 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %lld audioHalFrames %zu", 968 (long long)mPresentationCompleteFrames, audioHalFrames); 969 } 970 971 bool complete; 972 if (isOffloaded()) { 973 complete = true; 974 } else if (isDirect() || isFastTrack()) { // these do not go through linear map 975 complete = framesWritten >= (int64_t) mPresentationCompleteFrames; 976 } else { // Normal tracks, OutputTracks, and PatchTracks 977 complete = framesWritten >= (int64_t) mPresentationCompleteFrames 978 && mAudioTrackServerProxy->isDrained(); 979 } 980 981 if (complete) { 982 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 983 mAudioTrackServerProxy->setStreamEndDone(); 984 return true; 985 } 986 return false; 987 } 988 989 void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type) 990 { 991 for (size_t i = 0; i < mSyncEvents.size(); i++) { 992 if (mSyncEvents[i]->type() == type) { 993 mSyncEvents[i]->trigger(); 994 mSyncEvents.removeAt(i); 995 i--; 996 } 997 } 998 } 999 1000 // implement VolumeBufferProvider interface 1001 1002 gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR() 1003 { 1004 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs 1005 ALOG_ASSERT(isFastTrack() && (mCblk != NULL)); 1006 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR(); 1007 float vl = float_from_gain(gain_minifloat_unpack_left(vlr)); 1008 float vr = float_from_gain(gain_minifloat_unpack_right(vlr)); 1009 // track volumes come from shared memory, so can't be trusted and must be clamped 1010 if (vl > GAIN_FLOAT_UNITY) { 1011 vl = GAIN_FLOAT_UNITY; 1012 } 1013 if (vr > GAIN_FLOAT_UNITY) { 1014 vr = GAIN_FLOAT_UNITY; 1015 } 1016 // now apply the cached master volume and stream type volume; 1017 // this is trusted but lacks any synchronization or barrier so may be stale 1018 float v = mCachedVolume; 1019 vl *= v; 1020 vr *= v; 1021 // re-combine into packed minifloat 1022 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr)); 1023 // FIXME look at mute, pause, and stop flags 1024 return vlr; 1025 } 1026 1027 status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event) 1028 { 1029 if (isTerminated() || mState == PAUSED || 1030 ((framesReady() == 0) && ((mSharedBuffer != 0) || 1031 (mState == STOPPED)))) { 1032 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %zu", 1033 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady()); 1034 event->cancel(); 1035 return INVALID_OPERATION; 1036 } 1037 (void) TrackBase::setSyncEvent(event); 1038 return NO_ERROR; 1039 } 1040 1041 void AudioFlinger::PlaybackThread::Track::invalidate() 1042 { 1043 signalClientFlag(CBLK_INVALID); 1044 mIsInvalid = true; 1045 } 1046 1047 void AudioFlinger::PlaybackThread::Track::disable() 1048 { 1049 signalClientFlag(CBLK_DISABLED); 1050 } 1051 1052 void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag) 1053 { 1054 // FIXME should use proxy, and needs work 1055 audio_track_cblk_t* cblk = mCblk; 1056 android_atomic_or(flag, &cblk->mFlags); 1057 android_atomic_release_store(0x40000000, &cblk->mFutex); 1058 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 1059 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX); 1060 } 1061 1062 void AudioFlinger::PlaybackThread::Track::signal() 1063 { 1064 sp<ThreadBase> thread = mThread.promote(); 1065 if (thread != 0) { 1066 PlaybackThread *t = (PlaybackThread *)thread.get(); 1067 Mutex::Autolock _l(t->mLock); 1068 t->broadcast_l(); 1069 } 1070 } 1071 1072 //To be called with thread lock held 1073 bool AudioFlinger::PlaybackThread::Track::isResumePending() { 1074 1075 if (mState == RESUMING) 1076 return true; 1077 /* Resume is pending if track was stopping before pause was called */ 1078 if (mState == STOPPING_1 && 1079 mResumeToStopping) 1080 return true; 1081 1082 return false; 1083 } 1084 1085 //To be called with thread lock held 1086 void AudioFlinger::PlaybackThread::Track::resumeAck() { 1087 1088 1089 if (mState == RESUMING) 1090 mState = ACTIVE; 1091 1092 // Other possibility of pending resume is stopping_1 state 1093 // Do not update the state from stopping as this prevents 1094 // drain being called. 1095 if (mState == STOPPING_1) { 1096 mResumeToStopping = false; 1097 } 1098 } 1099 1100 //To be called with thread lock held 1101 void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo( 1102 int64_t trackFramesReleased, int64_t sinkFramesWritten, 1103 const ExtendedTimestamp &timeStamp) { 1104 //update frame map 1105 mFrameMap.push(trackFramesReleased, sinkFramesWritten); 1106 1107 // adjust server times and set drained state. 1108 // 1109 // Our timestamps are only updated when the track is on the Thread active list. 1110 // We need to ensure that tracks are not removed before full drain. 1111 ExtendedTimestamp local = timeStamp; 1112 bool checked = false; 1113 for (int i = ExtendedTimestamp::LOCATION_MAX - 1; 1114 i >= ExtendedTimestamp::LOCATION_SERVER; --i) { 1115 // Lookup the track frame corresponding to the sink frame position. 1116 if (local.mTimeNs[i] > 0) { 1117 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]); 1118 // check drain state from the latest stage in the pipeline. 1119 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) { 1120 mAudioTrackServerProxy->setDrained( 1121 local.mPosition[i] >= mAudioTrackServerProxy->framesReleased()); 1122 checked = true; 1123 } 1124 } 1125 } 1126 if (!checked) { // no server info, assume drained. 1127 mAudioTrackServerProxy->setDrained(true); 1128 } 1129 // Set correction for flushed frames that are not accounted for in released. 1130 local.mFlushed = mAudioTrackServerProxy->framesFlushed(); 1131 mServerProxy->setTimestamp(local); 1132 } 1133 1134 // ---------------------------------------------------------------------------- 1135 1136 AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( 1137 PlaybackThread *playbackThread, 1138 DuplicatingThread *sourceThread, 1139 uint32_t sampleRate, 1140 audio_format_t format, 1141 audio_channel_mask_t channelMask, 1142 size_t frameCount, 1143 int uid) 1144 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH, 1145 sampleRate, format, channelMask, frameCount, 1146 NULL, 0, AUDIO_SESSION_NONE, uid, AUDIO_OUTPUT_FLAG_NONE, 1147 TYPE_OUTPUT), 1148 mActive(false), mSourceThread(sourceThread), mClientProxy(NULL) 1149 { 1150 1151 if (mCblk != NULL) { 1152 mOutBuffer.frameCount = 0; 1153 playbackThread->mTracks.add(this); 1154 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, " 1155 "frameCount %zu, mChannelMask 0x%08x", 1156 mCblk, mBuffer, 1157 frameCount, mChannelMask); 1158 // since client and server are in the same process, 1159 // the buffer has the same virtual address on both sides 1160 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize, 1161 true /*clientInServer*/); 1162 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY); 1163 mClientProxy->setSendLevel(0.0); 1164 mClientProxy->setSampleRate(sampleRate); 1165 } else { 1166 ALOGW("Error creating output track on thread %p", playbackThread); 1167 } 1168 } 1169 1170 AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack() 1171 { 1172 clearBufferQueue(); 1173 delete mClientProxy; 1174 // superclass destructor will now delete the server proxy and shared memory both refer to 1175 } 1176 1177 status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event, 1178 audio_session_t triggerSession) 1179 { 1180 status_t status = Track::start(event, triggerSession); 1181 if (status != NO_ERROR) { 1182 return status; 1183 } 1184 1185 mActive = true; 1186 mRetryCount = 127; 1187 return status; 1188 } 1189 1190 void AudioFlinger::PlaybackThread::OutputTrack::stop() 1191 { 1192 Track::stop(); 1193 clearBufferQueue(); 1194 mOutBuffer.frameCount = 0; 1195 mActive = false; 1196 } 1197 1198 bool AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames) 1199 { 1200 Buffer *pInBuffer; 1201 Buffer inBuffer; 1202 bool outputBufferFull = false; 1203 inBuffer.frameCount = frames; 1204 inBuffer.raw = data; 1205 1206 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); 1207 1208 if (!mActive && frames != 0) { 1209 (void) start(); 1210 } 1211 1212 while (waitTimeLeftMs) { 1213 // First write pending buffers, then new data 1214 if (mBufferQueue.size()) { 1215 pInBuffer = mBufferQueue.itemAt(0); 1216 } else { 1217 pInBuffer = &inBuffer; 1218 } 1219 1220 if (pInBuffer->frameCount == 0) { 1221 break; 1222 } 1223 1224 if (mOutBuffer.frameCount == 0) { 1225 mOutBuffer.frameCount = pInBuffer->frameCount; 1226 nsecs_t startTime = systemTime(); 1227 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs); 1228 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) { 1229 ALOGV("OutputTrack::write() %p thread %p no more output buffers; status %d", this, 1230 mThread.unsafe_get(), status); 1231 outputBufferFull = true; 1232 break; 1233 } 1234 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); 1235 if (waitTimeLeftMs >= waitTimeMs) { 1236 waitTimeLeftMs -= waitTimeMs; 1237 } else { 1238 waitTimeLeftMs = 0; 1239 } 1240 if (status == NOT_ENOUGH_DATA) { 1241 restartIfDisabled(); 1242 continue; 1243 } 1244 } 1245 1246 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : 1247 pInBuffer->frameCount; 1248 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize); 1249 Proxy::Buffer buf; 1250 buf.mFrameCount = outFrames; 1251 buf.mRaw = NULL; 1252 mClientProxy->releaseBuffer(&buf); 1253 restartIfDisabled(); 1254 pInBuffer->frameCount -= outFrames; 1255 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize; 1256 mOutBuffer.frameCount -= outFrames; 1257 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize; 1258 1259 if (pInBuffer->frameCount == 0) { 1260 if (mBufferQueue.size()) { 1261 mBufferQueue.removeAt(0); 1262 free(pInBuffer->mBuffer); 1263 delete pInBuffer; 1264 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %zu", this, 1265 mThread.unsafe_get(), mBufferQueue.size()); 1266 } else { 1267 break; 1268 } 1269 } 1270 } 1271 1272 // If we could not write all frames, allocate a buffer and queue it for next time. 1273 if (inBuffer.frameCount) { 1274 sp<ThreadBase> thread = mThread.promote(); 1275 if (thread != 0 && !thread->standby()) { 1276 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 1277 pInBuffer = new Buffer; 1278 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize); 1279 pInBuffer->frameCount = inBuffer.frameCount; 1280 pInBuffer->raw = pInBuffer->mBuffer; 1281 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize); 1282 mBufferQueue.add(pInBuffer); 1283 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %zu", this, 1284 mThread.unsafe_get(), mBufferQueue.size()); 1285 } else { 1286 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers", 1287 mThread.unsafe_get(), this); 1288 } 1289 } 1290 } 1291 1292 // Calling write() with a 0 length buffer means that no more data will be written: 1293 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out. 1294 if (frames == 0 && mBufferQueue.size() == 0 && mActive) { 1295 stop(); 1296 } 1297 1298 return outputBufferFull; 1299 } 1300 1301 status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer( 1302 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs) 1303 { 1304 ClientProxy::Buffer buf; 1305 buf.mFrameCount = buffer->frameCount; 1306 struct timespec timeout; 1307 timeout.tv_sec = waitTimeMs / 1000; 1308 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000; 1309 status_t status = mClientProxy->obtainBuffer(&buf, &timeout); 1310 buffer->frameCount = buf.mFrameCount; 1311 buffer->raw = buf.mRaw; 1312 return status; 1313 } 1314 1315 void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue() 1316 { 1317 size_t size = mBufferQueue.size(); 1318 1319 for (size_t i = 0; i < size; i++) { 1320 Buffer *pBuffer = mBufferQueue.itemAt(i); 1321 free(pBuffer->mBuffer); 1322 delete pBuffer; 1323 } 1324 mBufferQueue.clear(); 1325 } 1326 1327 void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled() 1328 { 1329 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags); 1330 if (mActive && (flags & CBLK_DISABLED)) { 1331 start(); 1332 } 1333 } 1334 1335 AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread, 1336 audio_stream_type_t streamType, 1337 uint32_t sampleRate, 1338 audio_channel_mask_t channelMask, 1339 audio_format_t format, 1340 size_t frameCount, 1341 void *buffer, 1342 audio_output_flags_t flags) 1343 : Track(playbackThread, NULL, streamType, 1344 sampleRate, format, channelMask, frameCount, 1345 buffer, 0, AUDIO_SESSION_NONE, getuid(), flags, TYPE_PATCH), 1346 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true)) 1347 { 1348 uint64_t mixBufferNs = ((uint64_t)2 * playbackThread->frameCount() * 1000000000) / 1349 playbackThread->sampleRate(); 1350 mPeerTimeout.tv_sec = mixBufferNs / 1000000000; 1351 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000); 1352 1353 ALOGV("PatchTrack %p sampleRate %d mPeerTimeout %d.%03d sec", 1354 this, sampleRate, 1355 (int)mPeerTimeout.tv_sec, 1356 (int)(mPeerTimeout.tv_nsec / 1000000)); 1357 } 1358 1359 AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack() 1360 { 1361 } 1362 1363 status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event, 1364 audio_session_t triggerSession) 1365 { 1366 status_t status = Track::start(event, triggerSession); 1367 if (status != NO_ERROR) { 1368 return status; 1369 } 1370 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags); 1371 return status; 1372 } 1373 1374 // AudioBufferProvider interface 1375 status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer( 1376 AudioBufferProvider::Buffer* buffer) 1377 { 1378 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::getNextBuffer() called without peer proxy"); 1379 Proxy::Buffer buf; 1380 buf.mFrameCount = buffer->frameCount; 1381 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout); 1382 ALOGV_IF(status != NO_ERROR, "PatchTrack() %p getNextBuffer status %d", this, status); 1383 buffer->frameCount = buf.mFrameCount; 1384 if (buf.mFrameCount == 0) { 1385 return WOULD_BLOCK; 1386 } 1387 status = Track::getNextBuffer(buffer); 1388 return status; 1389 } 1390 1391 void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer) 1392 { 1393 ALOG_ASSERT(mPeerProxy != 0, "PatchTrack::releaseBuffer() called without peer proxy"); 1394 Proxy::Buffer buf; 1395 buf.mFrameCount = buffer->frameCount; 1396 buf.mRaw = buffer->raw; 1397 mPeerProxy->releaseBuffer(&buf); 1398 TrackBase::releaseBuffer(buffer); 1399 } 1400 1401 status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer, 1402 const struct timespec *timeOut) 1403 { 1404 status_t status = NO_ERROR; 1405 static const int32_t kMaxTries = 5; 1406 int32_t tryCounter = kMaxTries; 1407 do { 1408 if (status == NOT_ENOUGH_DATA) { 1409 restartIfDisabled(); 1410 } 1411 status = mProxy->obtainBuffer(buffer, timeOut); 1412 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0)); 1413 return status; 1414 } 1415 1416 void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer) 1417 { 1418 mProxy->releaseBuffer(buffer); 1419 restartIfDisabled(); 1420 android_atomic_or(CBLK_FORCEREADY, &mCblk->mFlags); 1421 } 1422 1423 void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled() 1424 { 1425 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) { 1426 ALOGW("PatchTrack::releaseBuffer() disabled due to previous underrun, restarting"); 1427 start(); 1428 } 1429 } 1430 1431 // ---------------------------------------------------------------------------- 1432 // Record 1433 // ---------------------------------------------------------------------------- 1434 1435 AudioFlinger::RecordHandle::RecordHandle( 1436 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack) 1437 : BnAudioRecord(), 1438 mRecordTrack(recordTrack) 1439 { 1440 } 1441 1442 AudioFlinger::RecordHandle::~RecordHandle() { 1443 stop_nonvirtual(); 1444 mRecordTrack->destroy(); 1445 } 1446 1447 status_t AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event, 1448 audio_session_t triggerSession) { 1449 ALOGV("RecordHandle::start()"); 1450 return mRecordTrack->start((AudioSystem::sync_event_t)event, triggerSession); 1451 } 1452 1453 void AudioFlinger::RecordHandle::stop() { 1454 stop_nonvirtual(); 1455 } 1456 1457 void AudioFlinger::RecordHandle::stop_nonvirtual() { 1458 ALOGV("RecordHandle::stop()"); 1459 mRecordTrack->stop(); 1460 } 1461 1462 status_t AudioFlinger::RecordHandle::onTransact( 1463 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1464 { 1465 return BnAudioRecord::onTransact(code, data, reply, flags); 1466 } 1467 1468 // ---------------------------------------------------------------------------- 1469 1470 // RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 1471 AudioFlinger::RecordThread::RecordTrack::RecordTrack( 1472 RecordThread *thread, 1473 const sp<Client>& client, 1474 uint32_t sampleRate, 1475 audio_format_t format, 1476 audio_channel_mask_t channelMask, 1477 size_t frameCount, 1478 void *buffer, 1479 audio_session_t sessionId, 1480 int uid, 1481 audio_input_flags_t flags, 1482 track_type type) 1483 : TrackBase(thread, client, sampleRate, format, 1484 channelMask, frameCount, buffer, sessionId, uid, false /*isOut*/, 1485 (type == TYPE_DEFAULT) ? 1486 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) : 1487 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE), 1488 type), 1489 mOverflow(false), 1490 mFramesToDrop(0), 1491 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit 1492 mRecordBufferConverter(NULL), 1493 mFlags(flags) 1494 { 1495 if (mCblk == NULL) { 1496 return; 1497 } 1498 1499 mRecordBufferConverter = new RecordBufferConverter( 1500 thread->mChannelMask, thread->mFormat, thread->mSampleRate, 1501 channelMask, format, sampleRate); 1502 // Check if the RecordBufferConverter construction was successful. 1503 // If not, don't continue with construction. 1504 // 1505 // NOTE: It would be extremely rare that the record track cannot be created 1506 // for the current device, but a pending or future device change would make 1507 // the record track configuration valid. 1508 if (mRecordBufferConverter->initCheck() != NO_ERROR) { 1509 ALOGE("RecordTrack unable to create record buffer converter"); 1510 return; 1511 } 1512 1513 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount, 1514 mFrameSize, !isExternalTrack()); 1515 1516 mResamplerBufferProvider = new ResamplerBufferProvider(this); 1517 1518 if (flags & AUDIO_INPUT_FLAG_FAST) { 1519 ALOG_ASSERT(thread->mFastTrackAvail); 1520 thread->mFastTrackAvail = false; 1521 } 1522 } 1523 1524 AudioFlinger::RecordThread::RecordTrack::~RecordTrack() 1525 { 1526 ALOGV("%s", __func__); 1527 delete mRecordBufferConverter; 1528 delete mResamplerBufferProvider; 1529 } 1530 1531 status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const 1532 { 1533 status_t status = TrackBase::initCheck(); 1534 if (status == NO_ERROR && mServerProxy == 0) { 1535 status = BAD_VALUE; 1536 } 1537 return status; 1538 } 1539 1540 // AudioBufferProvider interface 1541 status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer) 1542 { 1543 ServerProxy::Buffer buf; 1544 buf.mFrameCount = buffer->frameCount; 1545 status_t status = mServerProxy->obtainBuffer(&buf); 1546 buffer->frameCount = buf.mFrameCount; 1547 buffer->raw = buf.mRaw; 1548 if (buf.mFrameCount == 0) { 1549 // FIXME also wake futex so that overrun is noticed more quickly 1550 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags); 1551 } 1552 return status; 1553 } 1554 1555 status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event, 1556 audio_session_t triggerSession) 1557 { 1558 sp<ThreadBase> thread = mThread.promote(); 1559 if (thread != 0) { 1560 RecordThread *recordThread = (RecordThread *)thread.get(); 1561 return recordThread->start(this, event, triggerSession); 1562 } else { 1563 return BAD_VALUE; 1564 } 1565 } 1566 1567 void AudioFlinger::RecordThread::RecordTrack::stop() 1568 { 1569 sp<ThreadBase> thread = mThread.promote(); 1570 if (thread != 0) { 1571 RecordThread *recordThread = (RecordThread *)thread.get(); 1572 if (recordThread->stop(this) && isExternalTrack()) { 1573 AudioSystem::stopInput(mThreadIoHandle, mSessionId); 1574 } 1575 } 1576 } 1577 1578 void AudioFlinger::RecordThread::RecordTrack::destroy() 1579 { 1580 // see comments at AudioFlinger::PlaybackThread::Track::destroy() 1581 sp<RecordTrack> keep(this); 1582 { 1583 if (isExternalTrack()) { 1584 if (mState == ACTIVE || mState == RESUMING) { 1585 AudioSystem::stopInput(mThreadIoHandle, mSessionId); 1586 } 1587 AudioSystem::releaseInput(mThreadIoHandle, mSessionId); 1588 } 1589 sp<ThreadBase> thread = mThread.promote(); 1590 if (thread != 0) { 1591 Mutex::Autolock _l(thread->mLock); 1592 RecordThread *recordThread = (RecordThread *) thread.get(); 1593 recordThread->destroyTrack_l(this); 1594 } 1595 } 1596 } 1597 1598 void AudioFlinger::RecordThread::RecordTrack::invalidate() 1599 { 1600 // FIXME should use proxy, and needs work 1601 audio_track_cblk_t* cblk = mCblk; 1602 android_atomic_or(CBLK_INVALID, &cblk->mFlags); 1603 android_atomic_release_store(0x40000000, &cblk->mFutex); 1604 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 1605 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX); 1606 } 1607 1608 1609 /*static*/ void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result) 1610 { 1611 result.append(" Active Client Fmt Chn mask Session S Server fCount SRate\n"); 1612 } 1613 1614 void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size, bool active) 1615 { 1616 snprintf(buffer, size, " %6s %6u %3u %08X %7u %1d %08X %6zu %5u\n", 1617 active ? "yes" : "no", 1618 (mClient == 0) ? getpid_cached : mClient->pid(), 1619 mFormat, 1620 mChannelMask, 1621 mSessionId, 1622 mState, 1623 mCblk->mServer, 1624 mFrameCount, 1625 mSampleRate); 1626 1627 } 1628 1629 void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event) 1630 { 1631 if (event == mSyncStartEvent) { 1632 ssize_t framesToDrop = 0; 1633 sp<ThreadBase> threadBase = mThread.promote(); 1634 if (threadBase != 0) { 1635 // TODO: use actual buffer filling status instead of 2 buffers when info is available 1636 // from audio HAL 1637 framesToDrop = threadBase->mFrameCount * 2; 1638 } 1639 mFramesToDrop = framesToDrop; 1640 } 1641 } 1642 1643 void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent() 1644 { 1645 if (mSyncStartEvent != 0) { 1646 mSyncStartEvent->cancel(); 1647 mSyncStartEvent.clear(); 1648 } 1649 mFramesToDrop = 0; 1650 } 1651 1652 void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo( 1653 int64_t trackFramesReleased, int64_t sourceFramesRead, 1654 uint32_t halSampleRate, const ExtendedTimestamp ×tamp) 1655 { 1656 ExtendedTimestamp local = timestamp; 1657 1658 // Convert HAL frames to server-side track frames at track sample rate. 1659 // We use trackFramesReleased and sourceFramesRead as an anchor point. 1660 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) { 1661 if (local.mTimeNs[i] != 0) { 1662 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead; 1663 const int64_t relativeTrackFrames = relativeServerFrames 1664 * mSampleRate / halSampleRate; // TODO: potential computation overflow 1665 local.mPosition[i] = relativeTrackFrames + trackFramesReleased; 1666 } 1667 } 1668 mServerProxy->setTimestamp(local); 1669 } 1670 1671 AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread, 1672 uint32_t sampleRate, 1673 audio_channel_mask_t channelMask, 1674 audio_format_t format, 1675 size_t frameCount, 1676 void *buffer, 1677 audio_input_flags_t flags) 1678 : RecordTrack(recordThread, NULL, sampleRate, format, channelMask, frameCount, 1679 buffer, AUDIO_SESSION_NONE, getuid(), flags, TYPE_PATCH), 1680 mProxy(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true)) 1681 { 1682 uint64_t mixBufferNs = ((uint64_t)2 * recordThread->frameCount() * 1000000000) / 1683 recordThread->sampleRate(); 1684 mPeerTimeout.tv_sec = mixBufferNs / 1000000000; 1685 mPeerTimeout.tv_nsec = (int) (mixBufferNs % 1000000000); 1686 1687 ALOGV("PatchRecord %p sampleRate %d mPeerTimeout %d.%03d sec", 1688 this, sampleRate, 1689 (int)mPeerTimeout.tv_sec, 1690 (int)(mPeerTimeout.tv_nsec / 1000000)); 1691 } 1692 1693 AudioFlinger::RecordThread::PatchRecord::~PatchRecord() 1694 { 1695 } 1696 1697 // AudioBufferProvider interface 1698 status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer( 1699 AudioBufferProvider::Buffer* buffer) 1700 { 1701 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::getNextBuffer() called without peer proxy"); 1702 Proxy::Buffer buf; 1703 buf.mFrameCount = buffer->frameCount; 1704 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout); 1705 ALOGV_IF(status != NO_ERROR, 1706 "PatchRecord() %p mPeerProxy->obtainBuffer status %d", this, status); 1707 buffer->frameCount = buf.mFrameCount; 1708 if (buf.mFrameCount == 0) { 1709 return WOULD_BLOCK; 1710 } 1711 status = RecordTrack::getNextBuffer(buffer); 1712 return status; 1713 } 1714 1715 void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer) 1716 { 1717 ALOG_ASSERT(mPeerProxy != 0, "PatchRecord::releaseBuffer() called without peer proxy"); 1718 Proxy::Buffer buf; 1719 buf.mFrameCount = buffer->frameCount; 1720 buf.mRaw = buffer->raw; 1721 mPeerProxy->releaseBuffer(&buf); 1722 TrackBase::releaseBuffer(buffer); 1723 } 1724 1725 status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer, 1726 const struct timespec *timeOut) 1727 { 1728 return mProxy->obtainBuffer(buffer, timeOut); 1729 } 1730 1731 void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer) 1732 { 1733 mProxy->releaseBuffer(buffer); 1734 } 1735 1736 } // namespace android 1737