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 MMAP_PLAYBACK, // Thread class for MMAP playback stream 34 MMAP_CAPTURE, // Thread class for MMAP capture stream 35 SPATIALIZER, // 36 // If you add any values here, also update ThreadBase::threadTypeToString() 37 }; 38 39 static const char *threadTypeToString(type_t type); 40 41 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 42 type_t type, bool systemReady, bool isOut); 43 virtual ~ThreadBase(); 44 45 virtual status_t readyToRun(); 46 47 void clearPowerManager(); 48 49 // base for record and playback 50 enum { 51 CFG_EVENT_IO, 52 CFG_EVENT_PRIO, 53 CFG_EVENT_SET_PARAMETER, 54 CFG_EVENT_CREATE_AUDIO_PATCH, 55 CFG_EVENT_RELEASE_AUDIO_PATCH, 56 CFG_EVENT_UPDATE_OUT_DEVICE, 57 CFG_EVENT_RESIZE_BUFFER, 58 CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS, 59 CFG_EVENT_HAL_LATENCY_MODES_CHANGED, 60 }; 61 62 class ConfigEventData: public RefBase { 63 public: ~ConfigEventData()64 virtual ~ConfigEventData() {} 65 66 virtual void dump(char *buffer, size_t size) = 0; 67 protected: ConfigEventData()68 ConfigEventData() {} 69 }; 70 71 // Config event sequence by client if status needed (e.g binder thread calling setParameters()): 72 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event 73 // 2. Lock mLock 74 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal 75 // 4. sendConfigEvent_l() reads status from event->mStatus; 76 // 5. sendConfigEvent_l() returns status 77 // 6. Unlock 78 // 79 // Parameter sequence by server: threadLoop calling processConfigEvents_l(): 80 // 1. Lock mLock 81 // 2. If there is an entry in mConfigEvents proceed ... 82 // 3. Read first entry in mConfigEvents 83 // 4. Remove first entry from mConfigEvents 84 // 5. Process 85 // 6. Set event->mStatus 86 // 7. event->mCond.signal 87 // 8. Unlock 88 89 class ConfigEvent: public RefBase { 90 public: ~ConfigEvent()91 virtual ~ConfigEvent() {} 92 dump(char * buffer,size_t size)93 void dump(char *buffer, size_t size) { 94 snprintf(buffer, size, "Event type: %d\n", mType); 95 if (mData != nullptr) { 96 snprintf(buffer, size, "Data:\n"); 97 mData->dump(buffer, size); 98 } 99 } 100 101 const int mType; // event type e.g. CFG_EVENT_IO 102 Mutex mLock; // mutex associated with mCond 103 Condition mCond; // condition for status return 104 status_t mStatus; // status communicated to sender 105 bool mWaitStatus; // true if sender is waiting for status 106 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue 107 sp<ConfigEventData> mData; // event specific parameter data 108 109 protected: 110 explicit ConfigEvent(int type, bool requiresSystemReady = false) : mType(type)111 mType(type), mStatus(NO_ERROR), mWaitStatus(false), 112 mRequiresSystemReady(requiresSystemReady), mData(NULL) {} 113 }; 114 115 class IoConfigEventData : public ConfigEventData { 116 public: IoConfigEventData(audio_io_config_event_t event,pid_t pid,audio_port_handle_t portId)117 IoConfigEventData(audio_io_config_event_t event, pid_t pid, 118 audio_port_handle_t portId) : 119 mEvent(event), mPid(pid), mPortId(portId) {} 120 dump(char * buffer,size_t size)121 virtual void dump(char *buffer, size_t size) { 122 snprintf(buffer, size, "- IO event: event %d\n", mEvent); 123 } 124 125 const audio_io_config_event_t mEvent; 126 const pid_t mPid; 127 const audio_port_handle_t mPortId; 128 }; 129 130 class IoConfigEvent : public ConfigEvent { 131 public: IoConfigEvent(audio_io_config_event_t event,pid_t pid,audio_port_handle_t portId)132 IoConfigEvent(audio_io_config_event_t event, pid_t pid, audio_port_handle_t portId) : 133 ConfigEvent(CFG_EVENT_IO) { 134 mData = new IoConfigEventData(event, pid, portId); 135 } ~IoConfigEvent()136 virtual ~IoConfigEvent() {} 137 }; 138 139 class PrioConfigEventData : public ConfigEventData { 140 public: PrioConfigEventData(pid_t pid,pid_t tid,int32_t prio,bool forApp)141 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) : 142 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {} 143 dump(char * buffer,size_t size)144 virtual void dump(char *buffer, size_t size) { 145 snprintf(buffer, size, "- Prio event: pid %d, tid %d, prio %d, for app? %d\n", 146 mPid, mTid, mPrio, mForApp); 147 } 148 149 const pid_t mPid; 150 const pid_t mTid; 151 const int32_t mPrio; 152 const bool mForApp; 153 }; 154 155 class PrioConfigEvent : public ConfigEvent { 156 public: PrioConfigEvent(pid_t pid,pid_t tid,int32_t prio,bool forApp)157 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) : 158 ConfigEvent(CFG_EVENT_PRIO, true) { 159 mData = new PrioConfigEventData(pid, tid, prio, forApp); 160 } ~PrioConfigEvent()161 virtual ~PrioConfigEvent() {} 162 }; 163 164 class SetParameterConfigEventData : public ConfigEventData { 165 public: SetParameterConfigEventData(String8 keyValuePairs)166 explicit SetParameterConfigEventData(String8 keyValuePairs) : 167 mKeyValuePairs(keyValuePairs) {} 168 dump(char * buffer,size_t size)169 virtual void dump(char *buffer, size_t size) { 170 snprintf(buffer, size, "- KeyValue: %s\n", mKeyValuePairs.string()); 171 } 172 173 const String8 mKeyValuePairs; 174 }; 175 176 class SetParameterConfigEvent : public ConfigEvent { 177 public: SetParameterConfigEvent(String8 keyValuePairs)178 explicit SetParameterConfigEvent(String8 keyValuePairs) : 179 ConfigEvent(CFG_EVENT_SET_PARAMETER) { 180 mData = new SetParameterConfigEventData(keyValuePairs); 181 mWaitStatus = true; 182 } ~SetParameterConfigEvent()183 virtual ~SetParameterConfigEvent() {} 184 }; 185 186 class CreateAudioPatchConfigEventData : public ConfigEventData { 187 public: CreateAudioPatchConfigEventData(const struct audio_patch patch,audio_patch_handle_t handle)188 CreateAudioPatchConfigEventData(const struct audio_patch patch, 189 audio_patch_handle_t handle) : 190 mPatch(patch), mHandle(handle) {} 191 dump(char * buffer,size_t size)192 virtual void dump(char *buffer, size_t size) { 193 snprintf(buffer, size, "- Patch handle: %u\n", mHandle); 194 } 195 196 const struct audio_patch mPatch; 197 audio_patch_handle_t mHandle; 198 }; 199 200 class CreateAudioPatchConfigEvent : public ConfigEvent { 201 public: CreateAudioPatchConfigEvent(const struct audio_patch patch,audio_patch_handle_t handle)202 CreateAudioPatchConfigEvent(const struct audio_patch patch, 203 audio_patch_handle_t handle) : 204 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) { 205 mData = new CreateAudioPatchConfigEventData(patch, handle); 206 mWaitStatus = true; 207 } ~CreateAudioPatchConfigEvent()208 virtual ~CreateAudioPatchConfigEvent() {} 209 }; 210 211 class ReleaseAudioPatchConfigEventData : public ConfigEventData { 212 public: ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle)213 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) : 214 mHandle(handle) {} 215 dump(char * buffer,size_t size)216 virtual void dump(char *buffer, size_t size) { 217 snprintf(buffer, size, "- Patch handle: %u\n", mHandle); 218 } 219 220 audio_patch_handle_t mHandle; 221 }; 222 223 class ReleaseAudioPatchConfigEvent : public ConfigEvent { 224 public: ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle)225 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) : 226 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) { 227 mData = new ReleaseAudioPatchConfigEventData(handle); 228 mWaitStatus = true; 229 } ~ReleaseAudioPatchConfigEvent()230 virtual ~ReleaseAudioPatchConfigEvent() {} 231 }; 232 233 class UpdateOutDevicesConfigEventData : public ConfigEventData { 234 public: UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector & outDevices)235 explicit UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector& outDevices) : 236 mOutDevices(outDevices) {} 237 dump(char * buffer,size_t size)238 virtual void dump(char *buffer, size_t size) { 239 snprintf(buffer, size, "- Devices: %s", android::toString(mOutDevices).c_str()); 240 } 241 242 DeviceDescriptorBaseVector mOutDevices; 243 }; 244 245 class UpdateOutDevicesConfigEvent : public ConfigEvent { 246 public: UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector & outDevices)247 explicit UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector& outDevices) : 248 ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) { 249 mData = new UpdateOutDevicesConfigEventData(outDevices); 250 } 251 252 virtual ~UpdateOutDevicesConfigEvent(); 253 }; 254 255 class ResizeBufferConfigEventData : public ConfigEventData { 256 public: ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs)257 explicit ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs) : 258 mMaxSharedAudioHistoryMs(maxSharedAudioHistoryMs) {} 259 dump(char * buffer,size_t size)260 virtual void dump(char *buffer, size_t size) { 261 snprintf(buffer, size, "- mMaxSharedAudioHistoryMs: %d", mMaxSharedAudioHistoryMs); 262 } 263 264 int32_t mMaxSharedAudioHistoryMs; 265 }; 266 267 class ResizeBufferConfigEvent : public ConfigEvent { 268 public: ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs)269 explicit ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs) : 270 ConfigEvent(CFG_EVENT_RESIZE_BUFFER) { 271 mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs); 272 } 273 ~ResizeBufferConfigEvent()274 virtual ~ResizeBufferConfigEvent() {} 275 }; 276 277 class CheckOutputStageEffectsEvent : public ConfigEvent { 278 public: CheckOutputStageEffectsEvent()279 CheckOutputStageEffectsEvent() : 280 ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) { 281 } 282 ~CheckOutputStageEffectsEvent()283 virtual ~CheckOutputStageEffectsEvent() {} 284 }; 285 286 class HalLatencyModesChangedEvent : public ConfigEvent { 287 public: HalLatencyModesChangedEvent()288 HalLatencyModesChangedEvent() : 289 ConfigEvent(CFG_EVENT_HAL_LATENCY_MODES_CHANGED) { 290 } 291 ~HalLatencyModesChangedEvent()292 virtual ~HalLatencyModesChangedEvent() {} 293 }; 294 295 296 class PMDeathRecipient : public IBinder::DeathRecipient { 297 public: PMDeathRecipient(const wp<ThreadBase> & thread)298 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} ~PMDeathRecipient()299 virtual ~PMDeathRecipient() {} 300 301 // IBinder::DeathRecipient 302 virtual void binderDied(const wp<IBinder>& who); 303 304 private: 305 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient); 306 307 wp<ThreadBase> mThread; 308 }; 309 310 virtual status_t initCheck() const = 0; 311 312 // static externally-visible type()313 type_t type() const { return mType; } isDuplicating()314 bool isDuplicating() const { return (mType == DUPLICATING); } 315 id()316 audio_io_handle_t id() const { return mId;} 317 318 // dynamic externally-visible sampleRate()319 uint32_t sampleRate() const { return mSampleRate; } channelMask()320 audio_channel_mask_t channelMask() const { return mChannelMask; } mixerChannelMask()321 virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; } 322 format()323 audio_format_t format() const { return mHALFormat; } channelCount()324 uint32_t channelCount() const { return mChannelCount; } 325 326 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects, 327 // and returns the [normal mix] buffer's frame count. 328 virtual size_t frameCount() const = 0; hapticChannelMask()329 virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; } latency_l()330 virtual uint32_t latency_l() const { return 0; } setVolumeForOutput_l(float left __unused,float right __unused)331 virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {} 332 333 // Return's the HAL's frame count i.e. fast mixer buffer size. frameCountHAL()334 size_t frameCountHAL() const { return mFrameCount; } 335 frameSize()336 size_t frameSize() const { return mFrameSize; } 337 338 // Should be "virtual status_t requestExitAndWait()" and override same 339 // method in Thread, but Thread::requestExitAndWait() is not yet virtual. 340 void exit(); 341 virtual bool checkForNewParameter_l(const String8& keyValuePair, 342 status_t& status) = 0; 343 virtual status_t setParameters(const String8& keyValuePairs); 344 virtual String8 getParameters(const String8& keys) = 0; 345 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0, 346 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0; 347 // sendConfigEvent_l() must be called with ThreadBase::mLock held 348 // Can temporarily release the lock if waiting for a reply from 349 // processConfigEvents_l(). 350 status_t sendConfigEvent_l(sp<ConfigEvent>& event); 351 void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0, 352 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 353 void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0, 354 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 355 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp); 356 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp); 357 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair); 358 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch, 359 audio_patch_handle_t *handle); 360 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle); 361 status_t sendUpdateOutDeviceConfigEvent( 362 const DeviceDescriptorBaseVector& outDevices); 363 void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs); 364 void sendCheckOutputStageEffectsEvent(); 365 void sendCheckOutputStageEffectsEvent_l(); 366 void sendHalLatencyModesChangedEvent_l(); 367 368 void processConfigEvents_l(); setCheckOutputStageEffects()369 virtual void setCheckOutputStageEffects() {} 370 virtual void cacheParameters_l() = 0; 371 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 372 audio_patch_handle_t *handle) = 0; 373 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0; 374 virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices); 375 virtual void toAudioPortConfig(struct audio_port_config *config) = 0; 376 377 virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs); onHalLatencyModesChanged_l()378 virtual void onHalLatencyModesChanged_l() {} 379 380 381 // see note at declaration of mStandby, mOutDevice and mInDevice standby()382 bool standby() const { return mStandby; } outDeviceTypes()383 const DeviceTypeSet outDeviceTypes() const { 384 return getAudioDeviceTypes(mOutDeviceTypeAddrs); 385 } inDeviceType()386 audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; } getDeviceTypes()387 DeviceTypeSet getDeviceTypes() const { 388 return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()}); 389 } 390 outDeviceTypeAddrs()391 const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const { 392 return mOutDeviceTypeAddrs; 393 } inDeviceTypeAddr()394 const AudioDeviceTypeAddr& inDeviceTypeAddr() const { 395 return mInDeviceTypeAddr; 396 } 397 isOutput()398 bool isOutput() const { return mIsOut; } 399 isOffloadOrMmap()400 bool isOffloadOrMmap() const { 401 switch (mType) { 402 case OFFLOAD: 403 case MMAP_PLAYBACK: 404 case MMAP_CAPTURE: 405 return true; 406 default: 407 return false; 408 } 409 } 410 411 virtual sp<StreamHalInterface> stream() const = 0; 412 413 sp<EffectHandle> createEffect_l( 414 const sp<AudioFlinger::Client>& client, 415 const sp<media::IEffectClient>& effectClient, 416 int32_t priority, 417 audio_session_t sessionId, 418 effect_descriptor_t *desc, 419 int *enabled, 420 status_t *status /*non-NULL*/, 421 bool pinned, 422 bool probe, 423 bool notifyFramesProcessed); 424 425 // return values for hasAudioSession (bit field) 426 enum effect_state { 427 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one 428 // effect 429 TRACK_SESSION = 0x2, // the audio session corresponds to at least one 430 // track 431 FAST_SESSION = 0x4, // the audio session corresponds to at least one 432 // fast track 433 SPATIALIZED_SESSION = 0x8 // the audio session corresponds to at least one 434 // spatialized track 435 }; 436 437 // get effect chain corresponding to session Id. 438 sp<EffectChain> getEffectChain(audio_session_t sessionId); 439 // same as getEffectChain() but must be called with ThreadBase mutex locked 440 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const; 441 std::vector<int> getEffectIds_l(audio_session_t sessionId); 442 // add an effect chain to the chain list (mEffectChains) 443 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; 444 // remove an effect chain from the chain list (mEffectChains) 445 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; 446 // lock all effect chains Mutexes. Must be called before releasing the 447 // ThreadBase mutex before processing the mixer and effects. This guarantees the 448 // integrity of the chains during the process. 449 // Also sets the parameter 'effectChains' to current value of mEffectChains. 450 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains); 451 // unlock effect chains after process 452 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains); 453 // get a copy of mEffectChains vector getEffectChains_l()454 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; }; 455 // set audio mode to all effect chains 456 void setMode(audio_mode_t mode); 457 // get effect module with corresponding ID on specified audio session 458 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId); 459 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId); 460 // add and effect module. Also creates the effect chain is none exists for 461 // the effects audio session. Only called in a context of moving an effect 462 // from one thread to another 463 status_t addEffect_l(const sp< EffectModule>& effect); 464 // remove and effect module. Also removes the effect chain is this was the last 465 // effect 466 void removeEffect_l(const sp< EffectModule>& effect, bool release = false); 467 // disconnect an effect handle from module and destroy module if last handle 468 void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast); 469 // detach all tracks connected to an auxiliary effect detachAuxEffect_l(int effectId __unused)470 virtual void detachAuxEffect_l(int effectId __unused) {} 471 // returns a combination of: 472 // - EFFECT_SESSION if effects on this audio session exist in one chain 473 // - TRACK_SESSION if tracks on this audio session exist 474 // - FAST_SESSION if fast tracks on this audio session exist 475 // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist 476 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0; hasAudioSession(audio_session_t sessionId)477 uint32_t hasAudioSession(audio_session_t sessionId) const { 478 Mutex::Autolock _l(mLock); 479 return hasAudioSession_l(sessionId); 480 } 481 482 template <typename T> hasAudioSession_l(audio_session_t sessionId,const T & tracks)483 uint32_t hasAudioSession_l(audio_session_t sessionId, const T& tracks) const { 484 uint32_t result = 0; 485 if (getEffectChain_l(sessionId) != 0) { 486 result = EFFECT_SESSION; 487 } 488 for (size_t i = 0; i < tracks.size(); ++i) { 489 const sp<TrackBase>& track = tracks[i]; 490 if (sessionId == track->sessionId() 491 && !track->isInvalid() // not yet removed from tracks. 492 && !track->isTerminated()) { 493 result |= TRACK_SESSION; 494 if (track->isFastTrack()) { 495 result |= FAST_SESSION; // caution, only represents first track. 496 } 497 if (track->isSpatialized()) { 498 result |= SPATIALIZED_SESSION; // caution, only first track. 499 } 500 break; 501 } 502 } 503 return result; 504 } 505 506 // the value returned by default implementation is not important as the 507 // strategy is only meaningful for PlaybackThread which implements this method getStrategyForSession_l(audio_session_t sessionId __unused)508 virtual product_strategy_t getStrategyForSession_l( 509 audio_session_t sessionId __unused) { 510 return static_cast<product_strategy_t>(0); 511 } 512 513 // check if some effects must be suspended/restored when an effect is enabled 514 // or disabled 515 void checkSuspendOnEffectEnabled(bool enabled, 516 audio_session_t sessionId, 517 bool threadLocked); 518 519 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0; 520 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0; 521 522 // Return a reference to a per-thread heap which can be used to allocate IMemory 523 // objects that will be read-only to client processes, read/write to mediaserver, 524 // and shared by all client processes of the thread. 525 // The heap is per-thread rather than common across all threads, because 526 // clients can't be trusted not to modify the offset of the IMemory they receive. 527 // If a thread does not have such a heap, this method returns 0. readOnlyHeap()528 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; } 529 pipeMemory()530 virtual sp<IMemory> pipeMemory() const { return 0; } 531 532 void systemReady(); 533 534 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held 535 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 536 audio_session_t sessionId) = 0; 537 538 void broadcast_l(); 539 isTimestampCorrectionEnabled()540 virtual bool isTimestampCorrectionEnabled() const { return false; } 541 isMsdDevice()542 bool isMsdDevice() const { return mIsMsdDevice; } 543 544 void dump(int fd, const Vector<String16>& args); 545 546 // deliver stats to mediametrics. 547 void sendStatistics(bool force); 548 549 mutable Mutex mLock; 550 551 void onEffectEnable(const sp<EffectModule>& effect); 552 void onEffectDisable(); 553 554 // invalidateTracksForAudioSession_l must be called with holding mLock. invalidateTracksForAudioSession_l(audio_session_t sessionId __unused)555 virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { } 556 // Invalidate all the tracks with the given audio session. invalidateTracksForAudioSession(audio_session_t sessionId)557 void invalidateTracksForAudioSession(audio_session_t sessionId) const { 558 Mutex::Autolock _l(mLock); 559 invalidateTracksForAudioSession_l(sessionId); 560 } 561 562 template <typename T> invalidateTracksForAudioSession_l(audio_session_t sessionId,const T & tracks)563 void invalidateTracksForAudioSession_l(audio_session_t sessionId, 564 const T& tracks) const { 565 for (size_t i = 0; i < tracks.size(); ++i) { 566 const sp<TrackBase>& track = tracks[i]; 567 if (sessionId == track->sessionId()) { 568 track->invalidate(); 569 } 570 } 571 } 572 573 virtual bool isStreamInitialized() = 0; 574 575 protected: 576 577 // entry describing an effect being suspended in mSuspendedSessions keyed vector 578 class SuspendedSessionDesc : public RefBase { 579 public: SuspendedSessionDesc()580 SuspendedSessionDesc() : mRefCount(0) {} 581 582 int mRefCount; // number of active suspend requests 583 effect_uuid_t mType; // effect type UUID 584 }; 585 586 void acquireWakeLock(); 587 virtual void acquireWakeLock_l(); 588 void releaseWakeLock(); 589 void releaseWakeLock_l(); 590 void updateWakeLockUids_l(const SortedVector<uid_t> &uids); 591 void getPowerManager_l(); 592 // suspend or restore effects of the specified type (or all if type is NULL) 593 // on a given session. The number of suspend requests is counted and restore 594 // occurs when all suspend requests are cancelled. 595 void setEffectSuspended_l(const effect_uuid_t *type, 596 bool suspend, 597 audio_session_t sessionId); 598 // updated mSuspendedSessions when an effect is suspended or restored 599 void updateSuspendedSessions_l(const effect_uuid_t *type, 600 bool suspend, 601 audio_session_t sessionId); 602 // check if some effects must be suspended when an effect chain is added 603 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); 604 605 // sends the metadata of the active tracks to the HAL 606 virtual void updateMetadata_l() = 0; 607 608 String16 getWakeLockTag(); 609 preExit()610 virtual void preExit() { } setMasterMono_l(bool mono __unused)611 virtual void setMasterMono_l(bool mono __unused) { } requireMonoBlend()612 virtual bool requireMonoBlend() { return false; } 613 614 // called within the threadLoop to obtain timestamp from the HAL. threadloop_getHalTimestamp_l(ExtendedTimestamp * timestamp __unused)615 virtual status_t threadloop_getHalTimestamp_l( 616 ExtendedTimestamp *timestamp __unused) const { 617 return INVALID_OPERATION; 618 } 619 620 product_strategy_t getStrategyForStream(audio_stream_type_t stream) const; 621 dumpInternals_l(int fd __unused,const Vector<String16> & args __unused)622 virtual void dumpInternals_l(int fd __unused, const Vector<String16>& args __unused) 623 { } dumpTracks_l(int fd __unused,const Vector<String16> & args __unused)624 virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { } 625 626 627 friend class AudioFlinger; // for mEffectChains 628 629 const type_t mType; 630 631 // Used by parameters, config events, addTrack_l, exit 632 Condition mWaitWorkCV; 633 634 const sp<AudioFlinger> mAudioFlinger; 635 ThreadMetrics mThreadMetrics; 636 const bool mIsOut; 637 638 // updated by PlaybackThread::readOutputParameters_l() or 639 // RecordThread::readInputParameters_l() 640 uint32_t mSampleRate; 641 size_t mFrameCount; // output HAL, direct output, record 642 audio_channel_mask_t mChannelMask; 643 uint32_t mChannelCount; 644 size_t mFrameSize; 645 // not HAL frame size, this is for output sink (to pipe to fast mixer) 646 audio_format_t mFormat; // Source format for Recording and 647 // Sink format for Playback. 648 // Sink format may be different than 649 // HAL format if Fastmixer is used. 650 audio_format_t mHALFormat; 651 size_t mBufferSize; // HAL buffer size for read() or write() 652 AudioDeviceTypeAddrVector mOutDeviceTypeAddrs; // output device types and addresses 653 AudioDeviceTypeAddr mInDeviceTypeAddr; // input device type and address 654 Vector< sp<ConfigEvent> > mConfigEvents; 655 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready 656 657 // These fields are written and read by thread itself without lock or barrier, 658 // and read by other threads without lock or barrier via standby(), outDeviceTypes() 659 // and inDeviceType(). 660 // Because of the absence of a lock or barrier, any other thread that reads 661 // these fields must use the information in isolation, or be prepared to deal 662 // with possibility that it might be inconsistent with other information. 663 bool mStandby; // Whether thread is currently in standby. 664 665 struct audio_patch mPatch; 666 667 audio_source_t mAudioSource; 668 669 const audio_io_handle_t mId; 670 Vector< sp<EffectChain> > mEffectChains; 671 672 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit 673 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated 674 sp<os::IPowerManager> mPowerManager; 675 sp<IBinder> mWakeLockToken; 676 const sp<PMDeathRecipient> mDeathRecipient; 677 // list of suspended effects per session and per type. The first (outer) vector is 678 // keyed by session ID, the second (inner) by type UUID timeLow field 679 // Updated by updateSuspendedSessions_l() only. 680 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > > 681 mSuspendedSessions; 682 // TODO: add comment and adjust size as needed 683 static const size_t kLogSize = 4 * 1024; 684 sp<NBLog::Writer> mNBLogWriter; 685 bool mSystemReady; 686 ExtendedTimestamp mTimestamp; 687 TimestampVerifier< // For timestamp statistics. 688 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier; 689 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush 690 // TODO: add confirmation checks: 691 // 1) DIRECT threads and linear PCM format really resets to 0? 692 // 2) Is frame count really valid if not linear pcm? 693 // 3) Are all 64 bits of position returned, not just lowest 32 bits? 694 // Timestamp corrected device should be a single device. 695 audio_devices_t mTimestampCorrectedDevice = AUDIO_DEVICE_NONE; 696 697 // ThreadLoop statistics per iteration. 698 int64_t mLastIoBeginNs = -1; 699 int64_t mLastIoEndNs = -1; 700 701 // ThreadSnapshot is thread-safe (internally locked) 702 mediautils::ThreadSnapshot mThreadSnapshot; 703 704 // This should be read under ThreadBase lock (if not on the threadLoop thread). 705 audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */}; 706 audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */}; 707 audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */}; 708 audio_utils::Statistics<double> mMonopipePipeDepthStats{0.999 /* alpha */}; 709 710 // Save the last count when we delivered statistics to mediametrics. 711 int64_t mLastRecordedTimestampVerifierN = 0; 712 int64_t mLastRecordedTimeNs = 0; // BOOTTIME to include suspend. 713 714 bool mIsMsdDevice = false; 715 // A condition that must be evaluated by the thread loop has changed and 716 // we must not wait for async write callback in the thread loop before evaluating it 717 bool mSignalPending; 718 719 #ifdef TEE_SINK 720 NBAIO_Tee mTee; 721 #endif 722 // ActiveTracks is a sorted vector of track type T representing the 723 // active tracks of threadLoop() to be considered by the locked prepare portion. 724 // ActiveTracks should be accessed with the ThreadBase lock held. 725 // 726 // During processing and I/O, the threadLoop does not hold the lock; 727 // hence it does not directly use ActiveTracks. Care should be taken 728 // to hold local strong references or defer removal of tracks 729 // if the threadLoop may still be accessing those tracks due to mix, etc. 730 // 731 // This class updates power information appropriately. 732 // 733 734 template <typename T> 735 class ActiveTracks { 736 public: 737 explicit ActiveTracks(SimpleLog *localLog = nullptr) 738 : mActiveTracksGeneration(0) 739 , mLastActiveTracksGeneration(0) 740 , mLocalLog(localLog) 741 { } 742 ~ActiveTracks()743 ~ActiveTracks() { 744 ALOGW_IF(!mActiveTracks.isEmpty(), 745 "ActiveTracks should be empty in destructor"); 746 } 747 // returns the last track added (even though it may have been 748 // subsequently removed from ActiveTracks). 749 // 750 // Used for DirectOutputThread to ensure a flush is called when transitioning 751 // to a new track (even though it may be on the same session). 752 // Used for OffloadThread to ensure that volume and mixer state is 753 // taken from the latest track added. 754 // 755 // The latest track is saved with a weak pointer to prevent keeping an 756 // otherwise useless track alive. Thus the function will return nullptr 757 // if the latest track has subsequently been removed and destroyed. getLatest()758 sp<T> getLatest() { 759 return mLatestActiveTrack.promote(); 760 } 761 762 // SortedVector methods 763 ssize_t add(const sp<T> &track); 764 ssize_t remove(const sp<T> &track); size()765 size_t size() const { 766 return mActiveTracks.size(); 767 } isEmpty()768 bool isEmpty() const { 769 return mActiveTracks.isEmpty(); 770 } indexOf(const sp<T> & item)771 ssize_t indexOf(const sp<T>& item) { 772 return mActiveTracks.indexOf(item); 773 } 774 sp<T> operator[](size_t index) const { 775 return mActiveTracks[index]; 776 } begin()777 typename SortedVector<sp<T>>::iterator begin() { 778 return mActiveTracks.begin(); 779 } end()780 typename SortedVector<sp<T>>::iterator end() { 781 return mActiveTracks.end(); 782 } 783 784 // Due to Binder recursion optimization, clear() and updatePowerState() 785 // cannot be called from a Binder thread because they may call back into 786 // the original calling process (system server) for BatteryNotifier 787 // (which requires a Java environment that may not be present). 788 // Hence, call clear() and updatePowerState() only from the 789 // ThreadBase thread. 790 void clear(); 791 // periodically called in the threadLoop() to update power state uids. 792 void updatePowerState(sp<ThreadBase> thread, bool force = false); 793 794 /** @return true if one or move active tracks was added or removed since the 795 * last time this function was called or the vector was created. 796 * true if volume of one of active tracks was changed. 797 */ 798 bool readAndClearHasChanged(); 799 800 private: 801 void logTrack(const char *funcName, const sp<T> &track) const; 802 getWakeLockUids()803 SortedVector<uid_t> getWakeLockUids() { 804 SortedVector<uid_t> wakeLockUids; 805 for (const sp<T> &track : mActiveTracks) { 806 wakeLockUids.add(track->uid()); 807 } 808 return wakeLockUids; // moved by underlying SharedBuffer 809 } 810 811 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>> 812 mBatteryCounter; 813 SortedVector<sp<T>> mActiveTracks; 814 int mActiveTracksGeneration; 815 int mLastActiveTracksGeneration; 816 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks 817 SimpleLog * const mLocalLog; 818 // If the vector has changed since last call to readAndClearHasChanged 819 bool mHasChanged = false; 820 }; 821 822 SimpleLog mLocalLog; 823 824 private: 825 void dumpBase_l(int fd, const Vector<String16>& args); 826 void dumpEffectChains_l(int fd, const Vector<String16>& args); 827 }; 828 829 class VolumeInterface { 830 public: 831 ~VolumeInterface()832 virtual ~VolumeInterface() {} 833 834 virtual void setMasterVolume(float value) = 0; 835 virtual void setMasterMute(bool muted) = 0; 836 virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0; 837 virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0; 838 virtual float streamVolume(audio_stream_type_t stream) const = 0; 839 840 }; 841 842 // --- PlaybackThread --- 843 class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback, 844 public VolumeInterface, public StreamOutHalInterfaceEventCallback { 845 public: 846 847 #include "PlaybackTracks.h" 848 849 enum mixer_state { 850 MIXER_IDLE, // no active tracks 851 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready 852 MIXER_TRACKS_READY, // at least one active track, and at least one track has data 853 MIXER_DRAIN_TRACK, // drain currently playing track 854 MIXER_DRAIN_ALL, // fully drain the hardware 855 // standby mode does not have an enum value 856 // suspend by audio policy manager is orthogonal to mixer state 857 }; 858 859 // retry count before removing active track in case of underrun on offloaded thread: 860 // we need to make sure that AudioTrack client has enough time to send large buffers 861 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is 862 // handled for offloaded tracks 863 static const int8_t kMaxTrackRetriesOffload = 20; 864 static const int8_t kMaxTrackStartupRetriesOffload = 100; 865 static const int8_t kMaxTrackStopRetriesOffload = 2; 866 static constexpr uint32_t kMaxTracksPerUid = 40; 867 static constexpr size_t kMaxTracks = 256; 868 869 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise 870 // if delay is greater, the estimated time for timeLoopNextNs is reset. 871 // This allows for catch-up to be done for small delays, while resetting the estimate 872 // for initial conditions or large delays. 873 static const nsecs_t kMaxNextBufferDelayNs = 100000000; 874 875 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 876 audio_io_handle_t id, type_t type, bool systemReady, 877 audio_config_base_t *mixerConfig = nullptr); 878 virtual ~PlaybackThread(); 879 880 // Thread virtuals 881 virtual bool threadLoop(); 882 883 // RefBase 884 virtual void onFirstRef(); 885 886 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 887 audio_session_t sessionId); 888 889 protected: 890 // Code snippets that were lifted up out of threadLoop() 891 virtual void threadLoop_mix() = 0; 892 virtual void threadLoop_sleepTime() = 0; 893 virtual ssize_t threadLoop_write(); 894 virtual void threadLoop_drain(); 895 virtual void threadLoop_standby(); 896 virtual void threadLoop_exit(); 897 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove); 898 899 // prepareTracks_l reads and writes mActiveTracks, and returns 900 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller 901 // is responsible for clearing or destroying this Vector later on, when it 902 // is safe to do so. That will drop the final ref count and destroy the tracks. 903 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0; 904 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove); 905 status_t handleVoipVolume_l(float *volume); 906 907 // StreamOutHalInterfaceCallback implementation 908 virtual void onWriteReady(); 909 virtual void onDrainReady(); 910 virtual void onError(); 911 912 void resetWriteBlocked(uint32_t sequence); 913 void resetDraining(uint32_t sequence); 914 915 virtual bool waitingAsyncCallback(); 916 virtual bool waitingAsyncCallback_l(); 917 virtual bool shouldStandby_l(); 918 virtual void onAddNewTrack_l(); 919 void onAsyncError(); // error reported by AsyncCallbackThread 920 921 // StreamHalInterfaceCodecFormatCallback implementation 922 void onCodecFormatChanged( 923 const std::basic_string<uint8_t>& metadataBs) override; 924 925 // ThreadBase virtuals 926 virtual void preExit(); 927 keepWakeLock()928 virtual bool keepWakeLock() const { return true; } acquireWakeLock_l()929 virtual void acquireWakeLock_l() { 930 ThreadBase::acquireWakeLock_l(); 931 mActiveTracks.updatePowerState(this, true /* force */); 932 } 933 checkOutputStageEffects()934 virtual void checkOutputStageEffects() {} setHalLatencyMode_l()935 virtual void setHalLatencyMode_l() {} 936 937 938 void dumpInternals_l(int fd, const Vector<String16>& args) override; 939 void dumpTracks_l(int fd, const Vector<String16>& args) override; 940 941 public: 942 initCheck()943 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } 944 945 // return estimated latency in milliseconds, as reported by HAL 946 uint32_t latency() const; 947 // same, but lock must already be held 948 uint32_t latency_l() const override; 949 950 // VolumeInterface 951 virtual void setMasterVolume(float value); 952 virtual void setMasterBalance(float balance); 953 virtual void setMasterMute(bool muted); 954 virtual void setStreamVolume(audio_stream_type_t stream, float value); 955 virtual void setStreamMute(audio_stream_type_t stream, bool muted); 956 virtual float streamVolume(audio_stream_type_t stream) const; 957 958 void setVolumeForOutput_l(float left, float right) const override; 959 960 sp<Track> createTrack_l( 961 const sp<AudioFlinger::Client>& client, 962 audio_stream_type_t streamType, 963 const audio_attributes_t& attr, 964 uint32_t *sampleRate, 965 audio_format_t format, 966 audio_channel_mask_t channelMask, 967 size_t *pFrameCount, 968 size_t *pNotificationFrameCount, 969 uint32_t notificationsPerBuffer, 970 float speed, 971 const sp<IMemory>& sharedBuffer, 972 audio_session_t sessionId, 973 audio_output_flags_t *flags, 974 pid_t creatorPid, 975 const AttributionSourceState& attributionSource, 976 pid_t tid, 977 status_t *status /*non-NULL*/, 978 audio_port_handle_t portId, 979 const sp<media::IAudioTrackCallback>& callback, 980 bool isSpatialized); 981 982 AudioStreamOut* getOutput() const; 983 AudioStreamOut* clearOutput(); 984 virtual sp<StreamHalInterface> stream() const; 985 986 // a very large number of suspend() will eventually wraparound, but unlikely suspend()987 void suspend() { (void) android_atomic_inc(&mSuspended); } restore()988 void restore() 989 { 990 // if restore() is done without suspend(), get back into 991 // range so that the next suspend() will operate correctly 992 if (android_atomic_dec(&mSuspended) <= 0) { 993 android_atomic_release_store(0, &mSuspended); 994 } 995 } isSuspended()996 bool isSuspended() const 997 { return android_atomic_acquire_load(&mSuspended) > 0; } 998 999 virtual String8 getParameters(const String8& keys); 1000 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0, 1001 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 1002 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); 1003 // Consider also removing and passing an explicit mMainBuffer initialization 1004 // parameter to AF::PlaybackThread::Track::Track(). sinkBuffer()1005 effect_buffer_t *sinkBuffer() const { 1006 return reinterpret_cast<effect_buffer_t *>(mSinkBuffer); }; 1007 1008 virtual void detachAuxEffect_l(int effectId); 1009 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track, 1010 int EffectId); 1011 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track, 1012 int EffectId); 1013 1014 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 1015 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); hasAudioSession_l(audio_session_t sessionId)1016 uint32_t hasAudioSession_l(audio_session_t sessionId) const override { 1017 return ThreadBase::hasAudioSession_l(sessionId, mTracks); 1018 } 1019 virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId); 1020 1021 1022 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 1023 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 1024 1025 // called with AudioFlinger lock held 1026 bool invalidateTracks_l(audio_stream_type_t streamType); 1027 virtual void invalidateTracks(audio_stream_type_t streamType); 1028 frameCount()1029 virtual size_t frameCount() const { return mNormalFrameCount; } 1030 mixerChannelMask()1031 audio_channel_mask_t mixerChannelMask() const override { 1032 return mMixerChannelMask; 1033 } 1034 1035 status_t getTimestamp_l(AudioTimestamp& timestamp); 1036 1037 void addPatchTrack(const sp<PatchTrack>& track); 1038 void deletePatchTrack(const sp<PatchTrack>& track); 1039 1040 virtual void toAudioPortConfig(struct audio_port_config *config); 1041 1042 // Return the asynchronous signal wait time. computeWaitTimeNs_l()1043 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; } 1044 // returns true if the track is allowed to be added to the thread. isTrackAllowed_l(audio_channel_mask_t channelMask __unused,audio_format_t format __unused,audio_session_t sessionId __unused,uid_t uid)1045 virtual bool isTrackAllowed_l( 1046 audio_channel_mask_t channelMask __unused, 1047 audio_format_t format __unused, 1048 audio_session_t sessionId __unused, 1049 uid_t uid) const { 1050 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid 1051 && mTracks.size() < PlaybackThread::kMaxTracks; 1052 } 1053 isTimestampCorrectionEnabled()1054 bool isTimestampCorrectionEnabled() const override { 1055 return audio_is_output_devices(mTimestampCorrectedDevice) 1056 && outDeviceTypes().count(mTimestampCorrectedDevice) != 0; 1057 } 1058 isStreamInitialized()1059 virtual bool isStreamInitialized() { 1060 return !(mOutput == nullptr || mOutput->stream == nullptr); 1061 } 1062 hapticChannelMask()1063 audio_channel_mask_t hapticChannelMask() const override { 1064 return mHapticChannelMask; 1065 } supportsHapticPlayback()1066 bool supportsHapticPlayback() const { 1067 return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE; 1068 } 1069 setDownStreamPatch(const struct audio_patch * patch)1070 void setDownStreamPatch(const struct audio_patch *patch) { 1071 Mutex::Autolock _l(mLock); 1072 mDownStreamPatch = *patch; 1073 } 1074 1075 PlaybackThread::Track* getTrackById_l(audio_port_handle_t trackId); 1076 hasMixer()1077 bool hasMixer() const { 1078 return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER; 1079 } 1080 setRequestedLatencyMode(audio_latency_mode_t mode __unused)1081 virtual status_t setRequestedLatencyMode( 1082 audio_latency_mode_t mode __unused) { return INVALID_OPERATION; } 1083 getSupportedLatencyModes(std::vector<audio_latency_mode_t> * modes __unused)1084 virtual status_t getSupportedLatencyModes( 1085 std::vector<audio_latency_mode_t>* modes __unused) { 1086 return INVALID_OPERATION; 1087 } 1088 1089 protected: 1090 // updated by readOutputParameters_l() 1091 size_t mNormalFrameCount; // normal mixer and effects 1092 1093 bool mThreadThrottle; // throttle the thread processing 1094 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads 1095 uint32_t mThreadThrottleEndMs; // notify once per throttling 1096 uint32_t mHalfBufferMs; // half the buffer size in milliseconds 1097 1098 void* mSinkBuffer; // frame size aligned sink buffer 1099 1100 // TODO: 1101 // Rearrange the buffer info into a struct/class with 1102 // clear, copy, construction, destruction methods. 1103 // 1104 // mSinkBuffer also has associated with it: 1105 // 1106 // mSinkBufferSize: Sink Buffer Size 1107 // mFormat: Sink Buffer Format 1108 1109 // Mixer Buffer (mMixerBuffer*) 1110 // 1111 // In the case of floating point or multichannel data, which is not in the 1112 // sink format, it is required to accumulate in a higher precision or greater channel count 1113 // buffer before downmixing or data conversion to the sink buffer. 1114 1115 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer. 1116 bool mMixerBufferEnabled; 1117 1118 // Storage, 32 byte aligned (may make this alignment a requirement later). 1119 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames. 1120 void* mMixerBuffer; 1121 1122 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize. 1123 size_t mMixerBufferSize; 1124 1125 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only. 1126 audio_format_t mMixerBufferFormat; 1127 1128 // An internal flag set to true by MixerThread::prepareTracks_l() 1129 // when mMixerBuffer contains valid data after mixing. 1130 bool mMixerBufferValid; 1131 1132 // Effects Buffer (mEffectsBuffer*) 1133 // 1134 // In the case of effects data, which is not in the sink format, 1135 // it is required to accumulate in a different buffer before data conversion 1136 // to the sink buffer. 1137 1138 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer. 1139 bool mEffectBufferEnabled; 1140 1141 // Storage, 32 byte aligned (may make this alignment a requirement later). 1142 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames. 1143 void* mEffectBuffer; 1144 1145 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize. 1146 size_t mEffectBufferSize; 1147 1148 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only. 1149 audio_format_t mEffectBufferFormat; 1150 1151 // An internal flag set to true by MixerThread::prepareTracks_l() 1152 // when mEffectsBuffer contains valid data after mixing. 1153 // 1154 // When this is set, all mixer data is routed into the effects buffer 1155 // for any processing (including output processing). 1156 bool mEffectBufferValid; 1157 1158 // Frame size aligned buffer used as input and output to all post processing effects 1159 // except the Spatializer in a SPATIALIZER thread. Non spatialized tracks are mixed into 1160 // this buffer so that post processing effects can be applied. 1161 void* mPostSpatializerBuffer = nullptr; 1162 1163 // Size of mPostSpatializerBuffer in bytes 1164 size_t mPostSpatializerBufferSize; 1165 1166 1167 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from 1168 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle 1169 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to 1170 // workaround that restriction. 1171 // 'volatile' means accessed via atomic operations and no lock. 1172 volatile int32_t mSuspended; 1173 1174 int64_t mBytesWritten; 1175 std::atomic<int64_t> mFramesWritten; // not reset on standby 1176 int64_t mLastFramesWritten = -1; // track changes in timestamp 1177 // server frames written. 1178 int64_t mSuspendedFrames; // not reset on standby 1179 1180 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support 1181 // haptic playback. 1182 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE; 1183 uint32_t mHapticChannelCount = 0; 1184 1185 audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE; 1186 1187 private: 1188 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a 1189 // PlaybackThread needs to find out if master-muted, it checks it's local 1190 // copy rather than the one in AudioFlinger. This optimization saves a lock. 1191 bool mMasterMute; setMasterMute_l(bool muted)1192 void setMasterMute_l(bool muted) { mMasterMute = muted; } 1193 discontinuityForStandbyOrFlush()1194 auto discontinuityForStandbyOrFlush() const { // call on threadLoop or with lock. 1195 return ((mType == DIRECT && !audio_is_linear_pcm(mFormat)) 1196 || mType == OFFLOAD) 1197 ? mTimestampVerifier.DISCONTINUITY_MODE_ZERO 1198 : mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS; 1199 } 1200 1201 protected: 1202 ActiveTracks<Track> mActiveTracks; 1203 1204 // Time to sleep between cycles when: 1205 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED 1206 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE 1207 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us 1208 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write() 1209 // No sleep in standby mode; waits on a condition 1210 1211 // Code snippets that are temporarily lifted up out of threadLoop() until the merge 1212 void checkSilentMode_l(); 1213 1214 // Non-trivial for DUPLICATING only saveOutputTracks()1215 virtual void saveOutputTracks() { } clearOutputTracks()1216 virtual void clearOutputTracks() { } 1217 1218 // Cache various calculated values, at threadLoop() entry and after a parameter change 1219 virtual void cacheParameters_l(); setCheckOutputStageEffects()1220 void setCheckOutputStageEffects() override { 1221 mCheckOutputStageEffects.store(true); 1222 } 1223 1224 virtual uint32_t correctLatency_l(uint32_t latency) const; 1225 1226 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1227 audio_patch_handle_t *handle); 1228 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1229 usesHwAvSync()1230 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL) 1231 && mHwSupportsPause 1232 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); } 1233 1234 uint32_t trackCountForUid_l(uid_t uid) const; 1235 invalidateTracksForAudioSession_l(audio_session_t sessionId)1236 void invalidateTracksForAudioSession_l( 1237 audio_session_t sessionId) const override { 1238 ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks); 1239 } 1240 1241 private: 1242 1243 friend class AudioFlinger; // for numerous 1244 1245 DISALLOW_COPY_AND_ASSIGN(PlaybackThread); 1246 1247 status_t addTrack_l(const sp<Track>& track); 1248 bool destroyTrack_l(const sp<Track>& track); 1249 void removeTrack_l(const sp<Track>& track); 1250 1251 void readOutputParameters_l(); 1252 void updateMetadata_l() final; 1253 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata); 1254 1255 void collectTimestamps_l(); 1256 1257 // The Tracks class manages tracks added and removed from the Thread. 1258 template <typename T> 1259 class Tracks { 1260 public: Tracks(bool saveDeletedTrackIds)1261 Tracks(bool saveDeletedTrackIds) : 1262 mSaveDeletedTrackIds(saveDeletedTrackIds) { } 1263 1264 // SortedVector methods add(const sp<T> & track)1265 ssize_t add(const sp<T> &track) { 1266 const ssize_t index = mTracks.add(track); 1267 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track"); 1268 return index; 1269 } 1270 ssize_t remove(const sp<T> &track); size()1271 size_t size() const { 1272 return mTracks.size(); 1273 } isEmpty()1274 bool isEmpty() const { 1275 return mTracks.isEmpty(); 1276 } indexOf(const sp<T> & item)1277 ssize_t indexOf(const sp<T> &item) { 1278 return mTracks.indexOf(item); 1279 } 1280 sp<T> operator[](size_t index) const { 1281 return mTracks[index]; 1282 } begin()1283 typename SortedVector<sp<T>>::iterator begin() { 1284 return mTracks.begin(); 1285 } end()1286 typename SortedVector<sp<T>>::iterator end() { 1287 return mTracks.end(); 1288 } 1289 processDeletedTrackIds(std::function<void (int)> f)1290 size_t processDeletedTrackIds(std::function<void(int)> f) { 1291 for (const int trackId : mDeletedTrackIds) { 1292 f(trackId); 1293 } 1294 return mDeletedTrackIds.size(); 1295 } 1296 clearDeletedTrackIds()1297 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); } 1298 1299 private: 1300 // Tracks pending deletion for MIXER type threads 1301 const bool mSaveDeletedTrackIds; // true to enable tracking 1302 std::set<int> mDeletedTrackIds; 1303 1304 SortedVector<sp<T>> mTracks; // wrapped SortedVector. 1305 }; 1306 1307 Tracks<Track> mTracks; 1308 1309 stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; 1310 AudioStreamOut *mOutput; 1311 1312 float mMasterVolume; 1313 std::atomic<float> mMasterBalance{}; 1314 audio_utils::Balance mBalance; 1315 int mNumWrites; 1316 int mNumDelayedWrites; 1317 bool mInWrite; 1318 1319 // FIXME rename these former local variables of threadLoop to standard "m" names 1320 nsecs_t mStandbyTimeNs; 1321 size_t mSinkBufferSize; 1322 1323 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l() 1324 uint32_t mActiveSleepTimeUs; 1325 uint32_t mIdleSleepTimeUs; 1326 1327 uint32_t mSleepTimeUs; 1328 1329 // mixer status returned by prepareTracks_l() 1330 mixer_state mMixerStatus; // current cycle 1331 // previous cycle when in prepareTracks_l() 1332 mixer_state mMixerStatusIgnoringFastTracks; 1333 // FIXME or a separate ready state per track 1334 1335 // FIXME move these declarations into the specific sub-class that needs them 1336 // MIXER only 1337 uint32_t sleepTimeShift; 1338 1339 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value 1340 nsecs_t mStandbyDelayNs; 1341 1342 // MIXER only 1343 nsecs_t maxPeriod; 1344 1345 // DUPLICATING only 1346 uint32_t writeFrames; 1347 1348 size_t mBytesRemaining; 1349 size_t mCurrentWriteLength; 1350 bool mUseAsyncWrite; 1351 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is 1352 // incremented each time a write(), a flush() or a standby() occurs. 1353 // Bit 0 is set when a write blocks and indicates a callback is expected. 1354 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence 1355 // callbacks are ignored. 1356 uint32_t mWriteAckSequence; 1357 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is 1358 // incremented each time a drain is requested or a flush() or standby() occurs. 1359 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is 1360 // expected. 1361 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence 1362 // callbacks are ignored. 1363 uint32_t mDrainSequence; 1364 sp<AsyncCallbackThread> mCallbackThread; 1365 1366 Mutex mAudioTrackCbLock; 1367 // Record of IAudioTrackCallback 1368 std::map<sp<Track>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks; 1369 1370 private: 1371 // The HAL output sink is treated as non-blocking, but current implementation is blocking 1372 sp<NBAIO_Sink> mOutputSink; 1373 // If a fast mixer is present, the blocking pipe sink, otherwise clear 1374 sp<NBAIO_Sink> mPipeSink; 1375 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink 1376 sp<NBAIO_Sink> mNormalSink; 1377 uint32_t mScreenState; // cached copy of gScreenState 1378 // TODO: add comment and adjust size as needed 1379 static const size_t kFastMixerLogSize = 8 * 1024; 1380 sp<NBLog::Writer> mFastMixerNBLogWriter; 1381 1382 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0. 1383 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999}; 1384 1385 public: 1386 virtual bool hasFastMixer() const = 0; getFastTrackUnderruns(size_t fastIndex __unused)1387 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const 1388 { FastTrackUnderruns dummy; return dummy; } framesWritten()1389 const std::atomic<int64_t>& framesWritten() const { return mFramesWritten; } 1390 1391 protected: 1392 // accessed by both binder threads and within threadLoop(), lock on mutex needed 1393 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available 1394 bool mHwSupportsPause; 1395 bool mHwPaused; 1396 bool mFlushPending; 1397 // volumes last sent to audio HAL with stream->setVolume() 1398 float mLeftVolFloat; 1399 float mRightVolFloat; 1400 1401 // audio patch used by the downstream software patch. 1402 // Only used if ThreadBase::mIsMsdDevice is true. 1403 struct audio_patch mDownStreamPatch; 1404 1405 std::atomic_bool mCheckOutputStageEffects{}; 1406 1407 1408 // Provides periodic checking for timestamp advancement for underrun detection. 1409 class IsTimestampAdvancing { 1410 public: 1411 // The timestamp will not be checked any faster than the specified time. IsTimestampAdvancing(nsecs_t minimumTimeBetweenChecksNs)1412 IsTimestampAdvancing(nsecs_t minimumTimeBetweenChecksNs) 1413 : mMinimumTimeBetweenChecksNs(minimumTimeBetweenChecksNs) 1414 { 1415 clear(); 1416 } 1417 // Check if the presentation position has advanced in the last periodic time. 1418 bool check(AudioStreamOut * output); 1419 // Clear the internal state when the playback state changes for the output 1420 // stream. 1421 void clear(); 1422 private: 1423 // The minimum time between timestamp checks. 1424 const nsecs_t mMinimumTimeBetweenChecksNs; 1425 // Add differential check on the timestamps to see if there is a change in the 1426 // timestamp frame position between the last call to check. 1427 uint64_t mPreviousPosition; 1428 // The time at which the last check occurred, to ensure we don't check too 1429 // frequently, giving the Audio HAL enough time to update its timestamps. 1430 nsecs_t mPreviousNs; 1431 // The valued is latched so we don't check timestamps too frequently. 1432 bool mLatchedValue; 1433 }; 1434 IsTimestampAdvancing mIsTimestampAdvancing; 1435 flushHw_l()1436 virtual void flushHw_l() { 1437 mIsTimestampAdvancing.clear(); 1438 } 1439 }; 1440 1441 class MixerThread : public PlaybackThread { 1442 public: 1443 MixerThread(const sp<AudioFlinger>& audioFlinger, 1444 AudioStreamOut* output, 1445 audio_io_handle_t id, 1446 bool systemReady, 1447 type_t type = MIXER, 1448 audio_config_base_t *mixerConfig = nullptr); 1449 virtual ~MixerThread(); 1450 1451 // Thread virtuals 1452 1453 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1454 status_t& status); 1455 1456 virtual bool isTrackAllowed_l( 1457 audio_channel_mask_t channelMask, audio_format_t format, 1458 audio_session_t sessionId, uid_t uid) const override; 1459 protected: 1460 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1461 virtual uint32_t idleSleepTimeUs() const; 1462 virtual uint32_t suspendSleepTimeUs() const; 1463 virtual void cacheParameters_l(); 1464 acquireWakeLock_l()1465 virtual void acquireWakeLock_l() { 1466 PlaybackThread::acquireWakeLock_l(); 1467 if (hasFastMixer()) { 1468 mFastMixer->setBoottimeOffset( 1469 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]); 1470 } 1471 } 1472 1473 void dumpInternals_l(int fd, const Vector<String16>& args) override; 1474 1475 // threadLoop snippets 1476 virtual ssize_t threadLoop_write(); 1477 virtual void threadLoop_standby(); 1478 virtual void threadLoop_mix(); 1479 virtual void threadLoop_sleepTime(); 1480 virtual uint32_t correctLatency_l(uint32_t latency) const; 1481 1482 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1483 audio_patch_handle_t *handle); 1484 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1485 1486 AudioMixer* mAudioMixer; // normal mixer 1487 private: 1488 // one-time initialization, no locks required 1489 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer 1490 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread 1491 1492 // contents are not guaranteed to be consistent, no locks required 1493 FastMixerDumpState mFastMixerDumpState; 1494 #ifdef STATE_QUEUE_DUMP 1495 StateQueueObserverDump mStateQueueObserverDump; 1496 StateQueueMutatorDump mStateQueueMutatorDump; 1497 #endif 1498 AudioWatchdogDump mAudioWatchdogDump; 1499 1500 // accessible only within the threadLoop(), no locks required 1501 // mFastMixer->sq() // for mutating and pushing state 1502 int32_t mFastMixerFutex; // for cold idle 1503 1504 std::atomic_bool mMasterMono; 1505 public: hasFastMixer()1506 virtual bool hasFastMixer() const { return mFastMixer != 0; } getFastTrackUnderruns(size_t fastIndex)1507 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const { 1508 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks); 1509 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns; 1510 } 1511 threadloop_getHalTimestamp_l(ExtendedTimestamp * timestamp)1512 status_t threadloop_getHalTimestamp_l( 1513 ExtendedTimestamp *timestamp) const override { 1514 if (mNormalSink.get() != nullptr) { 1515 return mNormalSink->getTimestamp(*timestamp); 1516 } 1517 return INVALID_OPERATION; 1518 } 1519 1520 protected: setMasterMono_l(bool mono)1521 virtual void setMasterMono_l(bool mono) { 1522 mMasterMono.store(mono); 1523 if (mFastMixer != nullptr) { /* hasFastMixer() */ 1524 mFastMixer->setMasterMono(mMasterMono); 1525 } 1526 } 1527 // the FastMixer performs mono blend if it exists. 1528 // Blending with limiter is not idempotent, 1529 // and blending without limiter is idempotent but inefficient to do twice. requireMonoBlend()1530 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); } 1531 setMasterBalance(float balance)1532 void setMasterBalance(float balance) override { 1533 mMasterBalance.store(balance); 1534 if (hasFastMixer()) { 1535 mFastMixer->setMasterBalance(balance); 1536 } 1537 } 1538 }; 1539 1540 class DirectOutputThread : public PlaybackThread { 1541 public: 1542 DirectOutputThread(const sp<AudioFlinger> & audioFlinger,AudioStreamOut * output,audio_io_handle_t id,bool systemReady)1543 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1544 audio_io_handle_t id, bool systemReady) 1545 : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady) { } 1546 1547 virtual ~DirectOutputThread(); 1548 1549 status_t selectPresentation(int presentationId, int programId); 1550 1551 // Thread virtuals 1552 1553 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1554 status_t& status); 1555 1556 void flushHw_l() override; 1557 1558 void setMasterBalance(float balance) override; 1559 1560 protected: 1561 virtual uint32_t activeSleepTimeUs() const; 1562 virtual uint32_t idleSleepTimeUs() const; 1563 virtual uint32_t suspendSleepTimeUs() const; 1564 virtual void cacheParameters_l(); 1565 1566 void dumpInternals_l(int fd, const Vector<String16>& args) override; 1567 1568 // threadLoop snippets 1569 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1570 virtual void threadLoop_mix(); 1571 virtual void threadLoop_sleepTime(); 1572 virtual void threadLoop_exit(); 1573 virtual bool shouldStandby_l(); 1574 1575 virtual void onAddNewTrack_l(); 1576 1577 bool mVolumeShaperActive = false; 1578 1579 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1580 audio_io_handle_t id, ThreadBase::type_t type, bool systemReady); 1581 void processVolume_l(Track *track, bool lastTrack); 1582 1583 // prepareTracks_l() tells threadLoop_mix() the name of the single active track 1584 sp<Track> mActiveTrack; 1585 1586 wp<Track> mPreviousTrack; // used to detect track switch 1587 1588 // This must be initialized for initial condition of mMasterBalance = 0 (disabled). 1589 float mMasterBalanceLeft = 1.f; 1590 float mMasterBalanceRight = 1.f; 1591 1592 public: hasFastMixer()1593 virtual bool hasFastMixer() const { return false; } 1594 1595 virtual int64_t computeWaitTimeNs_l() const override; 1596 threadloop_getHalTimestamp_l(ExtendedTimestamp * timestamp)1597 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override { 1598 // For DIRECT and OFFLOAD threads, query the output sink directly. 1599 if (mOutput != nullptr) { 1600 uint64_t uposition64; 1601 struct timespec time; 1602 if (mOutput->getPresentationPosition( 1603 &uposition64, &time) == OK) { 1604 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] 1605 = (int64_t)uposition64; 1606 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] 1607 = audio_utils_ns_from_timespec(&time); 1608 return NO_ERROR; 1609 } 1610 } 1611 return INVALID_OPERATION; 1612 } 1613 }; 1614 1615 class OffloadThread : public DirectOutputThread { 1616 public: 1617 1618 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1619 audio_io_handle_t id, bool systemReady); ~OffloadThread()1620 virtual ~OffloadThread() {}; 1621 void flushHw_l() override; 1622 1623 protected: 1624 // threadLoop snippets 1625 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1626 virtual void threadLoop_exit(); 1627 1628 virtual bool waitingAsyncCallback(); 1629 virtual bool waitingAsyncCallback_l(); 1630 virtual void invalidateTracks(audio_stream_type_t streamType); 1631 keepWakeLock()1632 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); } 1633 1634 private: 1635 size_t mPausedWriteLength; // length in bytes of write interrupted by pause 1636 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume 1637 bool mKeepWakeLock; // keep wake lock while waiting for write callback 1638 }; 1639 1640 class AsyncCallbackThread : public Thread { 1641 public: 1642 1643 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread); 1644 1645 virtual ~AsyncCallbackThread(); 1646 1647 // Thread virtuals 1648 virtual bool threadLoop(); 1649 1650 // RefBase 1651 virtual void onFirstRef(); 1652 1653 void exit(); 1654 void setWriteBlocked(uint32_t sequence); 1655 void resetWriteBlocked(); 1656 void setDraining(uint32_t sequence); 1657 void resetDraining(); 1658 void setAsyncError(); 1659 1660 private: 1661 const wp<PlaybackThread> mPlaybackThread; 1662 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via 1663 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used 1664 // to indicate that the callback has been received via resetWriteBlocked() 1665 uint32_t mWriteAckSequence; 1666 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via 1667 // setDraining(). The sequence is shifted one bit to the left and the lsb is used 1668 // to indicate that the callback has been received via resetDraining() 1669 uint32_t mDrainSequence; 1670 Condition mWaitWorkCV; 1671 Mutex mLock; 1672 bool mAsyncError; 1673 }; 1674 1675 class DuplicatingThread : public MixerThread { 1676 public: 1677 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, 1678 audio_io_handle_t id, bool systemReady); 1679 virtual ~DuplicatingThread(); 1680 1681 // Thread virtuals 1682 void addOutputTrack(MixerThread* thread); 1683 void removeOutputTrack(MixerThread* thread); waitTimeMs()1684 uint32_t waitTimeMs() const { return mWaitTimeMs; } 1685 1686 void sendMetadataToBackend_l( 1687 const StreamOutHalInterface::SourceMetadata& metadata) override; 1688 protected: 1689 virtual uint32_t activeSleepTimeUs() const; 1690 void dumpInternals_l(int fd, const Vector<String16>& args) override; 1691 1692 private: 1693 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks); 1694 protected: 1695 // threadLoop snippets 1696 virtual void threadLoop_mix(); 1697 virtual void threadLoop_sleepTime(); 1698 virtual ssize_t threadLoop_write(); 1699 virtual void threadLoop_standby(); 1700 virtual void cacheParameters_l(); 1701 1702 private: 1703 // called from threadLoop, addOutputTrack, removeOutputTrack 1704 virtual void updateWaitTime_l(); 1705 protected: 1706 virtual void saveOutputTracks(); 1707 virtual void clearOutputTracks(); 1708 private: 1709 1710 uint32_t mWaitTimeMs; 1711 SortedVector < sp<OutputTrack> > outputTracks; 1712 SortedVector < sp<OutputTrack> > mOutputTracks; 1713 public: hasFastMixer()1714 virtual bool hasFastMixer() const { return false; } threadloop_getHalTimestamp_l(ExtendedTimestamp * timestamp)1715 status_t threadloop_getHalTimestamp_l( 1716 ExtendedTimestamp *timestamp) const override { 1717 if (mOutputTracks.size() > 0) { 1718 // forward the first OutputTrack's kernel information for timestamp. 1719 const ExtendedTimestamp trackTimestamp = 1720 mOutputTracks[0]->getClientProxyTimestamp(); 1721 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) { 1722 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = 1723 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]; 1724 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 1725 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]; 1726 return OK; // discard server timestamp - that's ignored. 1727 } 1728 } 1729 return INVALID_OPERATION; 1730 } 1731 }; 1732 1733 class SpatializerThread : public MixerThread, 1734 public StreamOutHalInterfaceLatencyModeCallback { 1735 public: 1736 SpatializerThread(const sp<AudioFlinger>& audioFlinger, 1737 AudioStreamOut* output, 1738 audio_io_handle_t id, 1739 bool systemReady, 1740 audio_config_base_t *mixerConfig); ~SpatializerThread()1741 ~SpatializerThread() override {} 1742 hasFastMixer()1743 bool hasFastMixer() const override { return false; } 1744 1745 status_t createAudioPatch_l(const struct audio_patch *patch, 1746 audio_patch_handle_t *handle) override; 1747 1748 // RefBase 1749 virtual void onFirstRef(); 1750 1751 // StreamOutHalInterfaceLatencyModeCallback 1752 void onRecommendedLatencyModeChanged(std::vector<audio_latency_mode_t> modes) override; 1753 1754 status_t setRequestedLatencyMode(audio_latency_mode_t mode) override; 1755 status_t getSupportedLatencyModes(std::vector<audio_latency_mode_t>* modes) override; 1756 1757 protected: 1758 void checkOutputStageEffects() override; 1759 void onHalLatencyModesChanged_l() override; 1760 void setHalLatencyMode_l() override; 1761 1762 private: 1763 void updateHalSupportedLatencyModes_l(); 1764 1765 // Support low latency mode by default as unless explicitly indicated by the audio HAL 1766 // we assume the audio path is compatible with the head tracking latency requirements 1767 std::vector<audio_latency_mode_t> mSupportedLatencyModes = {AUDIO_LATENCY_MODE_LOW}; 1768 // default to invalid value to force first update to the audio HAL 1769 audio_latency_mode_t mSetLatencyMode = 1770 (audio_latency_mode_t)AUDIO_LATENCY_MODE_INVALID; 1771 // Do not request a specific mode by default 1772 audio_latency_mode_t mRequestedLatencyMode = AUDIO_LATENCY_MODE_FREE; 1773 1774 sp<EffectHandle> mFinalDownMixer; 1775 }; 1776 1777 // record thread 1778 class RecordThread : public ThreadBase 1779 { 1780 public: 1781 1782 class RecordTrack; 1783 1784 /* The ResamplerBufferProvider is used to retrieve recorded input data from the 1785 * RecordThread. It maintains local state on the relative position of the read 1786 * position of the RecordTrack compared with the RecordThread. 1787 */ 1788 class ResamplerBufferProvider : public AudioBufferProvider 1789 { 1790 public: ResamplerBufferProvider(RecordTrack * recordTrack)1791 explicit ResamplerBufferProvider(RecordTrack* recordTrack) : 1792 mRecordTrack(recordTrack), 1793 mRsmpInUnrel(0), mRsmpInFront(0) { } ~ResamplerBufferProvider()1794 virtual ~ResamplerBufferProvider() { } 1795 1796 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer, 1797 // skipping any previous data read from the hal. 1798 virtual void reset(); 1799 1800 /* Synchronizes RecordTrack position with the RecordThread. 1801 * Calculates available frames and handle overruns if the RecordThread 1802 * has advanced faster than the ResamplerBufferProvider has retrieved data. 1803 * TODO: why not do this for every getNextBuffer? 1804 * 1805 * Parameters 1806 * framesAvailable: pointer to optional output size_t to store record track 1807 * frames available. 1808 * hasOverrun: pointer to optional boolean, returns true if track has overrun. 1809 */ 1810 1811 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL); 1812 1813 // AudioBufferProvider interface 1814 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 1815 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 1816 getFront()1817 int32_t getFront() const { return mRsmpInFront; } setFront(int32_t front)1818 void setFront(int32_t front) { mRsmpInFront = front; } 1819 private: 1820 RecordTrack * const mRecordTrack; 1821 size_t mRsmpInUnrel; // unreleased frames remaining from 1822 // most recent getNextBuffer 1823 // for debug only 1824 int32_t mRsmpInFront; // next available frame 1825 // rolling counter that is never cleared 1826 }; 1827 1828 #include "RecordTracks.h" 1829 1830 RecordThread(const sp<AudioFlinger>& audioFlinger, 1831 AudioStreamIn *input, 1832 audio_io_handle_t id, 1833 bool systemReady 1834 ); 1835 virtual ~RecordThread(); 1836 1837 // no addTrack_l ? 1838 void destroyTrack_l(const sp<RecordTrack>& track); 1839 void removeTrack_l(const sp<RecordTrack>& track); 1840 1841 // Thread virtuals 1842 virtual bool threadLoop(); 1843 virtual void preExit(); 1844 1845 // RefBase 1846 virtual void onFirstRef(); 1847 initCheck()1848 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } 1849 readOnlyHeap()1850 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; } 1851 pipeMemory()1852 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; } 1853 1854 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( 1855 const sp<AudioFlinger::Client>& client, 1856 const audio_attributes_t& attr, 1857 uint32_t *pSampleRate, 1858 audio_format_t format, 1859 audio_channel_mask_t channelMask, 1860 size_t *pFrameCount, 1861 audio_session_t sessionId, 1862 size_t *pNotificationFrameCount, 1863 pid_t creatorPid, 1864 const AttributionSourceState& attributionSource, 1865 audio_input_flags_t *flags, 1866 pid_t tid, 1867 status_t *status /*non-NULL*/, 1868 audio_port_handle_t portId, 1869 int32_t maxSharedAudioHistoryMs); 1870 1871 status_t start(RecordTrack* recordTrack, 1872 AudioSystem::sync_event_t event, 1873 audio_session_t triggerSession); 1874 1875 // ask the thread to stop the specified track, and 1876 // return true if the caller should then do it's part of the stopping process 1877 bool stop(RecordTrack* recordTrack); 1878 1879 AudioStreamIn* clearInput(); 1880 virtual sp<StreamHalInterface> stream() const; 1881 1882 1883 virtual bool checkForNewParameter_l(const String8& keyValuePair, 1884 status_t& status); cacheParameters_l()1885 virtual void cacheParameters_l() {} 1886 virtual String8 getParameters(const String8& keys); 1887 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0, 1888 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 1889 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 1890 audio_patch_handle_t *handle); 1891 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 1892 void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override; 1893 void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override; 1894 1895 void addPatchTrack(const sp<PatchRecord>& record); 1896 void deletePatchTrack(const sp<PatchRecord>& record); 1897 1898 void readInputParameters_l(); 1899 virtual uint32_t getInputFramesLost(); 1900 1901 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 1902 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); hasAudioSession_l(audio_session_t sessionId)1903 uint32_t hasAudioSession_l(audio_session_t sessionId) const override { 1904 return ThreadBase::hasAudioSession_l(sessionId, mTracks); 1905 } 1906 1907 // Return the set of unique session IDs across all tracks. 1908 // The keys are the session IDs, and the associated values are meaningless. 1909 // FIXME replace by Set [and implement Bag/Multiset for other uses]. 1910 KeyedVector<audio_session_t, bool> sessionIds() const; 1911 1912 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 1913 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 1914 1915 static void syncStartEventCallback(const wp<SyncEvent>& event); 1916 frameCount()1917 virtual size_t frameCount() const { return mFrameCount; } hasFastCapture()1918 bool hasFastCapture() const { return mFastCapture != 0; } 1919 virtual void toAudioPortConfig(struct audio_port_config *config); 1920 1921 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 1922 audio_session_t sessionId); 1923 acquireWakeLock_l()1924 virtual void acquireWakeLock_l() { 1925 ThreadBase::acquireWakeLock_l(); 1926 mActiveTracks.updatePowerState(this, true /* force */); 1927 } 1928 1929 void checkBtNrec(); 1930 1931 // Sets the UID records silence 1932 void setRecordSilenced(audio_port_handle_t portId, bool silenced); 1933 1934 status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones); 1935 1936 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction); 1937 status_t setPreferredMicrophoneFieldDimension(float zoom); 1938 1939 void updateMetadata_l() override; 1940 fastTrackAvailable()1941 bool fastTrackAvailable() const { return mFastTrackAvail; } 1942 isTimestampCorrectionEnabled()1943 bool isTimestampCorrectionEnabled() const override { 1944 // checks popcount for exactly one device. 1945 // Is currently disabled. Before enabling, 1946 // verify compressed record timestamps. 1947 return audio_is_input_device(mTimestampCorrectedDevice) 1948 && inDeviceType() == mTimestampCorrectedDevice; 1949 } 1950 1951 status_t shareAudioHistory(const std::string& sharedAudioPackageName, 1952 audio_session_t sharedSessionId = AUDIO_SESSION_NONE, 1953 int64_t sharedAudioStartMs = -1); 1954 status_t shareAudioHistory_l(const std::string& sharedAudioPackageName, 1955 audio_session_t sharedSessionId = AUDIO_SESSION_NONE, 1956 int64_t sharedAudioStartMs = -1); 1957 void resetAudioHistory_l(); 1958 isStreamInitialized()1959 virtual bool isStreamInitialized() { 1960 return !(mInput == nullptr || mInput->stream == nullptr); 1961 } 1962 1963 protected: 1964 void dumpInternals_l(int fd, const Vector<String16>& args) override; 1965 void dumpTracks_l(int fd, const Vector<String16>& args) override; 1966 1967 private: 1968 // Enter standby if not already in standby, and set mStandby flag 1969 void standbyIfNotAlreadyInStandby(); 1970 1971 // Call the HAL standby method unconditionally, and don't change mStandby flag 1972 void inputStandBy(); 1973 1974 void checkBtNrec_l(); 1975 1976 int32_t getOldestFront_l(); 1977 void updateFronts_l(int32_t offset); 1978 1979 AudioStreamIn *mInput; 1980 Source *mSource; 1981 SortedVector < sp<RecordTrack> > mTracks; 1982 // mActiveTracks has dual roles: it indicates the current active track(s), and 1983 // is used together with mStartStopCond to indicate start()/stop() progress 1984 ActiveTracks<RecordTrack> mActiveTracks; 1985 1986 Condition mStartStopCond; 1987 1988 // resampler converts input at HAL Hz to output at AudioRecord client Hz 1989 void *mRsmpInBuffer; // size = mRsmpInFramesOA 1990 size_t mRsmpInFrames; // size of resampler input in frames 1991 size_t mRsmpInFramesP2;// size rounded up to a power-of-2 1992 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation 1993 1994 // rolling index that is never cleared 1995 int32_t mRsmpInRear; // last filled frame + 1 1996 1997 // For dumpsys 1998 const sp<MemoryDealer> mReadOnlyHeap; 1999 2000 // one-time initialization, no locks required 2001 sp<FastCapture> mFastCapture; // non-0 if there is also 2002 // a fast capture 2003 2004 // FIXME audio watchdog thread 2005 2006 // contents are not guaranteed to be consistent, no locks required 2007 FastCaptureDumpState mFastCaptureDumpState; 2008 #ifdef STATE_QUEUE_DUMP 2009 // FIXME StateQueue observer and mutator dump fields 2010 #endif 2011 // FIXME audio watchdog dump 2012 2013 // accessible only within the threadLoop(), no locks required 2014 // mFastCapture->sq() // for mutating and pushing state 2015 int32_t mFastCaptureFutex; // for cold idle 2016 2017 // The HAL input source is treated as non-blocking, 2018 // but current implementation is blocking 2019 sp<NBAIO_Source> mInputSource; 2020 // The source for the normal capture thread to read from: mInputSource or mPipeSource 2021 sp<NBAIO_Source> mNormalSource; 2022 // If a fast capture is present, the non-blocking pipe sink written to by fast capture, 2023 // otherwise clear 2024 sp<NBAIO_Sink> mPipeSink; 2025 // If a fast capture is present, the non-blocking pipe source read by normal thread, 2026 // otherwise clear 2027 sp<NBAIO_Source> mPipeSource; 2028 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2 2029 size_t mPipeFramesP2; 2030 // If a fast capture is present, the Pipe as IMemory, otherwise clear 2031 sp<IMemory> mPipeMemory; 2032 2033 // TODO: add comment and adjust size as needed 2034 static const size_t kFastCaptureLogSize = 4 * 1024; 2035 sp<NBLog::Writer> mFastCaptureNBLogWriter; 2036 2037 bool mFastTrackAvail; // true if fast track available 2038 // common state to all record threads 2039 std::atomic_bool mBtNrecSuspended; 2040 2041 int64_t mFramesRead = 0; // continuous running counter. 2042 2043 DeviceDescriptorBaseVector mOutDevices; 2044 2045 int32_t mMaxSharedAudioHistoryMs = 0; 2046 std::string mSharedAudioPackageName = {}; 2047 int32_t mSharedAudioStartFrames = -1; 2048 audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE; 2049 }; 2050 2051 class MmapThread : public ThreadBase 2052 { 2053 public: 2054 2055 #include "MmapTracks.h" 2056 2057 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 2058 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, bool systemReady, 2059 bool isOut); 2060 virtual ~MmapThread(); 2061 2062 virtual void configure(const audio_attributes_t *attr, 2063 audio_stream_type_t streamType, 2064 audio_session_t sessionId, 2065 const sp<MmapStreamCallback>& callback, 2066 audio_port_handle_t deviceId, 2067 audio_port_handle_t portId); 2068 2069 void disconnect(); 2070 2071 // MmapStreamInterface 2072 status_t createMmapBuffer(int32_t minSizeFrames, 2073 struct audio_mmap_buffer_info *info); 2074 status_t getMmapPosition(struct audio_mmap_position *position); 2075 status_t start(const AudioClient& client, 2076 const audio_attributes_t *attr, 2077 audio_port_handle_t *handle); 2078 status_t stop(audio_port_handle_t handle); 2079 status_t standby(); 2080 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0; 2081 2082 // RefBase 2083 virtual void onFirstRef(); 2084 2085 // Thread virtuals 2086 virtual bool threadLoop(); 2087 2088 virtual void threadLoop_exit(); 2089 virtual void threadLoop_standby(); shouldStandby_l()2090 virtual bool shouldStandby_l() { return false; } 2091 virtual status_t exitStandby(); 2092 initCheck()2093 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; } frameCount()2094 virtual size_t frameCount() const { return mFrameCount; } 2095 virtual bool checkForNewParameter_l(const String8& keyValuePair, 2096 status_t& status); 2097 virtual String8 getParameters(const String8& keys); 2098 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0, 2099 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 2100 void readHalParameters_l(); cacheParameters_l()2101 virtual void cacheParameters_l() {} 2102 virtual status_t createAudioPatch_l(const struct audio_patch *patch, 2103 audio_patch_handle_t *handle); 2104 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle); 2105 virtual void toAudioPortConfig(struct audio_port_config *config); 2106 stream()2107 virtual sp<StreamHalInterface> stream() const { return mHalStream; } 2108 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 2109 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 2110 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc, 2111 audio_session_t sessionId); 2112 hasAudioSession_l(audio_session_t sessionId)2113 uint32_t hasAudioSession_l(audio_session_t sessionId) const override { 2114 // Note: using mActiveTracks as no mTracks here. 2115 return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks); 2116 } 2117 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 2118 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const; 2119 checkSilentMode_l()2120 virtual void checkSilentMode_l() {} processVolume_l()2121 virtual void processVolume_l() {} 2122 void checkInvalidTracks_l(); 2123 streamType()2124 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; } 2125 invalidateTracks(audio_stream_type_t streamType __unused)2126 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {} 2127 2128 // Sets the UID records silence setRecordSilenced(audio_port_handle_t portId __unused,bool silenced __unused)2129 virtual void setRecordSilenced(audio_port_handle_t portId __unused, 2130 bool silenced __unused) {} 2131 isStreamInitialized()2132 virtual bool isStreamInitialized() { return false; } 2133 setClientSilencedState_l(audio_port_handle_t portId,bool silenced)2134 void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) { 2135 mClientSilencedStates[portId] = silenced; 2136 } 2137 eraseClientSilencedState_l(audio_port_handle_t portId)2138 size_t eraseClientSilencedState_l(audio_port_handle_t portId) { 2139 return mClientSilencedStates.erase(portId); 2140 } 2141 isClientSilenced_l(audio_port_handle_t portId)2142 bool isClientSilenced_l(audio_port_handle_t portId) const { 2143 const auto it = mClientSilencedStates.find(portId); 2144 return it != mClientSilencedStates.end() ? it->second : false; 2145 } 2146 setClientSilencedIfExists_l(audio_port_handle_t portId,bool silenced)2147 void setClientSilencedIfExists_l(audio_port_handle_t portId, bool silenced) { 2148 const auto it = mClientSilencedStates.find(portId); 2149 if (it != mClientSilencedStates.end()) { 2150 it->second = silenced; 2151 } 2152 } 2153 2154 protected: 2155 void dumpInternals_l(int fd, const Vector<String16>& args) override; 2156 void dumpTracks_l(int fd, const Vector<String16>& args) override; 2157 2158 /** 2159 * @brief mDeviceId current device port unique identifier 2160 */ 2161 audio_port_handle_t mDeviceId = AUDIO_PORT_HANDLE_NONE; 2162 2163 audio_attributes_t mAttr; 2164 audio_session_t mSessionId; 2165 audio_port_handle_t mPortId; 2166 2167 wp<MmapStreamCallback> mCallback; 2168 sp<StreamHalInterface> mHalStream; 2169 sp<DeviceHalInterface> mHalDevice; 2170 AudioHwDevice* const mAudioHwDev; 2171 ActiveTracks<MmapTrack> mActiveTracks; 2172 float mHalVolFloat; 2173 std::map<audio_port_handle_t, bool> mClientSilencedStates; 2174 2175 int32_t mNoCallbackWarningCount; 2176 static constexpr int32_t kMaxNoCallbackWarnings = 5; 2177 }; 2178 2179 class MmapPlaybackThread : public MmapThread, public VolumeInterface 2180 { 2181 2182 public: 2183 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 2184 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady); ~MmapPlaybackThread()2185 virtual ~MmapPlaybackThread() {} 2186 2187 virtual void configure(const audio_attributes_t *attr, 2188 audio_stream_type_t streamType, 2189 audio_session_t sessionId, 2190 const sp<MmapStreamCallback>& callback, 2191 audio_port_handle_t deviceId, 2192 audio_port_handle_t portId); 2193 2194 AudioStreamOut* clearOutput(); 2195 2196 // VolumeInterface 2197 virtual void setMasterVolume(float value); 2198 virtual void setMasterMute(bool muted); 2199 virtual void setStreamVolume(audio_stream_type_t stream, float value); 2200 virtual void setStreamMute(audio_stream_type_t stream, bool muted); 2201 virtual float streamVolume(audio_stream_type_t stream) const; 2202 setMasterMute_l(bool muted)2203 void setMasterMute_l(bool muted) { mMasterMute = muted; } 2204 2205 virtual void invalidateTracks(audio_stream_type_t streamType); 2206 streamType()2207 virtual audio_stream_type_t streamType() { return mStreamType; } 2208 virtual void checkSilentMode_l(); 2209 void processVolume_l() override; 2210 2211 void updateMetadata_l() override; 2212 2213 virtual void toAudioPortConfig(struct audio_port_config *config); 2214 2215 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override; 2216 isStreamInitialized()2217 virtual bool isStreamInitialized() { 2218 return !(mOutput == nullptr || mOutput->stream == nullptr); 2219 } 2220 2221 protected: 2222 void dumpInternals_l(int fd, const Vector<String16>& args) override; 2223 2224 audio_stream_type_t mStreamType; 2225 float mMasterVolume; 2226 float mStreamVolume; 2227 bool mMasterMute; 2228 bool mStreamMute; 2229 AudioStreamOut* mOutput; 2230 }; 2231 2232 class MmapCaptureThread : public MmapThread 2233 { 2234 2235 public: 2236 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, 2237 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady); ~MmapCaptureThread()2238 virtual ~MmapCaptureThread() {} 2239 2240 AudioStreamIn* clearInput(); 2241 2242 status_t exitStandby() override; 2243 2244 void updateMetadata_l() override; 2245 void processVolume_l() override; 2246 void setRecordSilenced(audio_port_handle_t portId, 2247 bool silenced) override; 2248 2249 virtual void toAudioPortConfig(struct audio_port_config *config); 2250 2251 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override; 2252 isStreamInitialized()2253 virtual bool isStreamInitialized() { 2254 return !(mInput == nullptr || mInput->stream == nullptr); 2255 } 2256 2257 protected: 2258 2259 AudioStreamIn* mInput; 2260 }; 2261