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 #ifndef INCLUDING_FROM_AUDIOFLINGER_H 19 #error This header file should only be included from AudioFlinger.h 20 #endif 21 22 class ThreadBase : public Thread { 23 public: 24 25 #include "TrackBase.h" 26 27 enum type_t { 28 MIXER, // Thread class is MixerThread 29 DIRECT, // Thread class is DirectOutputThread 30 DUPLICATING, // Thread class is DuplicatingThread 31 RECORD, // Thread class is RecordThread 32 OFFLOAD // Thread class is OffloadThread 33 }; 34 35 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 36 audio_devices_t outDevice, audio_devices_t inDevice, type_t type); 37 virtual ~ThreadBase(); 38 39 void dumpBase(int fd, const Vector<String16>& args); 40 void dumpEffectChains(int fd, const Vector<String16>& args); 41 42 void clearPowerManager(); 43 44 // base for record and playback 45 enum { 46 CFG_EVENT_IO, 47 CFG_EVENT_PRIO 48 }; 49 50 class ConfigEvent { 51 public: 52 ConfigEvent(int type) : mType(type) {} 53 virtual ~ConfigEvent() {} 54 55 int type() const { return mType; } 56 57 virtual void dump(char *buffer, size_t size) = 0; 58 59 private: 60 const int mType; 61 }; 62 63 class IoConfigEvent : public ConfigEvent { 64 public: 65 IoConfigEvent(int event, int param) : 66 ConfigEvent(CFG_EVENT_IO), mEvent(event), mParam(event) {} 67 virtual ~IoConfigEvent() {} 68 69 int event() const { return mEvent; } 70 int param() const { return mParam; } 71 72 virtual void dump(char *buffer, size_t size) { 73 snprintf(buffer, size, "IO event: event %d, param %d\n", mEvent, mParam); 74 } 75 76 private: 77 const int mEvent; 78 const int mParam; 79 }; 80 81 class PrioConfigEvent : public ConfigEvent { 82 public: 83 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio) : 84 ConfigEvent(CFG_EVENT_PRIO), mPid(pid), mTid(tid), mPrio(prio) {} 85 virtual ~PrioConfigEvent() {} 86 87 pid_t pid() const { return mPid; } 88 pid_t tid() const { return mTid; } 89 int32_t prio() const { return mPrio; } 90 91 virtual void dump(char *buffer, size_t size) { 92 snprintf(buffer, size, "Prio event: pid %d, tid %d, prio %d\n", mPid, mTid, mPrio); 93 } 94 95 private: 96 const pid_t mPid; 97 const pid_t mTid; 98 const int32_t mPrio; 99 }; 100 101 102 class PMDeathRecipient : public IBinder::DeathRecipient { 103 public: 104 PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} 105 virtual ~PMDeathRecipient() {} 106 107 // IBinder::DeathRecipient 108 virtual void binderDied(const wp<IBinder>& who); 109 110 private: 111 PMDeathRecipient(const PMDeathRecipient&); 112 PMDeathRecipient& operator = (const PMDeathRecipient&); 113 114 wp<ThreadBase> mThread; 115 }; 116 117 virtual status_t initCheck() const = 0; 118 119 // static externally-visible 120 type_t type() const { return mType; } 121 audio_io_handle_t id() const { return mId;} 122 123 // dynamic externally-visible 124 uint32_t sampleRate() const { return mSampleRate; } 125 uint32_t channelCount() const { return mChannelCount; } 126 audio_channel_mask_t channelMask() const { return mChannelMask; } 127 audio_format_t format() const { return mFormat; } 128 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects, 129 // and returns the [normal mix] buffer's frame count. 130 virtual size_t frameCount() const = 0; 131 size_t frameSize() const { return mFrameSize; } 132 133 // Should be "virtual status_t requestExitAndWait()" and override same 134 // method in Thread, but Thread::requestExitAndWait() is not yet virtual. 135 void exit(); 136 virtual bool checkForNewParameters_l() = 0; 137 virtual status_t setParameters(const String8& keyValuePairs); 138 virtual String8 getParameters(const String8& keys) = 0; 139 virtual void audioConfigChanged_l(int event, int param = 0) = 0; 140 void sendIoConfigEvent(int event, int param = 0); 141 void sendIoConfigEvent_l(int event, int param = 0); 142 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio); 143 void processConfigEvents(); 144 145 // see note at declaration of mStandby, mOutDevice and mInDevice 146 bool standby() const { return mStandby; } 147 audio_devices_t outDevice() const { return mOutDevice; } 148 audio_devices_t inDevice() const { return mInDevice; } 149 150 virtual audio_stream_t* stream() const = 0; 151 152 sp<EffectHandle> createEffect_l( 153 const sp<AudioFlinger::Client>& client, 154 const sp<IEffectClient>& effectClient, 155 int32_t priority, 156 int sessionId, 157 effect_descriptor_t *desc, 158 int *enabled, 159 status_t *status); 160 void disconnectEffect(const sp< EffectModule>& effect, 161 EffectHandle *handle, 162 bool unpinIfLast); 163 164 // return values for hasAudioSession (bit field) 165 enum effect_state { 166 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one 167 // effect 168 TRACK_SESSION = 0x2 // the audio session corresponds to at least one 169 // track 170 }; 171 172 // get effect chain corresponding to session Id. 173 sp<EffectChain> getEffectChain(int sessionId); 174 // same as getEffectChain() but must be called with ThreadBase mutex locked 175 sp<EffectChain> getEffectChain_l(int sessionId) const; 176 // add an effect chain to the chain list (mEffectChains) 177 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; 178 // remove an effect chain from the chain list (mEffectChains) 179 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; 180 // lock all effect chains Mutexes. Must be called before releasing the 181 // ThreadBase mutex before processing the mixer and effects. This guarantees the 182 // integrity of the chains during the process. 183 // Also sets the parameter 'effectChains' to current value of mEffectChains. 184 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains); 185 // unlock effect chains after process 186 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains); 187 // get a copy of mEffectChains vector 188 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; }; 189 // set audio mode to all effect chains 190 void setMode(audio_mode_t mode); 191 // get effect module with corresponding ID on specified audio session 192 sp<AudioFlinger::EffectModule> getEffect(int sessionId, int effectId); 193 sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId); 194 // add and effect module. Also creates the effect chain is none exists for 195 // the effects audio session 196 status_t addEffect_l(const sp< EffectModule>& effect); 197 // remove and effect module. Also removes the effect chain is this was the last 198 // effect 199 void removeEffect_l(const sp< EffectModule>& effect); 200 // detach all tracks connected to an auxiliary effect 201 virtual void detachAuxEffect_l(int effectId) {} 202 // returns either EFFECT_SESSION if effects on this audio session exist in one 203 // chain, or TRACK_SESSION if tracks on this audio session exist, or both 204 virtual uint32_t hasAudioSession(int sessionId) const = 0; 205 // the value returned by default implementation is not important as the 206 // strategy is only meaningful for PlaybackThread which implements this method 207 virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; } 208 209 // suspend or restore effect according to the type of effect passed. a NULL 210 // type pointer means suspend all effects in the session 211 void setEffectSuspended(const effect_uuid_t *type, 212 bool suspend, 213 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 214 // check if some effects must be suspended/restored when an effect is enabled 215 // or disabled 216 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 217 bool enabled, 218 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 219 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, 220 bool enabled, 221 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 222 223 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0; 224 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0; 225 226 227 mutable Mutex mLock; 228 229 protected: 230 231 // entry describing an effect being suspended in mSuspendedSessions keyed vector 232 class SuspendedSessionDesc : public RefBase { 233 public: 234 SuspendedSessionDesc() : mRefCount(0) {} 235 236 int mRefCount; // number of active suspend requests 237 effect_uuid_t mType; // effect type UUID 238 }; 239 240 void acquireWakeLock(int uid = -1); 241 void acquireWakeLock_l(int uid = -1); 242 void releaseWakeLock(); 243 void releaseWakeLock_l(); 244 void updateWakeLockUids(const SortedVector<int> &uids); 245 void updateWakeLockUids_l(const SortedVector<int> &uids); 246 void getPowerManager_l(); 247 void setEffectSuspended_l(const effect_uuid_t *type, 248 bool suspend, 249 int sessionId); 250 // updated mSuspendedSessions when an effect suspended or restored 251 void updateSuspendedSessions_l(const effect_uuid_t *type, 252 bool suspend, 253 int sessionId); 254 // check if some effects must be suspended when an effect chain is added 255 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); 256 257 String16 getWakeLockTag(); 258 259 virtual void preExit() { } 260 261 friend class AudioFlinger; // for mEffectChains 262 263 const type_t mType; 264 265 // Used by parameters, config events, addTrack_l, exit 266 Condition mWaitWorkCV; 267 268 const sp<AudioFlinger> mAudioFlinger; 269 270 // updated by PlaybackThread::readOutputParameters() or 271 // RecordThread::readInputParameters() 272 uint32_t mSampleRate; 273 size_t mFrameCount; // output HAL, direct output, record 274 audio_channel_mask_t mChannelMask; 275 uint32_t mChannelCount; 276 size_t mFrameSize; 277 audio_format_t mFormat; 278 279 // Parameter sequence by client: binder thread calling setParameters(): 280 // 1. Lock mLock 281 // 2. Append to mNewParameters 282 // 3. mWaitWorkCV.signal 283 // 4. mParamCond.waitRelative with timeout 284 // 5. read mParamStatus 285 // 6. mWaitWorkCV.signal 286 // 7. Unlock 287 // 288 // Parameter sequence by server: threadLoop calling checkForNewParameters_l(): 289 // 1. Lock mLock 290 // 2. If there is an entry in mNewParameters proceed ... 291 // 2. Read first entry in mNewParameters 292 // 3. Process 293 // 4. Remove first entry from mNewParameters 294 // 5. Set mParamStatus 295 // 6. mParamCond.signal 296 // 7. mWaitWorkCV.wait with timeout (this is to avoid overwriting mParamStatus) 297 // 8. Unlock 298 Condition mParamCond; 299 Vector<String8> mNewParameters; 300 status_t mParamStatus; 301 302 // vector owns each ConfigEvent *, so must delete after removing 303 Vector<ConfigEvent *> mConfigEvents; 304 305 // These fields are written and read by thread itself without lock or barrier, 306 // and read by other threads without lock or barrier via standby() , outDevice() 307 // and inDevice(). 308 // Because of the absence of a lock or barrier, any other thread that reads 309 // these fields must use the information in isolation, or be prepared to deal 310 // with possibility that it might be inconsistent with other information. 311 bool mStandby; // Whether thread is currently in standby. 312 audio_devices_t mOutDevice; // output device 313 audio_devices_t mInDevice; // input device 314 audio_source_t mAudioSource; // (see audio.h, audio_source_t) 315 316 const audio_io_handle_t mId; 317 Vector< sp<EffectChain> > mEffectChains; 318 319 static const int kNameLength = 16; // prctl(PR_SET_NAME) limit 320 char mName[kNameLength]; 321 sp<IPowerManager> mPowerManager; 322 sp<IBinder> mWakeLockToken; 323 const sp<PMDeathRecipient> mDeathRecipient; 324 // list of suspended effects per session and per type. The first vector is 325 // keyed by session ID, the second by type UUID timeLow field 326 KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > 327 mSuspendedSessions; 328 static const size_t kLogSize = 4 * 1024; 329 sp<NBLog::Writer> mNBLogWriter; 330 }; 331 332 // --- PlaybackThread --- 333 class PlaybackThread : public ThreadBase { 334 public: 335 336 #include "PlaybackTracks.h" 337 338 enum mixer_state { 339 MIXER_IDLE, // no active tracks 340 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready 341 MIXER_TRACKS_READY, // at least one active track, and at least one track has data 342 MIXER_DRAIN_TRACK, // drain currently playing track 343 MIXER_DRAIN_ALL, // fully drain the hardware 344 // standby mode does not have an enum value 345 // suspend by audio policy manager is orthogonal to mixer state 346 }; 347 348 // retry count before removing active track in case of underrun on offloaded thread: 349 // we need to make sure that AudioTrack client has enough time to send large buffers 350 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is handled 351 // for offloaded tracks 352 static const int8_t kMaxTrackRetriesOffload = 20; 353 354 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 355 audio_io_handle_t id, audio_devices_t device, type_t type); 356 virtual ~PlaybackThread(); 357 358 void dump(int fd, const Vector<String16>& args); 359 360 // Thread virtuals 361 virtual status_t readyToRun(); 362 virtual bool threadLoop(); 363 364 // RefBase 365 virtual void onFirstRef(); 366 367 protected: 368 // Code snippets that were lifted up out of threadLoop() 369 virtual void threadLoop_mix() = 0; 370 virtual void threadLoop_sleepTime() = 0; 371 virtual ssize_t threadLoop_write(); 372 virtual void threadLoop_drain(); 373 virtual void threadLoop_standby(); 374 virtual void threadLoop_exit(); 375 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove); 376 377 // prepareTracks_l reads and writes mActiveTracks, and returns 378 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller 379 // is responsible for clearing or destroying this Vector later on, when it 380 // is safe to do so. That will drop the final ref count and destroy the tracks. 381 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0; 382 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove); 383 384 void writeCallback(); 385 void resetWriteBlocked(uint32_t sequence); 386 void drainCallback(); 387 void resetDraining(uint32_t sequence); 388 389 static int asyncCallback(stream_callback_event_t event, void *param, void *cookie); 390 391 virtual bool waitingAsyncCallback(); 392 virtual bool waitingAsyncCallback_l(); 393 virtual bool shouldStandby_l(); 394 395 396 // ThreadBase virtuals 397 virtual void preExit(); 398 399 public: 400 401 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } 402 403 // return estimated latency in milliseconds, as reported by HAL 404 uint32_t latency() const; 405 // same, but lock must already be held 406 uint32_t latency_l() const; 407 408 void setMasterVolume(float value); 409 void setMasterMute(bool muted); 410 411 void setStreamVolume(audio_stream_type_t stream, float value); 412 void setStreamMute(audio_stream_type_t stream, bool muted); 413 414 float streamVolume(audio_stream_type_t stream) const; 415 416 sp<Track> createTrack_l( 417 const sp<AudioFlinger::Client>& client, 418 audio_stream_type_t streamType, 419 uint32_t sampleRate, 420 audio_format_t format, 421 audio_channel_mask_t channelMask, 422 size_t frameCount, 423 const sp<IMemory>& sharedBuffer, 424 int sessionId, 425 IAudioFlinger::track_flags_t *flags, 426 pid_t tid, 427 int uid, 428 status_t *status); 429 430 AudioStreamOut* getOutput() const; 431 AudioStreamOut* clearOutput(); 432 virtual audio_stream_t* stream() const; 433 434 // a very large number of suspend() will eventually wraparound, but unlikely 435 void suspend() { (void) android_atomic_inc(&mSuspended); } 436 void restore() 437 { 438 // if restore() is done without suspend(), get back into 439 // range so that the next suspend() will operate correctly 440 if (android_atomic_dec(&mSuspended) <= 0) { 441 android_atomic_release_store(0, &mSuspended); 442 } 443 } 444 bool isSuspended() const 445 { return android_atomic_acquire_load(&mSuspended) > 0; } 446 447 virtual String8 getParameters(const String8& keys); 448 virtual void audioConfigChanged_l(int event, int param = 0); 449 status_t getRenderPosition(size_t *halFrames, size_t *dspFrames); 450 int16_t *mixBuffer() const { return mMixBuffer; }; 451 452 virtual void detachAuxEffect_l(int effectId); 453 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, 454 int EffectId); 455 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, 456 int EffectId); 457 458 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 459 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 460 virtual uint32_t hasAudioSession(int sessionId) const; 461 virtual uint32_t getStrategyForSession_l(int sessionId); 462 463 464 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 465 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 466 467 // called with AudioFlinger lock held 468 void invalidateTracks(audio_stream_type_t streamType); 469 470 virtual size_t frameCount() const { return mNormalFrameCount; } 471 472 // Return's the HAL's frame count i.e. fast mixer buffer size. 473 size_t frameCountHAL() const { return mFrameCount; } 474 475 status_t getTimestamp_l(AudioTimestamp& timestamp); 476 477 protected: 478 // updated by readOutputParameters() 479 size_t mNormalFrameCount; // normal mixer and effects 480 481 int16_t* mMixBuffer; // frame size aligned mix buffer 482 int8_t* mAllocMixBuffer; // mixer buffer allocation address 483 484 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from 485 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle 486 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to 487 // workaround that restriction. 488 // 'volatile' means accessed via atomic operations and no lock. 489 volatile int32_t mSuspended; 490 491 // FIXME overflows every 6+ hours at 44.1 kHz stereo 16-bit samples 492 // mFramesWritten would be better, or 64-bit even better 493 size_t mBytesWritten; 494 private: 495 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a 496 // PlaybackThread needs to find out if master-muted, it checks it's local 497 // copy rather than the one in AudioFlinger. This optimization saves a lock. 498 bool mMasterMute; 499 void setMasterMute_l(bool muted) { mMasterMute = muted; } 500 protected: 501 SortedVector< wp<Track> > mActiveTracks; // FIXME check if this could be sp<> 502 SortedVector<int> mWakeLockUids; 503 int mActiveTracksGeneration; 504 wp<Track> mLatestActiveTrack; // latest track added to mActiveTracks 505 506 // Allocate a track name for a given channel mask. 507 // Returns name >= 0 if successful, -1 on failure. 508 virtual int getTrackName_l(audio_channel_mask_t channelMask, int sessionId) = 0; 509 virtual void deleteTrackName_l(int name) = 0; 510 511 // Time to sleep between cycles when: 512 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED 513 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE 514 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us 515 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write() 516 // No sleep in standby mode; waits on a condition 517 518 // Code snippets that are temporarily lifted up out of threadLoop() until the merge 519 void checkSilentMode_l(); 520 521 // Non-trivial for DUPLICATING only 522 virtual void saveOutputTracks() { } 523 virtual void clearOutputTracks() { } 524 525 // Cache various calculated values, at threadLoop() entry and after a parameter change 526 virtual void cacheParameters_l(); 527 528 virtual uint32_t correctLatency_l(uint32_t latency) const; 529 530 private: 531 532 friend class AudioFlinger; // for numerous 533 534 PlaybackThread(const Client&); 535 PlaybackThread& operator = (const PlaybackThread&); 536 537 status_t addTrack_l(const sp<Track>& track); 538 bool destroyTrack_l(const sp<Track>& track); 539 void removeTrack_l(const sp<Track>& track); 540 void broadcast_l(); 541 542 void readOutputParameters(); 543 544 virtual void dumpInternals(int fd, const Vector<String16>& args); 545 void dumpTracks(int fd, const Vector<String16>& args); 546 547 SortedVector< sp<Track> > mTracks; 548 // mStreamTypes[] uses 1 additional stream type internally for the OutputTrack used by 549 // DuplicatingThread 550 stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1]; 551 AudioStreamOut *mOutput; 552 553 float mMasterVolume; 554 nsecs_t mLastWriteTime; 555 int mNumWrites; 556 int mNumDelayedWrites; 557 bool mInWrite; 558 559 // FIXME rename these former local variables of threadLoop to standard "m" names 560 nsecs_t standbyTime; 561 size_t mixBufferSize; 562 563 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l() 564 uint32_t activeSleepTime; 565 uint32_t idleSleepTime; 566 567 uint32_t sleepTime; 568 569 // mixer status returned by prepareTracks_l() 570 mixer_state mMixerStatus; // current cycle 571 // previous cycle when in prepareTracks_l() 572 mixer_state mMixerStatusIgnoringFastTracks; 573 // FIXME or a separate ready state per track 574 575 // FIXME move these declarations into the specific sub-class that needs them 576 // MIXER only 577 uint32_t sleepTimeShift; 578 579 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value 580 nsecs_t standbyDelay; 581 582 // MIXER only 583 nsecs_t maxPeriod; 584 585 // DUPLICATING only 586 uint32_t writeFrames; 587 588 size_t mBytesRemaining; 589 size_t mCurrentWriteLength; 590 bool mUseAsyncWrite; 591 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is 592 // incremented each time a write(), a flush() or a standby() occurs. 593 // Bit 0 is set when a write blocks and indicates a callback is expected. 594 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence 595 // callbacks are ignored. 596 uint32_t mWriteAckSequence; 597 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is 598 // incremented each time a drain is requested or a flush() or standby() occurs. 599 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is 600 // expected. 601 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence 602 // callbacks are ignored. 603 uint32_t mDrainSequence; 604 // A condition that must be evaluated by prepareTrack_l() has changed and we must not wait 605 // for async write callback in the thread loop before evaluating it 606 bool mSignalPending; 607 sp<AsyncCallbackThread> mCallbackThread; 608 609 private: 610 // The HAL output sink is treated as non-blocking, but current implementation is blocking 611 sp<NBAIO_Sink> mOutputSink; 612 // If a fast mixer is present, the blocking pipe sink, otherwise clear 613 sp<NBAIO_Sink> mPipeSink; 614 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink 615 sp<NBAIO_Sink> mNormalSink; 616 #ifdef TEE_SINK 617 // For dumpsys 618 sp<NBAIO_Sink> mTeeSink; 619 sp<NBAIO_Source> mTeeSource; 620 #endif 621 uint32_t mScreenState; // cached copy of gScreenState 622 static const size_t kFastMixerLogSize = 4 * 1024; 623 sp<NBLog::Writer> mFastMixerNBLogWriter; 624 public: 625 virtual bool hasFastMixer() const = 0; 626 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const 627 { FastTrackUnderruns dummy; return dummy; } 628 629 protected: 630 // accessed by both binder threads and within threadLoop(), lock on mutex needed 631 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available 632 virtual void flushOutput_l(); 633 634 private: 635 // timestamp latch: 636 // D input is written by threadLoop_write while mutex is unlocked, and read while locked 637 // Q output is written while locked, and read while locked 638 struct { 639 AudioTimestamp mTimestamp; 640 uint32_t mUnpresentedFrames; 641 } mLatchD, mLatchQ; 642 bool mLatchDValid; // true means mLatchD is valid, and clock it into latch at next opportunity 643 bool mLatchQValid; // true means mLatchQ is valid 644 }; 645 646 class MixerThread : public PlaybackThread { 647 public: 648 MixerThread(const sp<AudioFlinger>& audioFlinger, 649 AudioStreamOut* output, 650 audio_io_handle_t id, 651 audio_devices_t device, 652 type_t type = MIXER); 653 virtual ~MixerThread(); 654 655 // Thread virtuals 656 657 virtual bool checkForNewParameters_l(); 658 virtual void dumpInternals(int fd, const Vector<String16>& args); 659 660 protected: 661 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 662 virtual int getTrackName_l(audio_channel_mask_t channelMask, int sessionId); 663 virtual void deleteTrackName_l(int name); 664 virtual uint32_t idleSleepTimeUs() const; 665 virtual uint32_t suspendSleepTimeUs() const; 666 virtual void cacheParameters_l(); 667 668 // threadLoop snippets 669 virtual ssize_t threadLoop_write(); 670 virtual void threadLoop_standby(); 671 virtual void threadLoop_mix(); 672 virtual void threadLoop_sleepTime(); 673 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove); 674 virtual uint32_t correctLatency_l(uint32_t latency) const; 675 676 AudioMixer* mAudioMixer; // normal mixer 677 private: 678 // one-time initialization, no locks required 679 FastMixer* mFastMixer; // non-NULL if there is also a fast mixer 680 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread 681 682 // contents are not guaranteed to be consistent, no locks required 683 FastMixerDumpState mFastMixerDumpState; 684 #ifdef STATE_QUEUE_DUMP 685 StateQueueObserverDump mStateQueueObserverDump; 686 StateQueueMutatorDump mStateQueueMutatorDump; 687 #endif 688 AudioWatchdogDump mAudioWatchdogDump; 689 690 // accessible only within the threadLoop(), no locks required 691 // mFastMixer->sq() // for mutating and pushing state 692 int32_t mFastMixerFutex; // for cold idle 693 694 public: 695 virtual bool hasFastMixer() const { return mFastMixer != NULL; } 696 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const { 697 ALOG_ASSERT(fastIndex < FastMixerState::kMaxFastTracks); 698 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns; 699 } 700 }; 701 702 class DirectOutputThread : public PlaybackThread { 703 public: 704 705 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 706 audio_io_handle_t id, audio_devices_t device); 707 virtual ~DirectOutputThread(); 708 709 // Thread virtuals 710 711 virtual bool checkForNewParameters_l(); 712 713 protected: 714 virtual int getTrackName_l(audio_channel_mask_t channelMask, int sessionId); 715 virtual void deleteTrackName_l(int name); 716 virtual uint32_t activeSleepTimeUs() const; 717 virtual uint32_t idleSleepTimeUs() const; 718 virtual uint32_t suspendSleepTimeUs() const; 719 virtual void cacheParameters_l(); 720 721 // threadLoop snippets 722 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 723 virtual void threadLoop_mix(); 724 virtual void threadLoop_sleepTime(); 725 726 // volumes last sent to audio HAL with stream->set_volume() 727 float mLeftVolFloat; 728 float mRightVolFloat; 729 730 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 731 audio_io_handle_t id, uint32_t device, ThreadBase::type_t type); 732 void processVolume_l(Track *track, bool lastTrack); 733 734 // prepareTracks_l() tells threadLoop_mix() the name of the single active track 735 sp<Track> mActiveTrack; 736 public: 737 virtual bool hasFastMixer() const { return false; } 738 }; 739 740 class OffloadThread : public DirectOutputThread { 741 public: 742 743 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 744 audio_io_handle_t id, uint32_t device); 745 virtual ~OffloadThread() {}; 746 747 protected: 748 // threadLoop snippets 749 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 750 virtual void threadLoop_exit(); 751 virtual void flushOutput_l(); 752 753 virtual bool waitingAsyncCallback(); 754 virtual bool waitingAsyncCallback_l(); 755 virtual bool shouldStandby_l(); 756 757 private: 758 void flushHw_l(); 759 760 private: 761 bool mHwPaused; 762 bool mFlushPending; 763 size_t mPausedWriteLength; // length in bytes of write interrupted by pause 764 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume 765 wp<Track> mPreviousTrack; // used to detect track switch 766 }; 767 768 class AsyncCallbackThread : public Thread { 769 public: 770 771 AsyncCallbackThread(const wp<PlaybackThread>& playbackThread); 772 773 virtual ~AsyncCallbackThread(); 774 775 // Thread virtuals 776 virtual bool threadLoop(); 777 778 // RefBase 779 virtual void onFirstRef(); 780 781 void exit(); 782 void setWriteBlocked(uint32_t sequence); 783 void resetWriteBlocked(); 784 void setDraining(uint32_t sequence); 785 void resetDraining(); 786 787 private: 788 const wp<PlaybackThread> mPlaybackThread; 789 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via 790 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used 791 // to indicate that the callback has been received via resetWriteBlocked() 792 uint32_t mWriteAckSequence; 793 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via 794 // setDraining(). The sequence is shifted one bit to the left and the lsb is used 795 // to indicate that the callback has been received via resetDraining() 796 uint32_t mDrainSequence; 797 Condition mWaitWorkCV; 798 Mutex mLock; 799 }; 800 801 class DuplicatingThread : public MixerThread { 802 public: 803 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, 804 audio_io_handle_t id); 805 virtual ~DuplicatingThread(); 806 807 // Thread virtuals 808 void addOutputTrack(MixerThread* thread); 809 void removeOutputTrack(MixerThread* thread); 810 uint32_t waitTimeMs() const { return mWaitTimeMs; } 811 protected: 812 virtual uint32_t activeSleepTimeUs() const; 813 814 private: 815 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks); 816 protected: 817 // threadLoop snippets 818 virtual void threadLoop_mix(); 819 virtual void threadLoop_sleepTime(); 820 virtual ssize_t threadLoop_write(); 821 virtual void threadLoop_standby(); 822 virtual void cacheParameters_l(); 823 824 private: 825 // called from threadLoop, addOutputTrack, removeOutputTrack 826 virtual void updateWaitTime_l(); 827 protected: 828 virtual void saveOutputTracks(); 829 virtual void clearOutputTracks(); 830 private: 831 832 uint32_t mWaitTimeMs; 833 SortedVector < sp<OutputTrack> > outputTracks; 834 SortedVector < sp<OutputTrack> > mOutputTracks; 835 public: 836 virtual bool hasFastMixer() const { return false; } 837 }; 838 839 840 // record thread 841 class RecordThread : public ThreadBase, public AudioBufferProvider 842 // derives from AudioBufferProvider interface for use by resampler 843 { 844 public: 845 846 #include "RecordTracks.h" 847 848 RecordThread(const sp<AudioFlinger>& audioFlinger, 849 AudioStreamIn *input, 850 uint32_t sampleRate, 851 audio_channel_mask_t channelMask, 852 audio_io_handle_t id, 853 audio_devices_t outDevice, 854 audio_devices_t inDevice 855 #ifdef TEE_SINK 856 , const sp<NBAIO_Sink>& teeSink 857 #endif 858 ); 859 virtual ~RecordThread(); 860 861 // no addTrack_l ? 862 void destroyTrack_l(const sp<RecordTrack>& track); 863 void removeTrack_l(const sp<RecordTrack>& track); 864 865 void dumpInternals(int fd, const Vector<String16>& args); 866 void dumpTracks(int fd, const Vector<String16>& args); 867 868 // Thread virtuals 869 virtual bool threadLoop(); 870 virtual status_t readyToRun(); 871 872 // RefBase 873 virtual void onFirstRef(); 874 875 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } 876 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( 877 const sp<AudioFlinger::Client>& client, 878 uint32_t sampleRate, 879 audio_format_t format, 880 audio_channel_mask_t channelMask, 881 size_t frameCount, 882 int sessionId, 883 int uid, 884 IAudioFlinger::track_flags_t *flags, 885 pid_t tid, 886 status_t *status); 887 888 status_t start(RecordTrack* recordTrack, 889 AudioSystem::sync_event_t event, 890 int triggerSession); 891 892 // ask the thread to stop the specified track, and 893 // return true if the caller should then do it's part of the stopping process 894 bool stop(RecordTrack* recordTrack); 895 896 void dump(int fd, const Vector<String16>& args); 897 AudioStreamIn* clearInput(); 898 virtual audio_stream_t* stream() const; 899 900 // AudioBufferProvider interface 901 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts); 902 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 903 904 virtual bool checkForNewParameters_l(); 905 virtual String8 getParameters(const String8& keys); 906 virtual void audioConfigChanged_l(int event, int param = 0); 907 void readInputParameters(); 908 virtual unsigned int getInputFramesLost(); 909 910 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 911 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 912 virtual uint32_t hasAudioSession(int sessionId) const; 913 914 // Return the set of unique session IDs across all tracks. 915 // The keys are the session IDs, and the associated values are meaningless. 916 // FIXME replace by Set [and implement Bag/Multiset for other uses]. 917 KeyedVector<int, bool> sessionIds() const; 918 919 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 920 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 921 922 static void syncStartEventCallback(const wp<SyncEvent>& event); 923 void handleSyncStartEvent(const sp<SyncEvent>& event); 924 925 virtual size_t frameCount() const { return mFrameCount; } 926 bool hasFastRecorder() const { return false; } 927 928 private: 929 void clearSyncStartEvent(); 930 931 // Enter standby if not already in standby, and set mStandby flag 932 void standby(); 933 934 // Call the HAL standby method unconditionally, and don't change mStandby flag 935 void inputStandBy(); 936 937 AudioStreamIn *mInput; 938 SortedVector < sp<RecordTrack> > mTracks; 939 // mActiveTrack has dual roles: it indicates the current active track, and 940 // is used together with mStartStopCond to indicate start()/stop() progress 941 sp<RecordTrack> mActiveTrack; 942 Condition mStartStopCond; 943 944 // updated by RecordThread::readInputParameters() 945 AudioResampler *mResampler; 946 // interleaved stereo pairs of fixed-point signed Q19.12 947 int32_t *mRsmpOutBuffer; 948 int16_t *mRsmpInBuffer; // [mFrameCount * mChannelCount] 949 size_t mRsmpInIndex; 950 size_t mBufferSize; // stream buffer size for read() 951 const uint32_t mReqChannelCount; 952 const uint32_t mReqSampleRate; 953 ssize_t mBytesRead; 954 // sync event triggering actual audio capture. Frames read before this event will 955 // be dropped and therefore not read by the application. 956 sp<SyncEvent> mSyncStartEvent; 957 // number of captured frames to drop after the start sync event has been received. 958 // when < 0, maximum frames to drop before starting capture even if sync event is 959 // not received 960 ssize_t mFramestoDrop; 961 962 // For dumpsys 963 const sp<NBAIO_Sink> mTeeSink; 964 }; 965
