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