Tracks.cpp revision 30ff92cba19c5acd747631365db1e1084e45ab34
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 <math.h> 24#include <utils/Log.h> 25 26#include <private/media/AudioTrackShared.h> 27 28#include <common_time/cc_helper.h> 29#include <common_time/local_clock.h> 30 31#include "AudioMixer.h" 32#include "AudioFlinger.h" 33#include "ServiceUtilities.h" 34 35#include <media/nbaio/Pipe.h> 36#include <media/nbaio/PipeReader.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 53namespace android { 54 55// ---------------------------------------------------------------------------- 56// TrackBase 57// ---------------------------------------------------------------------------- 58 59static volatile int32_t nextTrackId = 55; 60 61// TrackBase constructor must be called with AudioFlinger::mLock held 62AudioFlinger::ThreadBase::TrackBase::TrackBase( 63 ThreadBase *thread, 64 const sp<Client>& client, 65 uint32_t sampleRate, 66 audio_format_t format, 67 audio_channel_mask_t channelMask, 68 size_t frameCount, 69 const sp<IMemory>& sharedBuffer, 70 int sessionId, 71 int clientUid, 72 bool isOut) 73 : RefBase(), 74 mThread(thread), 75 mClient(client), 76 mCblk(NULL), 77 // mBuffer 78 mState(IDLE), 79 mSampleRate(sampleRate), 80 mFormat(format), 81 mChannelMask(channelMask), 82 mChannelCount(popcount(channelMask)), 83 mFrameSize(audio_is_linear_pcm(format) ? 84 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)), 85 mFrameCount(frameCount), 86 mSessionId(sessionId), 87 mIsOut(isOut), 88 mServerProxy(NULL), 89 mId(android_atomic_inc(&nextTrackId)), 90 mTerminated(false) 91{ 92 // if the caller is us, trust the specified uid 93 if (IPCThreadState::self()->getCallingPid() != getpid_cached || clientUid == -1) { 94 int newclientUid = IPCThreadState::self()->getCallingUid(); 95 if (clientUid != -1 && clientUid != newclientUid) { 96 ALOGW("uid %d tried to pass itself off as %d", newclientUid, clientUid); 97 } 98 clientUid = newclientUid; 99 } 100 // clientUid contains the uid of the app that is responsible for this track, so we can blame 101 // battery usage on it. 102 mUid = clientUid; 103 104 // client == 0 implies sharedBuffer == 0 105 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0)); 106 107 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), 108 sharedBuffer->size()); 109 110 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize); 111 size_t size = sizeof(audio_track_cblk_t); 112 size_t bufferSize = (sharedBuffer == 0 ? roundup(frameCount) : frameCount) * mFrameSize; 113 if (sharedBuffer == 0) { 114 size += bufferSize; 115 } 116 117 if (client != 0) { 118 mCblkMemory = client->heap()->allocate(size); 119 if (mCblkMemory != 0) { 120 mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); 121 // can't assume mCblk != NULL 122 } else { 123 ALOGE("not enough memory for AudioTrack size=%u", size); 124 client->heap()->dump("AudioTrack"); 125 return; 126 } 127 } else { 128 // this syntax avoids calling the audio_track_cblk_t constructor twice 129 mCblk = (audio_track_cblk_t *) new uint8_t[size]; 130 // assume mCblk != NULL 131 } 132 133 // construct the shared structure in-place. 134 if (mCblk != NULL) { 135 new(mCblk) audio_track_cblk_t(); 136 // clear all buffers 137 mCblk->frameCount_ = frameCount; 138 if (sharedBuffer == 0) { 139 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 140 memset(mBuffer, 0, bufferSize); 141 } else { 142 mBuffer = sharedBuffer->pointer(); 143#if 0 144 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic 145#endif 146 } 147 148#ifdef TEE_SINK 149 if (mTeeSinkTrackEnabled) { 150 NBAIO_Format pipeFormat = Format_from_SR_C(mSampleRate, mChannelCount); 151 if (pipeFormat != Format_Invalid) { 152 Pipe *pipe = new Pipe(mTeeSinkTrackFrames, pipeFormat); 153 size_t numCounterOffers = 0; 154 const NBAIO_Format offers[1] = {pipeFormat}; 155 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers); 156 ALOG_ASSERT(index == 0); 157 PipeReader *pipeReader = new PipeReader(*pipe); 158 numCounterOffers = 0; 159 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers); 160 ALOG_ASSERT(index == 0); 161 mTeeSink = pipe; 162 mTeeSource = pipeReader; 163 } 164 } 165#endif 166 167 } 168} 169 170AudioFlinger::ThreadBase::TrackBase::~TrackBase() 171{ 172#ifdef TEE_SINK 173 dumpTee(-1, mTeeSource, mId); 174#endif 175 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference 176 delete mServerProxy; 177 if (mCblk != NULL) { 178 if (mClient == 0) { 179 delete mCblk; 180 } else { 181 mCblk->~audio_track_cblk_t(); // destroy our shared-structure. 182 } 183 } 184 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to 185 if (mClient != 0) { 186 // Client destructor must run with AudioFlinger mutex locked 187 Mutex::Autolock _l(mClient->audioFlinger()->mLock); 188 // If the client's reference count drops to zero, the associated destructor 189 // must run with AudioFlinger lock held. Thus the explicit clear() rather than 190 // relying on the automatic clear() at end of scope. 191 mClient.clear(); 192 } 193} 194 195// AudioBufferProvider interface 196// getNextBuffer() = 0; 197// This implementation of releaseBuffer() is used by Track and RecordTrack, but not TimedTrack 198void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer) 199{ 200#ifdef TEE_SINK 201 if (mTeeSink != 0) { 202 (void) mTeeSink->write(buffer->raw, buffer->frameCount); 203 } 204#endif 205 206 ServerProxy::Buffer buf; 207 buf.mFrameCount = buffer->frameCount; 208 buf.mRaw = buffer->raw; 209 buffer->frameCount = 0; 210 buffer->raw = NULL; 211 mServerProxy->releaseBuffer(&buf); 212} 213 214status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event) 215{ 216 mSyncEvents.add(event); 217 return NO_ERROR; 218} 219 220// ---------------------------------------------------------------------------- 221// Playback 222// ---------------------------------------------------------------------------- 223 224AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track) 225 : BnAudioTrack(), 226 mTrack(track) 227{ 228} 229 230AudioFlinger::TrackHandle::~TrackHandle() { 231 // just stop the track on deletion, associated resources 232 // will be freed from the main thread once all pending buffers have 233 // been played. Unless it's not in the active track list, in which 234 // case we free everything now... 235 mTrack->destroy(); 236} 237 238sp<IMemory> AudioFlinger::TrackHandle::getCblk() const { 239 return mTrack->getCblk(); 240} 241 242status_t AudioFlinger::TrackHandle::start() { 243 return mTrack->start(); 244} 245 246void AudioFlinger::TrackHandle::stop() { 247 mTrack->stop(); 248} 249 250void AudioFlinger::TrackHandle::flush() { 251 mTrack->flush(); 252} 253 254void AudioFlinger::TrackHandle::pause() { 255 mTrack->pause(); 256} 257 258status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId) 259{ 260 return mTrack->attachAuxEffect(EffectId); 261} 262 263status_t AudioFlinger::TrackHandle::allocateTimedBuffer(size_t size, 264 sp<IMemory>* buffer) { 265 if (!mTrack->isTimedTrack()) 266 return INVALID_OPERATION; 267 268 PlaybackThread::TimedTrack* tt = 269 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 270 return tt->allocateTimedBuffer(size, buffer); 271} 272 273status_t AudioFlinger::TrackHandle::queueTimedBuffer(const sp<IMemory>& buffer, 274 int64_t pts) { 275 if (!mTrack->isTimedTrack()) 276 return INVALID_OPERATION; 277 278 PlaybackThread::TimedTrack* tt = 279 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 280 return tt->queueTimedBuffer(buffer, pts); 281} 282 283status_t AudioFlinger::TrackHandle::setMediaTimeTransform( 284 const LinearTransform& xform, int target) { 285 286 if (!mTrack->isTimedTrack()) 287 return INVALID_OPERATION; 288 289 PlaybackThread::TimedTrack* tt = 290 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 291 return tt->setMediaTimeTransform( 292 xform, static_cast<TimedAudioTrack::TargetTimeline>(target)); 293} 294 295status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) { 296 return mTrack->setParameters(keyValuePairs); 297} 298 299status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp) 300{ 301 return mTrack->getTimestamp(timestamp); 302} 303 304 305void AudioFlinger::TrackHandle::signal() 306{ 307 return mTrack->signal(); 308} 309 310status_t AudioFlinger::TrackHandle::onTransact( 311 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 312{ 313 return BnAudioTrack::onTransact(code, data, reply, flags); 314} 315 316// ---------------------------------------------------------------------------- 317 318// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 319AudioFlinger::PlaybackThread::Track::Track( 320 PlaybackThread *thread, 321 const sp<Client>& client, 322 audio_stream_type_t streamType, 323 uint32_t sampleRate, 324 audio_format_t format, 325 audio_channel_mask_t channelMask, 326 size_t frameCount, 327 const sp<IMemory>& sharedBuffer, 328 int sessionId, 329 int uid, 330 IAudioFlinger::track_flags_t flags) 331 : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, sharedBuffer, 332 sessionId, uid, true /*isOut*/), 333 mFillingUpStatus(FS_INVALID), 334 // mRetryCount initialized later when needed 335 mSharedBuffer(sharedBuffer), 336 mStreamType(streamType), 337 mName(-1), // see note below 338 mMainBuffer(thread->mixBuffer()), 339 mAuxBuffer(NULL), 340 mAuxEffectId(0), mHasVolumeController(false), 341 mPresentationCompleteFrames(0), 342 mFlags(flags), 343 mFastIndex(-1), 344 mCachedVolume(1.0), 345 mIsInvalid(false), 346 mAudioTrackServerProxy(NULL), 347 mResumeToStopping(false) 348{ 349 if (mCblk != NULL) { 350 if (sharedBuffer == 0) { 351 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount, 352 mFrameSize); 353 } else { 354 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount, 355 mFrameSize); 356 } 357 mServerProxy = mAudioTrackServerProxy; 358 // to avoid leaking a track name, do not allocate one unless there is an mCblk 359 mName = thread->getTrackName_l(channelMask, sessionId); 360 if (mName < 0) { 361 ALOGE("no more track names available"); 362 return; 363 } 364 // only allocate a fast track index if we were able to allocate a normal track name 365 if (flags & IAudioFlinger::TRACK_FAST) { 366 mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads(); 367 ALOG_ASSERT(thread->mFastTrackAvailMask != 0); 368 int i = __builtin_ctz(thread->mFastTrackAvailMask); 369 ALOG_ASSERT(0 < i && i < (int)FastMixerState::kMaxFastTracks); 370 // FIXME This is too eager. We allocate a fast track index before the 371 // fast track becomes active. Since fast tracks are a scarce resource, 372 // this means we are potentially denying other more important fast tracks from 373 // being created. It would be better to allocate the index dynamically. 374 mFastIndex = i; 375 // Read the initial underruns because this field is never cleared by the fast mixer 376 mObservedUnderruns = thread->getFastTrackUnderruns(i); 377 thread->mFastTrackAvailMask &= ~(1 << i); 378 } 379 } 380 ALOGV("Track constructor name %d, calling pid %d", mName, 381 IPCThreadState::self()->getCallingPid()); 382} 383 384AudioFlinger::PlaybackThread::Track::~Track() 385{ 386 ALOGV("PlaybackThread::Track destructor"); 387 388 // The destructor would clear mSharedBuffer, 389 // but it will not push the decremented reference count, 390 // leaving the client's IMemory dangling indefinitely. 391 // This prevents that leak. 392 if (mSharedBuffer != 0) { 393 mSharedBuffer.clear(); 394 // flush the binder command buffer 395 IPCThreadState::self()->flushCommands(); 396 } 397} 398 399status_t AudioFlinger::PlaybackThread::Track::initCheck() const 400{ 401 status_t status = TrackBase::initCheck(); 402 if (status == NO_ERROR && mName < 0) { 403 status = NO_MEMORY; 404 } 405 return status; 406} 407 408void AudioFlinger::PlaybackThread::Track::destroy() 409{ 410 // NOTE: destroyTrack_l() can remove a strong reference to this Track 411 // by removing it from mTracks vector, so there is a risk that this Tracks's 412 // destructor is called. As the destructor needs to lock mLock, 413 // we must acquire a strong reference on this Track before locking mLock 414 // here so that the destructor is called only when exiting this function. 415 // On the other hand, as long as Track::destroy() is only called by 416 // TrackHandle destructor, the TrackHandle still holds a strong ref on 417 // this Track with its member mTrack. 418 sp<Track> keep(this); 419 { // scope for mLock 420 sp<ThreadBase> thread = mThread.promote(); 421 if (thread != 0) { 422 Mutex::Autolock _l(thread->mLock); 423 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 424 bool wasActive = playbackThread->destroyTrack_l(this); 425 if (!isOutputTrack() && !wasActive) { 426 AudioSystem::releaseOutput(thread->id()); 427 } 428 } 429 } 430} 431 432/*static*/ void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result) 433{ 434 result.append(" Name Client Type Fmt Chn mask Session fCount S F SRate " 435 "L dB R dB Server Main buf Aux Buf Flags UndFrmCnt\n"); 436} 437 438void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size) 439{ 440 uint32_t vlr = mAudioTrackServerProxy->getVolumeLR(); 441 if (isFastTrack()) { 442 sprintf(buffer, " F %2d", mFastIndex); 443 } else { 444 sprintf(buffer, " %4d", mName - AudioMixer::TRACK0); 445 } 446 track_state state = mState; 447 char stateChar; 448 if (isTerminated()) { 449 stateChar = 'T'; 450 } else { 451 switch (state) { 452 case IDLE: 453 stateChar = 'I'; 454 break; 455 case STOPPING_1: 456 stateChar = 's'; 457 break; 458 case STOPPING_2: 459 stateChar = '5'; 460 break; 461 case STOPPED: 462 stateChar = 'S'; 463 break; 464 case RESUMING: 465 stateChar = 'R'; 466 break; 467 case ACTIVE: 468 stateChar = 'A'; 469 break; 470 case PAUSING: 471 stateChar = 'p'; 472 break; 473 case PAUSED: 474 stateChar = 'P'; 475 break; 476 case FLUSHED: 477 stateChar = 'F'; 478 break; 479 default: 480 stateChar = '?'; 481 break; 482 } 483 } 484 char nowInUnderrun; 485 switch (mObservedUnderruns.mBitFields.mMostRecent) { 486 case UNDERRUN_FULL: 487 nowInUnderrun = ' '; 488 break; 489 case UNDERRUN_PARTIAL: 490 nowInUnderrun = '<'; 491 break; 492 case UNDERRUN_EMPTY: 493 nowInUnderrun = '*'; 494 break; 495 default: 496 nowInUnderrun = '?'; 497 break; 498 } 499 snprintf(&buffer[7], size-7, " %6u %4u %08X %08X %7u %6u %1c %1d %5u %5.2g %5.2g " 500 "%08X %08X %08X 0x%03X %9u%c\n", 501 (mClient == 0) ? getpid_cached : mClient->pid(), 502 mStreamType, 503 mFormat, 504 mChannelMask, 505 mSessionId, 506 mFrameCount, 507 stateChar, 508 mFillingUpStatus, 509 mAudioTrackServerProxy->getSampleRate(), 510 20.0 * log10((vlr & 0xFFFF) / 4096.0), 511 20.0 * log10((vlr >> 16) / 4096.0), 512 mCblk->mServer, 513 (int)mMainBuffer, 514 (int)mAuxBuffer, 515 mCblk->mFlags, 516 mAudioTrackServerProxy->getUnderrunFrames(), 517 nowInUnderrun); 518} 519 520uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const { 521 return mAudioTrackServerProxy->getSampleRate(); 522} 523 524// AudioBufferProvider interface 525status_t AudioFlinger::PlaybackThread::Track::getNextBuffer( 526 AudioBufferProvider::Buffer* buffer, int64_t pts) 527{ 528 ServerProxy::Buffer buf; 529 size_t desiredFrames = buffer->frameCount; 530 buf.mFrameCount = desiredFrames; 531 status_t status = mServerProxy->obtainBuffer(&buf); 532 buffer->frameCount = buf.mFrameCount; 533 buffer->raw = buf.mRaw; 534 if (buf.mFrameCount == 0) { 535 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames); 536 } 537 return status; 538} 539 540// releaseBuffer() is not overridden 541 542// ExtendedAudioBufferProvider interface 543 544// Note that framesReady() takes a mutex on the control block using tryLock(). 545// This could result in priority inversion if framesReady() is called by the normal mixer, 546// as the normal mixer thread runs at lower 547// priority than the client's callback thread: there is a short window within framesReady() 548// during which the normal mixer could be preempted, and the client callback would block. 549// Another problem can occur if framesReady() is called by the fast mixer: 550// the tryLock() could block for up to 1 ms, and a sequence of these could delay fast mixer. 551// FIXME Replace AudioTrackShared control block implementation by a non-blocking FIFO queue. 552size_t AudioFlinger::PlaybackThread::Track::framesReady() const { 553 return mAudioTrackServerProxy->framesReady(); 554} 555 556size_t AudioFlinger::PlaybackThread::Track::framesReleased() const 557{ 558 return mAudioTrackServerProxy->framesReleased(); 559} 560 561// Don't call for fast tracks; the framesReady() could result in priority inversion 562bool AudioFlinger::PlaybackThread::Track::isReady() const { 563 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) { 564 return true; 565 } 566 567 if (framesReady() >= mFrameCount || 568 (mCblk->mFlags & CBLK_FORCEREADY)) { 569 mFillingUpStatus = FS_FILLED; 570 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 571 return true; 572 } 573 return false; 574} 575 576status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event, 577 int triggerSession) 578{ 579 status_t status = NO_ERROR; 580 ALOGV("start(%d), calling pid %d session %d", 581 mName, IPCThreadState::self()->getCallingPid(), mSessionId); 582 583 sp<ThreadBase> thread = mThread.promote(); 584 if (thread != 0) { 585 if (isOffloaded()) { 586 Mutex::Autolock _laf(thread->mAudioFlinger->mLock); 587 Mutex::Autolock _lth(thread->mLock); 588 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId); 589 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() || 590 (ec != 0 && ec->isNonOffloadableEnabled())) { 591 invalidate(); 592 return PERMISSION_DENIED; 593 } 594 } 595 Mutex::Autolock _lth(thread->mLock); 596 track_state state = mState; 597 // here the track could be either new, or restarted 598 // in both cases "unstop" the track 599 600 if (state == PAUSED) { 601 if (mResumeToStopping) { 602 // happened we need to resume to STOPPING_1 603 mState = TrackBase::STOPPING_1; 604 ALOGV("PAUSED => STOPPING_1 (%d) on thread %p", mName, this); 605 } else { 606 mState = TrackBase::RESUMING; 607 ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this); 608 } 609 } else { 610 mState = TrackBase::ACTIVE; 611 ALOGV("? => ACTIVE (%d) on thread %p", mName, this); 612 } 613 614 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 615 status = playbackThread->addTrack_l(this); 616 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) { 617 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 618 // restore previous state if start was rejected by policy manager 619 if (status == PERMISSION_DENIED) { 620 mState = state; 621 } 622 } 623 // track was already in the active list, not a problem 624 if (status == ALREADY_EXISTS) { 625 status = NO_ERROR; 626 } else { 627 // Acknowledge any pending flush(), so that subsequent new data isn't discarded. 628 // It is usually unsafe to access the server proxy from a binder thread. 629 // But in this case we know the mixer thread (whether normal mixer or fast mixer) 630 // isn't looking at this track yet: we still hold the normal mixer thread lock, 631 // and for fast tracks the track is not yet in the fast mixer thread's active set. 632 ServerProxy::Buffer buffer; 633 buffer.mFrameCount = 1; 634 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/); 635 } 636 } else { 637 status = BAD_VALUE; 638 } 639 return status; 640} 641 642void AudioFlinger::PlaybackThread::Track::stop() 643{ 644 ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 645 sp<ThreadBase> thread = mThread.promote(); 646 if (thread != 0) { 647 Mutex::Autolock _l(thread->mLock); 648 track_state state = mState; 649 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) { 650 // If the track is not active (PAUSED and buffers full), flush buffers 651 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 652 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 653 reset(); 654 mState = STOPPED; 655 } else if (!isFastTrack() && !isOffloaded()) { 656 mState = STOPPED; 657 } else { 658 // For fast tracks prepareTracks_l() will set state to STOPPING_2 659 // presentation is complete 660 // For an offloaded track this starts a drain and state will 661 // move to STOPPING_2 when drain completes and then STOPPED 662 mState = STOPPING_1; 663 } 664 ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName, 665 playbackThread); 666 } 667 } 668} 669 670void AudioFlinger::PlaybackThread::Track::pause() 671{ 672 ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 673 sp<ThreadBase> thread = mThread.promote(); 674 if (thread != 0) { 675 Mutex::Autolock _l(thread->mLock); 676 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 677 switch (mState) { 678 case STOPPING_1: 679 case STOPPING_2: 680 if (!isOffloaded()) { 681 /* nothing to do if track is not offloaded */ 682 break; 683 } 684 685 // Offloaded track was draining, we need to carry on draining when resumed 686 mResumeToStopping = true; 687 // fall through... 688 case ACTIVE: 689 case RESUMING: 690 mState = PAUSING; 691 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get()); 692 playbackThread->broadcast_l(); 693 break; 694 695 default: 696 break; 697 } 698 } 699} 700 701void AudioFlinger::PlaybackThread::Track::flush() 702{ 703 ALOGV("flush(%d)", mName); 704 sp<ThreadBase> thread = mThread.promote(); 705 if (thread != 0) { 706 Mutex::Autolock _l(thread->mLock); 707 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 708 709 if (isOffloaded()) { 710 // If offloaded we allow flush during any state except terminated 711 // and keep the track active to avoid problems if user is seeking 712 // rapidly and underlying hardware has a significant delay handling 713 // a pause 714 if (isTerminated()) { 715 return; 716 } 717 718 ALOGV("flush: offload flush"); 719 reset(); 720 721 if (mState == STOPPING_1 || mState == STOPPING_2) { 722 ALOGV("flushed in STOPPING_1 or 2 state, change state to ACTIVE"); 723 mState = ACTIVE; 724 } 725 726 if (mState == ACTIVE) { 727 ALOGV("flush called in active state, resetting buffer time out retry count"); 728 mRetryCount = PlaybackThread::kMaxTrackRetriesOffload; 729 } 730 731 mResumeToStopping = false; 732 } else { 733 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED && 734 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) { 735 return; 736 } 737 // No point remaining in PAUSED state after a flush => go to 738 // FLUSHED state 739 mState = FLUSHED; 740 // do not reset the track if it is still in the process of being stopped or paused. 741 // this will be done by prepareTracks_l() when the track is stopped. 742 // prepareTracks_l() will see mState == FLUSHED, then 743 // remove from active track list, reset(), and trigger presentation complete 744 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 745 reset(); 746 } 747 } 748 // Prevent flush being lost if the track is flushed and then resumed 749 // before mixer thread can run. This is important when offloading 750 // because the hardware buffer could hold a large amount of audio 751 playbackThread->flushOutput_l(); 752 playbackThread->broadcast_l(); 753 } 754} 755 756void AudioFlinger::PlaybackThread::Track::reset() 757{ 758 // Do not reset twice to avoid discarding data written just after a flush and before 759 // the audioflinger thread detects the track is stopped. 760 if (!mResetDone) { 761 // Force underrun condition to avoid false underrun callback until first data is 762 // written to buffer 763 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 764 mFillingUpStatus = FS_FILLING; 765 mResetDone = true; 766 if (mState == FLUSHED) { 767 mState = IDLE; 768 } 769 } 770} 771 772status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs) 773{ 774 sp<ThreadBase> thread = mThread.promote(); 775 if (thread == 0) { 776 ALOGE("thread is dead"); 777 return FAILED_TRANSACTION; 778 } else if ((thread->type() == ThreadBase::DIRECT) || 779 (thread->type() == ThreadBase::OFFLOAD)) { 780 return thread->setParameters(keyValuePairs); 781 } else { 782 return PERMISSION_DENIED; 783 } 784} 785 786status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp) 787{ 788 // Client should implement this using SSQ; the unpresented frame count in latch is irrelevant 789 if (isFastTrack()) { 790 return INVALID_OPERATION; 791 } 792 sp<ThreadBase> thread = mThread.promote(); 793 if (thread == 0) { 794 return INVALID_OPERATION; 795 } 796 Mutex::Autolock _l(thread->mLock); 797 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 798 if (!isOffloaded()) { 799 if (!playbackThread->mLatchQValid) { 800 return INVALID_OPERATION; 801 } 802 uint32_t unpresentedFrames = 803 ((int64_t) playbackThread->mLatchQ.mUnpresentedFrames * mSampleRate) / 804 playbackThread->mSampleRate; 805 uint32_t framesWritten = mAudioTrackServerProxy->framesReleased(); 806 if (framesWritten < unpresentedFrames) { 807 return INVALID_OPERATION; 808 } 809 timestamp.mPosition = framesWritten - unpresentedFrames; 810 timestamp.mTime = playbackThread->mLatchQ.mTimestamp.mTime; 811 return NO_ERROR; 812 } 813 814 return playbackThread->getTimestamp_l(timestamp); 815} 816 817status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId) 818{ 819 status_t status = DEAD_OBJECT; 820 sp<ThreadBase> thread = mThread.promote(); 821 if (thread != 0) { 822 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 823 sp<AudioFlinger> af = mClient->audioFlinger(); 824 825 Mutex::Autolock _l(af->mLock); 826 827 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId); 828 829 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) { 830 Mutex::Autolock _dl(playbackThread->mLock); 831 Mutex::Autolock _sl(srcThread->mLock); 832 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); 833 if (chain == 0) { 834 return INVALID_OPERATION; 835 } 836 837 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId); 838 if (effect == 0) { 839 return INVALID_OPERATION; 840 } 841 srcThread->removeEffect_l(effect); 842 status = playbackThread->addEffect_l(effect); 843 if (status != NO_ERROR) { 844 srcThread->addEffect_l(effect); 845 return INVALID_OPERATION; 846 } 847 // removeEffect_l() has stopped the effect if it was active so it must be restarted 848 if (effect->state() == EffectModule::ACTIVE || 849 effect->state() == EffectModule::STOPPING) { 850 effect->start(); 851 } 852 853 sp<EffectChain> dstChain = effect->chain().promote(); 854 if (dstChain == 0) { 855 srcThread->addEffect_l(effect); 856 return INVALID_OPERATION; 857 } 858 AudioSystem::unregisterEffect(effect->id()); 859 AudioSystem::registerEffect(&effect->desc(), 860 srcThread->id(), 861 dstChain->strategy(), 862 AUDIO_SESSION_OUTPUT_MIX, 863 effect->id()); 864 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled()); 865 } 866 status = playbackThread->attachAuxEffect(this, EffectId); 867 } 868 return status; 869} 870 871void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer) 872{ 873 mAuxEffectId = EffectId; 874 mAuxBuffer = buffer; 875} 876 877bool AudioFlinger::PlaybackThread::Track::presentationComplete(size_t framesWritten, 878 size_t audioHalFrames) 879{ 880 // a track is considered presented when the total number of frames written to audio HAL 881 // corresponds to the number of frames written when presentationComplete() is called for the 882 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time. 883 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used 884 // to detect when all frames have been played. In this case framesWritten isn't 885 // useful because it doesn't always reflect whether there is data in the h/w 886 // buffers, particularly if a track has been paused and resumed during draining 887 ALOGV("presentationComplete() mPresentationCompleteFrames %d framesWritten %d", 888 mPresentationCompleteFrames, framesWritten); 889 if (mPresentationCompleteFrames == 0) { 890 mPresentationCompleteFrames = framesWritten + audioHalFrames; 891 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %d audioHalFrames %d", 892 mPresentationCompleteFrames, audioHalFrames); 893 } 894 895 if (framesWritten >= mPresentationCompleteFrames || isOffloaded()) { 896 ALOGV("presentationComplete() session %d complete: framesWritten %d", 897 mSessionId, framesWritten); 898 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 899 mAudioTrackServerProxy->setStreamEndDone(); 900 return true; 901 } 902 return false; 903} 904 905void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type) 906{ 907 for (int i = 0; i < (int)mSyncEvents.size(); i++) { 908 if (mSyncEvents[i]->type() == type) { 909 mSyncEvents[i]->trigger(); 910 mSyncEvents.removeAt(i); 911 i--; 912 } 913 } 914} 915 916// implement VolumeBufferProvider interface 917 918uint32_t AudioFlinger::PlaybackThread::Track::getVolumeLR() 919{ 920 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs 921 ALOG_ASSERT(isFastTrack() && (mCblk != NULL)); 922 uint32_t vlr = mAudioTrackServerProxy->getVolumeLR(); 923 uint32_t vl = vlr & 0xFFFF; 924 uint32_t vr = vlr >> 16; 925 // track volumes come from shared memory, so can't be trusted and must be clamped 926 if (vl > MAX_GAIN_INT) { 927 vl = MAX_GAIN_INT; 928 } 929 if (vr > MAX_GAIN_INT) { 930 vr = MAX_GAIN_INT; 931 } 932 // now apply the cached master volume and stream type volume; 933 // this is trusted but lacks any synchronization or barrier so may be stale 934 float v = mCachedVolume; 935 vl *= v; 936 vr *= v; 937 // re-combine into U4.16 938 vlr = (vr << 16) | (vl & 0xFFFF); 939 // FIXME look at mute, pause, and stop flags 940 return vlr; 941} 942 943status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event) 944{ 945 if (isTerminated() || mState == PAUSED || 946 ((framesReady() == 0) && ((mSharedBuffer != 0) || 947 (mState == STOPPED)))) { 948 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %d ", 949 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady()); 950 event->cancel(); 951 return INVALID_OPERATION; 952 } 953 (void) TrackBase::setSyncEvent(event); 954 return NO_ERROR; 955} 956 957void AudioFlinger::PlaybackThread::Track::invalidate() 958{ 959 // FIXME should use proxy, and needs work 960 audio_track_cblk_t* cblk = mCblk; 961 android_atomic_or(CBLK_INVALID, &cblk->mFlags); 962 android_atomic_release_store(0x40000000, &cblk->mFutex); 963 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 964 (void) __futex_syscall3(&cblk->mFutex, FUTEX_WAKE, INT_MAX); 965 mIsInvalid = true; 966} 967 968void AudioFlinger::PlaybackThread::Track::signal() 969{ 970 sp<ThreadBase> thread = mThread.promote(); 971 if (thread != 0) { 972 PlaybackThread *t = (PlaybackThread *)thread.get(); 973 Mutex::Autolock _l(t->mLock); 974 t->broadcast_l(); 975 } 976} 977 978// ---------------------------------------------------------------------------- 979 980sp<AudioFlinger::PlaybackThread::TimedTrack> 981AudioFlinger::PlaybackThread::TimedTrack::create( 982 PlaybackThread *thread, 983 const sp<Client>& client, 984 audio_stream_type_t streamType, 985 uint32_t sampleRate, 986 audio_format_t format, 987 audio_channel_mask_t channelMask, 988 size_t frameCount, 989 const sp<IMemory>& sharedBuffer, 990 int sessionId, 991 int uid) { 992 if (!client->reserveTimedTrack()) 993 return 0; 994 995 return new TimedTrack( 996 thread, client, streamType, sampleRate, format, channelMask, frameCount, 997 sharedBuffer, sessionId, uid); 998} 999 1000AudioFlinger::PlaybackThread::TimedTrack::TimedTrack( 1001 PlaybackThread *thread, 1002 const sp<Client>& client, 1003 audio_stream_type_t streamType, 1004 uint32_t sampleRate, 1005 audio_format_t format, 1006 audio_channel_mask_t channelMask, 1007 size_t frameCount, 1008 const sp<IMemory>& sharedBuffer, 1009 int sessionId, 1010 int uid) 1011 : Track(thread, client, streamType, sampleRate, format, channelMask, 1012 frameCount, sharedBuffer, sessionId, uid, IAudioFlinger::TRACK_TIMED), 1013 mQueueHeadInFlight(false), 1014 mTrimQueueHeadOnRelease(false), 1015 mFramesPendingInQueue(0), 1016 mTimedSilenceBuffer(NULL), 1017 mTimedSilenceBufferSize(0), 1018 mTimedAudioOutputOnTime(false), 1019 mMediaTimeTransformValid(false) 1020{ 1021 LocalClock lc; 1022 mLocalTimeFreq = lc.getLocalFreq(); 1023 1024 mLocalTimeToSampleTransform.a_zero = 0; 1025 mLocalTimeToSampleTransform.b_zero = 0; 1026 mLocalTimeToSampleTransform.a_to_b_numer = sampleRate; 1027 mLocalTimeToSampleTransform.a_to_b_denom = mLocalTimeFreq; 1028 LinearTransform::reduce(&mLocalTimeToSampleTransform.a_to_b_numer, 1029 &mLocalTimeToSampleTransform.a_to_b_denom); 1030 1031 mMediaTimeToSampleTransform.a_zero = 0; 1032 mMediaTimeToSampleTransform.b_zero = 0; 1033 mMediaTimeToSampleTransform.a_to_b_numer = sampleRate; 1034 mMediaTimeToSampleTransform.a_to_b_denom = 1000000; 1035 LinearTransform::reduce(&mMediaTimeToSampleTransform.a_to_b_numer, 1036 &mMediaTimeToSampleTransform.a_to_b_denom); 1037} 1038 1039AudioFlinger::PlaybackThread::TimedTrack::~TimedTrack() { 1040 mClient->releaseTimedTrack(); 1041 delete [] mTimedSilenceBuffer; 1042} 1043 1044status_t AudioFlinger::PlaybackThread::TimedTrack::allocateTimedBuffer( 1045 size_t size, sp<IMemory>* buffer) { 1046 1047 Mutex::Autolock _l(mTimedBufferQueueLock); 1048 1049 trimTimedBufferQueue_l(); 1050 1051 // lazily initialize the shared memory heap for timed buffers 1052 if (mTimedMemoryDealer == NULL) { 1053 const int kTimedBufferHeapSize = 512 << 10; 1054 1055 mTimedMemoryDealer = new MemoryDealer(kTimedBufferHeapSize, 1056 "AudioFlingerTimed"); 1057 if (mTimedMemoryDealer == NULL) { 1058 return NO_MEMORY; 1059 } 1060 } 1061 1062 sp<IMemory> newBuffer = mTimedMemoryDealer->allocate(size); 1063 if (newBuffer == 0) { 1064 return NO_MEMORY; 1065 } 1066 1067 *buffer = newBuffer; 1068 return NO_ERROR; 1069} 1070 1071// caller must hold mTimedBufferQueueLock 1072void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueue_l() { 1073 int64_t mediaTimeNow; 1074 { 1075 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1076 if (!mMediaTimeTransformValid) 1077 return; 1078 1079 int64_t targetTimeNow; 1080 status_t res = (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) 1081 ? mCCHelper.getCommonTime(&targetTimeNow) 1082 : mCCHelper.getLocalTime(&targetTimeNow); 1083 1084 if (OK != res) 1085 return; 1086 1087 if (!mMediaTimeTransform.doReverseTransform(targetTimeNow, 1088 &mediaTimeNow)) { 1089 return; 1090 } 1091 } 1092 1093 size_t trimEnd; 1094 for (trimEnd = 0; trimEnd < mTimedBufferQueue.size(); trimEnd++) { 1095 int64_t bufEnd; 1096 1097 if ((trimEnd + 1) < mTimedBufferQueue.size()) { 1098 // We have a next buffer. Just use its PTS as the PTS of the frame 1099 // following the last frame in this buffer. If the stream is sparse 1100 // (ie, there are deliberate gaps left in the stream which should be 1101 // filled with silence by the TimedAudioTrack), then this can result 1102 // in one extra buffer being left un-trimmed when it could have 1103 // been. In general, this is not typical, and we would rather 1104 // optimized away the TS calculation below for the more common case 1105 // where PTSes are contiguous. 1106 bufEnd = mTimedBufferQueue[trimEnd + 1].pts(); 1107 } else { 1108 // We have no next buffer. Compute the PTS of the frame following 1109 // the last frame in this buffer by computing the duration of of 1110 // this frame in media time units and adding it to the PTS of the 1111 // buffer. 1112 int64_t frameCount = mTimedBufferQueue[trimEnd].buffer()->size() 1113 / mFrameSize; 1114 1115 if (!mMediaTimeToSampleTransform.doReverseTransform(frameCount, 1116 &bufEnd)) { 1117 ALOGE("Failed to convert frame count of %lld to media time" 1118 " duration" " (scale factor %d/%u) in %s", 1119 frameCount, 1120 mMediaTimeToSampleTransform.a_to_b_numer, 1121 mMediaTimeToSampleTransform.a_to_b_denom, 1122 __PRETTY_FUNCTION__); 1123 break; 1124 } 1125 bufEnd += mTimedBufferQueue[trimEnd].pts(); 1126 } 1127 1128 if (bufEnd > mediaTimeNow) 1129 break; 1130 1131 // Is the buffer we want to use in the middle of a mix operation right 1132 // now? If so, don't actually trim it. Just wait for the releaseBuffer 1133 // from the mixer which should be coming back shortly. 1134 if (!trimEnd && mQueueHeadInFlight) { 1135 mTrimQueueHeadOnRelease = true; 1136 } 1137 } 1138 1139 size_t trimStart = mTrimQueueHeadOnRelease ? 1 : 0; 1140 if (trimStart < trimEnd) { 1141 // Update the bookkeeping for framesReady() 1142 for (size_t i = trimStart; i < trimEnd; ++i) { 1143 updateFramesPendingAfterTrim_l(mTimedBufferQueue[i], "trim"); 1144 } 1145 1146 // Now actually remove the buffers from the queue. 1147 mTimedBufferQueue.removeItemsAt(trimStart, trimEnd); 1148 } 1149} 1150 1151void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueueHead_l( 1152 const char* logTag) { 1153 ALOG_ASSERT(mTimedBufferQueue.size() > 0, 1154 "%s called (reason \"%s\"), but timed buffer queue has no" 1155 " elements to trim.", __FUNCTION__, logTag); 1156 1157 updateFramesPendingAfterTrim_l(mTimedBufferQueue[0], logTag); 1158 mTimedBufferQueue.removeAt(0); 1159} 1160 1161void AudioFlinger::PlaybackThread::TimedTrack::updateFramesPendingAfterTrim_l( 1162 const TimedBuffer& buf, 1163 const char* logTag) { 1164 uint32_t bufBytes = buf.buffer()->size(); 1165 uint32_t consumedAlready = buf.position(); 1166 1167 ALOG_ASSERT(consumedAlready <= bufBytes, 1168 "Bad bookkeeping while updating frames pending. Timed buffer is" 1169 " only %u bytes long, but claims to have consumed %u" 1170 " bytes. (update reason: \"%s\")", 1171 bufBytes, consumedAlready, logTag); 1172 1173 uint32_t bufFrames = (bufBytes - consumedAlready) / mFrameSize; 1174 ALOG_ASSERT(mFramesPendingInQueue >= bufFrames, 1175 "Bad bookkeeping while updating frames pending. Should have at" 1176 " least %u queued frames, but we think we have only %u. (update" 1177 " reason: \"%s\")", 1178 bufFrames, mFramesPendingInQueue, logTag); 1179 1180 mFramesPendingInQueue -= bufFrames; 1181} 1182 1183status_t AudioFlinger::PlaybackThread::TimedTrack::queueTimedBuffer( 1184 const sp<IMemory>& buffer, int64_t pts) { 1185 1186 { 1187 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1188 if (!mMediaTimeTransformValid) 1189 return INVALID_OPERATION; 1190 } 1191 1192 Mutex::Autolock _l(mTimedBufferQueueLock); 1193 1194 uint32_t bufFrames = buffer->size() / mFrameSize; 1195 mFramesPendingInQueue += bufFrames; 1196 mTimedBufferQueue.add(TimedBuffer(buffer, pts)); 1197 1198 return NO_ERROR; 1199} 1200 1201status_t AudioFlinger::PlaybackThread::TimedTrack::setMediaTimeTransform( 1202 const LinearTransform& xform, TimedAudioTrack::TargetTimeline target) { 1203 1204 ALOGVV("setMediaTimeTransform az=%lld bz=%lld n=%d d=%u tgt=%d", 1205 xform.a_zero, xform.b_zero, xform.a_to_b_numer, xform.a_to_b_denom, 1206 target); 1207 1208 if (!(target == TimedAudioTrack::LOCAL_TIME || 1209 target == TimedAudioTrack::COMMON_TIME)) { 1210 return BAD_VALUE; 1211 } 1212 1213 Mutex::Autolock lock(mMediaTimeTransformLock); 1214 mMediaTimeTransform = xform; 1215 mMediaTimeTransformTarget = target; 1216 mMediaTimeTransformValid = true; 1217 1218 return NO_ERROR; 1219} 1220 1221#define min(a, b) ((a) < (b) ? (a) : (b)) 1222 1223// implementation of getNextBuffer for tracks whose buffers have timestamps 1224status_t AudioFlinger::PlaybackThread::TimedTrack::getNextBuffer( 1225 AudioBufferProvider::Buffer* buffer, int64_t pts) 1226{ 1227 if (pts == AudioBufferProvider::kInvalidPTS) { 1228 buffer->raw = NULL; 1229 buffer->frameCount = 0; 1230 mTimedAudioOutputOnTime = false; 1231 return INVALID_OPERATION; 1232 } 1233 1234 Mutex::Autolock _l(mTimedBufferQueueLock); 1235 1236 ALOG_ASSERT(!mQueueHeadInFlight, 1237 "getNextBuffer called without releaseBuffer!"); 1238 1239 while (true) { 1240 1241 // if we have no timed buffers, then fail 1242 if (mTimedBufferQueue.isEmpty()) { 1243 buffer->raw = NULL; 1244 buffer->frameCount = 0; 1245 return NOT_ENOUGH_DATA; 1246 } 1247 1248 TimedBuffer& head = mTimedBufferQueue.editItemAt(0); 1249 1250 // calculate the PTS of the head of the timed buffer queue expressed in 1251 // local time 1252 int64_t headLocalPTS; 1253 { 1254 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1255 1256 ALOG_ASSERT(mMediaTimeTransformValid, "media time transform invalid"); 1257 1258 if (mMediaTimeTransform.a_to_b_denom == 0) { 1259 // the transform represents a pause, so yield silence 1260 timedYieldSilence_l(buffer->frameCount, buffer); 1261 return NO_ERROR; 1262 } 1263 1264 int64_t transformedPTS; 1265 if (!mMediaTimeTransform.doForwardTransform(head.pts(), 1266 &transformedPTS)) { 1267 // the transform failed. this shouldn't happen, but if it does 1268 // then just drop this buffer 1269 ALOGW("timedGetNextBuffer transform failed"); 1270 buffer->raw = NULL; 1271 buffer->frameCount = 0; 1272 trimTimedBufferQueueHead_l("getNextBuffer; no transform"); 1273 return NO_ERROR; 1274 } 1275 1276 if (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) { 1277 if (OK != mCCHelper.commonTimeToLocalTime(transformedPTS, 1278 &headLocalPTS)) { 1279 buffer->raw = NULL; 1280 buffer->frameCount = 0; 1281 return INVALID_OPERATION; 1282 } 1283 } else { 1284 headLocalPTS = transformedPTS; 1285 } 1286 } 1287 1288 uint32_t sr = sampleRate(); 1289 1290 // adjust the head buffer's PTS to reflect the portion of the head buffer 1291 // that has already been consumed 1292 int64_t effectivePTS = headLocalPTS + 1293 ((head.position() / mFrameSize) * mLocalTimeFreq / sr); 1294 1295 // Calculate the delta in samples between the head of the input buffer 1296 // queue and the start of the next output buffer that will be written. 1297 // If the transformation fails because of over or underflow, it means 1298 // that the sample's position in the output stream is so far out of 1299 // whack that it should just be dropped. 1300 int64_t sampleDelta; 1301 if (llabs(effectivePTS - pts) >= (static_cast<int64_t>(1) << 31)) { 1302 ALOGV("*** head buffer is too far from PTS: dropped buffer"); 1303 trimTimedBufferQueueHead_l("getNextBuffer, buf pts too far from" 1304 " mix"); 1305 continue; 1306 } 1307 if (!mLocalTimeToSampleTransform.doForwardTransform( 1308 (effectivePTS - pts) << 32, &sampleDelta)) { 1309 ALOGV("*** too late during sample rate transform: dropped buffer"); 1310 trimTimedBufferQueueHead_l("getNextBuffer, bad local to sample"); 1311 continue; 1312 } 1313 1314 ALOGVV("*** getNextBuffer head.pts=%lld head.pos=%d pts=%lld" 1315 " sampleDelta=[%d.%08x]", 1316 head.pts(), head.position(), pts, 1317 static_cast<int32_t>((sampleDelta >= 0 ? 0 : 1) 1318 + (sampleDelta >> 32)), 1319 static_cast<uint32_t>(sampleDelta & 0xFFFFFFFF)); 1320 1321 // if the delta between the ideal placement for the next input sample and 1322 // the current output position is within this threshold, then we will 1323 // concatenate the next input samples to the previous output 1324 const int64_t kSampleContinuityThreshold = 1325 (static_cast<int64_t>(sr) << 32) / 250; 1326 1327 // if this is the first buffer of audio that we're emitting from this track 1328 // then it should be almost exactly on time. 1329 const int64_t kSampleStartupThreshold = 1LL << 32; 1330 1331 if ((mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleContinuityThreshold) || 1332 (!mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleStartupThreshold)) { 1333 // the next input is close enough to being on time, so concatenate it 1334 // with the last output 1335 timedYieldSamples_l(buffer); 1336 1337 ALOGVV("*** on time: head.pos=%d frameCount=%u", 1338 head.position(), buffer->frameCount); 1339 return NO_ERROR; 1340 } 1341 1342 // Looks like our output is not on time. Reset our on timed status. 1343 // Next time we mix samples from our input queue, then should be within 1344 // the StartupThreshold. 1345 mTimedAudioOutputOnTime = false; 1346 if (sampleDelta > 0) { 1347 // the gap between the current output position and the proper start of 1348 // the next input sample is too big, so fill it with silence 1349 uint32_t framesUntilNextInput = (sampleDelta + 0x80000000) >> 32; 1350 1351 timedYieldSilence_l(framesUntilNextInput, buffer); 1352 ALOGV("*** silence: frameCount=%u", buffer->frameCount); 1353 return NO_ERROR; 1354 } else { 1355 // the next input sample is late 1356 uint32_t lateFrames = static_cast<uint32_t>(-((sampleDelta + 0x80000000) >> 32)); 1357 size_t onTimeSamplePosition = 1358 head.position() + lateFrames * mFrameSize; 1359 1360 if (onTimeSamplePosition > head.buffer()->size()) { 1361 // all the remaining samples in the head are too late, so 1362 // drop it and move on 1363 ALOGV("*** too late: dropped buffer"); 1364 trimTimedBufferQueueHead_l("getNextBuffer, dropped late buffer"); 1365 continue; 1366 } else { 1367 // skip over the late samples 1368 head.setPosition(onTimeSamplePosition); 1369 1370 // yield the available samples 1371 timedYieldSamples_l(buffer); 1372 1373 ALOGV("*** late: head.pos=%d frameCount=%u", head.position(), buffer->frameCount); 1374 return NO_ERROR; 1375 } 1376 } 1377 } 1378} 1379 1380// Yield samples from the timed buffer queue head up to the given output 1381// buffer's capacity. 1382// 1383// Caller must hold mTimedBufferQueueLock 1384void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSamples_l( 1385 AudioBufferProvider::Buffer* buffer) { 1386 1387 const TimedBuffer& head = mTimedBufferQueue[0]; 1388 1389 buffer->raw = (static_cast<uint8_t*>(head.buffer()->pointer()) + 1390 head.position()); 1391 1392 uint32_t framesLeftInHead = ((head.buffer()->size() - head.position()) / 1393 mFrameSize); 1394 size_t framesRequested = buffer->frameCount; 1395 buffer->frameCount = min(framesLeftInHead, framesRequested); 1396 1397 mQueueHeadInFlight = true; 1398 mTimedAudioOutputOnTime = true; 1399} 1400 1401// Yield samples of silence up to the given output buffer's capacity 1402// 1403// Caller must hold mTimedBufferQueueLock 1404void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSilence_l( 1405 uint32_t numFrames, AudioBufferProvider::Buffer* buffer) { 1406 1407 // lazily allocate a buffer filled with silence 1408 if (mTimedSilenceBufferSize < numFrames * mFrameSize) { 1409 delete [] mTimedSilenceBuffer; 1410 mTimedSilenceBufferSize = numFrames * mFrameSize; 1411 mTimedSilenceBuffer = new uint8_t[mTimedSilenceBufferSize]; 1412 memset(mTimedSilenceBuffer, 0, mTimedSilenceBufferSize); 1413 } 1414 1415 buffer->raw = mTimedSilenceBuffer; 1416 size_t framesRequested = buffer->frameCount; 1417 buffer->frameCount = min(numFrames, framesRequested); 1418 1419 mTimedAudioOutputOnTime = false; 1420} 1421 1422// AudioBufferProvider interface 1423void AudioFlinger::PlaybackThread::TimedTrack::releaseBuffer( 1424 AudioBufferProvider::Buffer* buffer) { 1425 1426 Mutex::Autolock _l(mTimedBufferQueueLock); 1427 1428 // If the buffer which was just released is part of the buffer at the head 1429 // of the queue, be sure to update the amt of the buffer which has been 1430 // consumed. If the buffer being returned is not part of the head of the 1431 // queue, its either because the buffer is part of the silence buffer, or 1432 // because the head of the timed queue was trimmed after the mixer called 1433 // getNextBuffer but before the mixer called releaseBuffer. 1434 if (buffer->raw == mTimedSilenceBuffer) { 1435 ALOG_ASSERT(!mQueueHeadInFlight, 1436 "Queue head in flight during release of silence buffer!"); 1437 goto done; 1438 } 1439 1440 ALOG_ASSERT(mQueueHeadInFlight, 1441 "TimedTrack::releaseBuffer of non-silence buffer, but no queue" 1442 " head in flight."); 1443 1444 if (mTimedBufferQueue.size()) { 1445 TimedBuffer& head = mTimedBufferQueue.editItemAt(0); 1446 1447 void* start = head.buffer()->pointer(); 1448 void* end = reinterpret_cast<void*>( 1449 reinterpret_cast<uint8_t*>(head.buffer()->pointer()) 1450 + head.buffer()->size()); 1451 1452 ALOG_ASSERT((buffer->raw >= start) && (buffer->raw < end), 1453 "released buffer not within the head of the timed buffer" 1454 " queue; qHead = [%p, %p], released buffer = %p", 1455 start, end, buffer->raw); 1456 1457 head.setPosition(head.position() + 1458 (buffer->frameCount * mFrameSize)); 1459 mQueueHeadInFlight = false; 1460 1461 ALOG_ASSERT(mFramesPendingInQueue >= buffer->frameCount, 1462 "Bad bookkeeping during releaseBuffer! Should have at" 1463 " least %u queued frames, but we think we have only %u", 1464 buffer->frameCount, mFramesPendingInQueue); 1465 1466 mFramesPendingInQueue -= buffer->frameCount; 1467 1468 if ((static_cast<size_t>(head.position()) >= head.buffer()->size()) 1469 || mTrimQueueHeadOnRelease) { 1470 trimTimedBufferQueueHead_l("releaseBuffer"); 1471 mTrimQueueHeadOnRelease = false; 1472 } 1473 } else { 1474 LOG_FATAL("TimedTrack::releaseBuffer of non-silence buffer with no" 1475 " buffers in the timed buffer queue"); 1476 } 1477 1478done: 1479 buffer->raw = 0; 1480 buffer->frameCount = 0; 1481} 1482 1483size_t AudioFlinger::PlaybackThread::TimedTrack::framesReady() const { 1484 Mutex::Autolock _l(mTimedBufferQueueLock); 1485 return mFramesPendingInQueue; 1486} 1487 1488AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer() 1489 : mPTS(0), mPosition(0) {} 1490 1491AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer( 1492 const sp<IMemory>& buffer, int64_t pts) 1493 : mBuffer(buffer), mPTS(pts), mPosition(0) {} 1494 1495 1496// ---------------------------------------------------------------------------- 1497 1498AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( 1499 PlaybackThread *playbackThread, 1500 DuplicatingThread *sourceThread, 1501 uint32_t sampleRate, 1502 audio_format_t format, 1503 audio_channel_mask_t channelMask, 1504 size_t frameCount, 1505 int uid) 1506 : Track(playbackThread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelMask, frameCount, 1507 NULL, 0, uid, IAudioFlinger::TRACK_DEFAULT), 1508 mActive(false), mSourceThread(sourceThread), mClientProxy(NULL) 1509{ 1510 1511 if (mCblk != NULL) { 1512 mOutBuffer.frameCount = 0; 1513 playbackThread->mTracks.add(this); 1514 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, " 1515 "mCblk->frameCount_ %u, mChannelMask 0x%08x", 1516 mCblk, mBuffer, 1517 mCblk->frameCount_, mChannelMask); 1518 // since client and server are in the same process, 1519 // the buffer has the same virtual address on both sides 1520 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize); 1521 mClientProxy->setVolumeLR((uint32_t(uint16_t(0x1000)) << 16) | uint16_t(0x1000)); 1522 mClientProxy->setSendLevel(0.0); 1523 mClientProxy->setSampleRate(sampleRate); 1524 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize, 1525 true /*clientInServer*/); 1526 } else { 1527 ALOGW("Error creating output track on thread %p", playbackThread); 1528 } 1529} 1530 1531AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack() 1532{ 1533 clearBufferQueue(); 1534 delete mClientProxy; 1535 // superclass destructor will now delete the server proxy and shared memory both refer to 1536} 1537 1538status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event, 1539 int triggerSession) 1540{ 1541 status_t status = Track::start(event, triggerSession); 1542 if (status != NO_ERROR) { 1543 return status; 1544 } 1545 1546 mActive = true; 1547 mRetryCount = 127; 1548 return status; 1549} 1550 1551void AudioFlinger::PlaybackThread::OutputTrack::stop() 1552{ 1553 Track::stop(); 1554 clearBufferQueue(); 1555 mOutBuffer.frameCount = 0; 1556 mActive = false; 1557} 1558 1559bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames) 1560{ 1561 Buffer *pInBuffer; 1562 Buffer inBuffer; 1563 uint32_t channelCount = mChannelCount; 1564 bool outputBufferFull = false; 1565 inBuffer.frameCount = frames; 1566 inBuffer.i16 = data; 1567 1568 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); 1569 1570 if (!mActive && frames != 0) { 1571 start(); 1572 sp<ThreadBase> thread = mThread.promote(); 1573 if (thread != 0) { 1574 MixerThread *mixerThread = (MixerThread *)thread.get(); 1575 if (mFrameCount > frames) { 1576 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 1577 uint32_t startFrames = (mFrameCount - frames); 1578 pInBuffer = new Buffer; 1579 pInBuffer->mBuffer = new int16_t[startFrames * channelCount]; 1580 pInBuffer->frameCount = startFrames; 1581 pInBuffer->i16 = pInBuffer->mBuffer; 1582 memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t)); 1583 mBufferQueue.add(pInBuffer); 1584 } else { 1585 ALOGW("OutputTrack::write() %p no more buffers in queue", this); 1586 } 1587 } 1588 } 1589 } 1590 1591 while (waitTimeLeftMs) { 1592 // First write pending buffers, then new data 1593 if (mBufferQueue.size()) { 1594 pInBuffer = mBufferQueue.itemAt(0); 1595 } else { 1596 pInBuffer = &inBuffer; 1597 } 1598 1599 if (pInBuffer->frameCount == 0) { 1600 break; 1601 } 1602 1603 if (mOutBuffer.frameCount == 0) { 1604 mOutBuffer.frameCount = pInBuffer->frameCount; 1605 nsecs_t startTime = systemTime(); 1606 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs); 1607 if (status != NO_ERROR) { 1608 ALOGV("OutputTrack::write() %p thread %p no more output buffers; status %d", this, 1609 mThread.unsafe_get(), status); 1610 outputBufferFull = true; 1611 break; 1612 } 1613 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); 1614 if (waitTimeLeftMs >= waitTimeMs) { 1615 waitTimeLeftMs -= waitTimeMs; 1616 } else { 1617 waitTimeLeftMs = 0; 1618 } 1619 } 1620 1621 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : 1622 pInBuffer->frameCount; 1623 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t)); 1624 Proxy::Buffer buf; 1625 buf.mFrameCount = outFrames; 1626 buf.mRaw = NULL; 1627 mClientProxy->releaseBuffer(&buf); 1628 pInBuffer->frameCount -= outFrames; 1629 pInBuffer->i16 += outFrames * channelCount; 1630 mOutBuffer.frameCount -= outFrames; 1631 mOutBuffer.i16 += outFrames * channelCount; 1632 1633 if (pInBuffer->frameCount == 0) { 1634 if (mBufferQueue.size()) { 1635 mBufferQueue.removeAt(0); 1636 delete [] pInBuffer->mBuffer; 1637 delete pInBuffer; 1638 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, 1639 mThread.unsafe_get(), mBufferQueue.size()); 1640 } else { 1641 break; 1642 } 1643 } 1644 } 1645 1646 // If we could not write all frames, allocate a buffer and queue it for next time. 1647 if (inBuffer.frameCount) { 1648 sp<ThreadBase> thread = mThread.promote(); 1649 if (thread != 0 && !thread->standby()) { 1650 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 1651 pInBuffer = new Buffer; 1652 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount]; 1653 pInBuffer->frameCount = inBuffer.frameCount; 1654 pInBuffer->i16 = pInBuffer->mBuffer; 1655 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * 1656 sizeof(int16_t)); 1657 mBufferQueue.add(pInBuffer); 1658 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, 1659 mThread.unsafe_get(), mBufferQueue.size()); 1660 } else { 1661 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers", 1662 mThread.unsafe_get(), this); 1663 } 1664 } 1665 } 1666 1667 // Calling write() with a 0 length buffer, means that no more data will be written: 1668 // If no more buffers are pending, fill output track buffer to make sure it is started 1669 // by output mixer. 1670 if (frames == 0 && mBufferQueue.size() == 0) { 1671 // FIXME borken, replace by getting framesReady() from proxy 1672 size_t user = 0; // was mCblk->user 1673 if (user < mFrameCount) { 1674 frames = mFrameCount - user; 1675 pInBuffer = new Buffer; 1676 pInBuffer->mBuffer = new int16_t[frames * channelCount]; 1677 pInBuffer->frameCount = frames; 1678 pInBuffer->i16 = pInBuffer->mBuffer; 1679 memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t)); 1680 mBufferQueue.add(pInBuffer); 1681 } else if (mActive) { 1682 stop(); 1683 } 1684 } 1685 1686 return outputBufferFull; 1687} 1688 1689status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer( 1690 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs) 1691{ 1692 ClientProxy::Buffer buf; 1693 buf.mFrameCount = buffer->frameCount; 1694 struct timespec timeout; 1695 timeout.tv_sec = waitTimeMs / 1000; 1696 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000; 1697 status_t status = mClientProxy->obtainBuffer(&buf, &timeout); 1698 buffer->frameCount = buf.mFrameCount; 1699 buffer->raw = buf.mRaw; 1700 return status; 1701} 1702 1703void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue() 1704{ 1705 size_t size = mBufferQueue.size(); 1706 1707 for (size_t i = 0; i < size; i++) { 1708 Buffer *pBuffer = mBufferQueue.itemAt(i); 1709 delete [] pBuffer->mBuffer; 1710 delete pBuffer; 1711 } 1712 mBufferQueue.clear(); 1713} 1714 1715 1716// ---------------------------------------------------------------------------- 1717// Record 1718// ---------------------------------------------------------------------------- 1719 1720AudioFlinger::RecordHandle::RecordHandle( 1721 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack) 1722 : BnAudioRecord(), 1723 mRecordTrack(recordTrack) 1724{ 1725} 1726 1727AudioFlinger::RecordHandle::~RecordHandle() { 1728 stop_nonvirtual(); 1729 mRecordTrack->destroy(); 1730} 1731 1732sp<IMemory> AudioFlinger::RecordHandle::getCblk() const { 1733 return mRecordTrack->getCblk(); 1734} 1735 1736status_t AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event, 1737 int triggerSession) { 1738 ALOGV("RecordHandle::start()"); 1739 return mRecordTrack->start((AudioSystem::sync_event_t)event, triggerSession); 1740} 1741 1742void AudioFlinger::RecordHandle::stop() { 1743 stop_nonvirtual(); 1744} 1745 1746void AudioFlinger::RecordHandle::stop_nonvirtual() { 1747 ALOGV("RecordHandle::stop()"); 1748 mRecordTrack->stop(); 1749} 1750 1751status_t AudioFlinger::RecordHandle::onTransact( 1752 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1753{ 1754 return BnAudioRecord::onTransact(code, data, reply, flags); 1755} 1756 1757// ---------------------------------------------------------------------------- 1758 1759// RecordTrack constructor must be called with AudioFlinger::mLock held 1760AudioFlinger::RecordThread::RecordTrack::RecordTrack( 1761 RecordThread *thread, 1762 const sp<Client>& client, 1763 uint32_t sampleRate, 1764 audio_format_t format, 1765 audio_channel_mask_t channelMask, 1766 size_t frameCount, 1767 int sessionId, 1768 int uid) 1769 : TrackBase(thread, client, sampleRate, format, 1770 channelMask, frameCount, 0 /*sharedBuffer*/, sessionId, uid, false /*isOut*/), 1771 mOverflow(false) 1772{ 1773 ALOGV("RecordTrack constructor"); 1774 if (mCblk != NULL) { 1775 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount, mFrameSize); 1776 } 1777} 1778 1779AudioFlinger::RecordThread::RecordTrack::~RecordTrack() 1780{ 1781 ALOGV("%s", __func__); 1782} 1783 1784// AudioBufferProvider interface 1785status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer, 1786 int64_t pts) 1787{ 1788 ServerProxy::Buffer buf; 1789 buf.mFrameCount = buffer->frameCount; 1790 status_t status = mServerProxy->obtainBuffer(&buf); 1791 buffer->frameCount = buf.mFrameCount; 1792 buffer->raw = buf.mRaw; 1793 if (buf.mFrameCount == 0) { 1794 // FIXME also wake futex so that overrun is noticed more quickly 1795 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags); 1796 } 1797 return status; 1798} 1799 1800status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event, 1801 int triggerSession) 1802{ 1803 sp<ThreadBase> thread = mThread.promote(); 1804 if (thread != 0) { 1805 RecordThread *recordThread = (RecordThread *)thread.get(); 1806 return recordThread->start(this, event, triggerSession); 1807 } else { 1808 return BAD_VALUE; 1809 } 1810} 1811 1812void AudioFlinger::RecordThread::RecordTrack::stop() 1813{ 1814 sp<ThreadBase> thread = mThread.promote(); 1815 if (thread != 0) { 1816 RecordThread *recordThread = (RecordThread *)thread.get(); 1817 if (recordThread->stop(this)) { 1818 AudioSystem::stopInput(recordThread->id()); 1819 } 1820 } 1821} 1822 1823void AudioFlinger::RecordThread::RecordTrack::destroy() 1824{ 1825 // see comments at AudioFlinger::PlaybackThread::Track::destroy() 1826 sp<RecordTrack> keep(this); 1827 { 1828 sp<ThreadBase> thread = mThread.promote(); 1829 if (thread != 0) { 1830 if (mState == ACTIVE || mState == RESUMING) { 1831 AudioSystem::stopInput(thread->id()); 1832 } 1833 AudioSystem::releaseInput(thread->id()); 1834 Mutex::Autolock _l(thread->mLock); 1835 RecordThread *recordThread = (RecordThread *) thread.get(); 1836 recordThread->destroyTrack_l(this); 1837 } 1838 } 1839} 1840 1841void AudioFlinger::RecordThread::RecordTrack::invalidate() 1842{ 1843 // FIXME should use proxy, and needs work 1844 audio_track_cblk_t* cblk = mCblk; 1845 android_atomic_or(CBLK_INVALID, &cblk->mFlags); 1846 android_atomic_release_store(0x40000000, &cblk->mFutex); 1847 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 1848 (void) __futex_syscall3(&cblk->mFutex, FUTEX_WAKE, INT_MAX); 1849} 1850 1851 1852/*static*/ void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result) 1853{ 1854 result.append("Client Fmt Chn mask Session S Server fCount\n"); 1855} 1856 1857void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size) 1858{ 1859 snprintf(buffer, size, "%6u %3u %08X %7u %1d %08X %6u\n", 1860 (mClient == 0) ? getpid_cached : mClient->pid(), 1861 mFormat, 1862 mChannelMask, 1863 mSessionId, 1864 mState, 1865 mCblk->mServer, 1866 mFrameCount); 1867} 1868 1869}; // namespace android 1870