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