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