1 /* 2 ** 3 ** Copyright 2007, 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 #pragma once 19 20 // Classes and interfaces directly used. 21 #include "Client.h" 22 #include "DeviceEffectManager.h" 23 #include "EffectConfiguration.h" 24 #include "IAfEffect.h" 25 #include "IAfPatchPanel.h" 26 #include "IAfThread.h" 27 #include "IAfTrack.h" 28 #include "MelReporter.h" 29 #include "PatchCommandThread.h" 30 #include "audio_utils/clock.h" 31 32 // External classes 33 #include <audio_utils/mutex.h> 34 #include <audio_utils/FdToString.h> 35 #include <audio_utils/SimpleLog.h> 36 #include <media/IAudioFlinger.h> 37 #include <media/IAudioPolicyServiceLocal.h> 38 #include <media/MediaMetricsItem.h> 39 #include <media/audiohal/DevicesFactoryHalInterface.h> 40 #include <mediautils/ServiceUtilities.h> 41 #include <mediautils/Synchronization.h> 42 #include <psh_utils/AudioPowerManager.h> 43 44 // not needed with the includes above, added to prevent transitive include dependency. 45 #include <utils/KeyedVector.h> 46 #include <utils/String16.h> 47 #include <atomic> 48 #include <functional> 49 #include <map> 50 #include <optional> 51 #include <set> 52 53 namespace android { 54 55 class AudioFlinger 56 : public AudioFlingerServerAdapter::Delegate // IAudioFlinger client interface 57 , public IAfClientCallback 58 , public IAfDeviceEffectManagerCallback 59 , public IAfMelReporterCallback 60 , public IAfPatchPanelCallback 61 , public IAfThreadCallback 62 { 63 friend class sp<AudioFlinger>; 64 public: 65 static void instantiate() ANDROID_API; 66 67 status_t resetReferencesForTest(); 68 69 // Called by main when startup finished -- for logging purposes only startupFinished()70 void startupFinished() { 71 mStartupFinishedTime.store(audio_utils_get_real_time_ns(), std::memory_order_release); 72 } 73 74 private: 75 76 // ---- begin IAudioFlinger interface 77 78 status_t dump(int fd, const Vector<String16>& args) final EXCLUDES_AudioFlinger_Mutex; 79 80 status_t createTrack(const media::CreateTrackRequest& input, 81 media::CreateTrackResponse& output) final EXCLUDES_AudioFlinger_Mutex; 82 83 status_t createRecord(const media::CreateRecordRequest& input, 84 media::CreateRecordResponse& output) final EXCLUDES_AudioFlinger_Mutex; 85 86 uint32_t sampleRate(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; 87 audio_format_t format(audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; 88 size_t frameCount(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; 89 size_t frameCountHAL(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; 90 uint32_t latency(audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; 91 92 status_t setMasterVolume(float value) final EXCLUDES_AudioFlinger_Mutex; 93 status_t setMasterMute(bool muted) final EXCLUDES_AudioFlinger_Mutex; 94 float masterVolume() const final EXCLUDES_AudioFlinger_Mutex; 95 bool masterMute() const final EXCLUDES_AudioFlinger_Mutex; 96 97 // Balance value must be within -1.f (left only) to 1.f (right only) inclusive. 98 status_t setMasterBalance(float balance) final EXCLUDES_AudioFlinger_Mutex; 99 status_t getMasterBalance(float* balance) const final EXCLUDES_AudioFlinger_Mutex; 100 101 status_t setStreamVolume(audio_stream_type_t stream, float value, 102 bool muted, audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; 103 status_t setStreamMute(audio_stream_type_t stream, bool muted) final 104 EXCLUDES_AudioFlinger_Mutex; 105 106 status_t setPortsVolume(const std::vector<audio_port_handle_t>& portIds, float volume, 107 bool muted, audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; 108 109 status_t setMode(audio_mode_t mode) final EXCLUDES_AudioFlinger_Mutex; 110 111 status_t setMicMute(bool state) final EXCLUDES_AudioFlinger_Mutex; 112 bool getMicMute() const final EXCLUDES_AudioFlinger_Mutex; 113 114 void setRecordSilenced(audio_port_handle_t portId, bool silenced) final 115 EXCLUDES_AudioFlinger_Mutex; 116 117 status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) final 118 EXCLUDES_AudioFlinger_Mutex; 119 String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const final 120 EXCLUDES_AudioFlinger_Mutex; 121 122 void registerClient(const sp<media::IAudioFlingerClient>& client) final 123 EXCLUDES_AudioFlinger_Mutex; 124 size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 125 audio_channel_mask_t channelMask) const final EXCLUDES_AudioFlinger_Mutex; 126 127 status_t openOutput(const media::OpenOutputRequest& request, 128 media::OpenOutputResponse* response) final EXCLUDES_AudioFlinger_Mutex; 129 130 audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 131 audio_io_handle_t output2) final EXCLUDES_AudioFlinger_Mutex; 132 133 status_t closeOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; 134 135 status_t suspendOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; 136 137 status_t restoreOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; 138 139 status_t openInput(const media::OpenInputRequest& request, 140 media::OpenInputResponse* response) final EXCLUDES_AudioFlinger_Mutex; 141 142 status_t closeInput(audio_io_handle_t input) final EXCLUDES_AudioFlinger_Mutex; 143 144 status_t setVoiceVolume(float volume) final EXCLUDES_AudioFlinger_Mutex; 145 146 status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames, 147 audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; 148 149 uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const final 150 EXCLUDES_AudioFlinger_Mutex; 151 152 // This is the binder API. For the internal API see nextUniqueId(). 153 audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) final 154 EXCLUDES_AudioFlinger_Mutex; 155 156 void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) final 157 EXCLUDES_AudioFlinger_Mutex; 158 159 void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) final 160 EXCLUDES_AudioFlinger_Mutex; 161 162 status_t queryNumberEffects(uint32_t* numEffects) const final EXCLUDES_AudioFlinger_Mutex; 163 164 status_t queryEffect(uint32_t index, effect_descriptor_t* descriptor) const final 165 EXCLUDES_AudioFlinger_Mutex; 166 167 status_t getEffectDescriptor(const effect_uuid_t* pUuid, 168 const effect_uuid_t* pTypeUuid, 169 uint32_t preferredTypeFlag, 170 effect_descriptor_t* descriptor) const final EXCLUDES_AudioFlinger_Mutex; 171 172 status_t createEffect(const media::CreateEffectRequest& request, 173 media::CreateEffectResponse* response) final EXCLUDES_AudioFlinger_Mutex; 174 175 status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput, 176 audio_io_handle_t dstOutput) final EXCLUDES_AudioFlinger_Mutex; 177 178 void setEffectSuspended(int effectId, 179 audio_session_t sessionId, 180 bool suspended) final EXCLUDES_AudioFlinger_Mutex; 181 182 audio_module_handle_t loadHwModule(const char* name) final EXCLUDES_AudioFlinger_Mutex; 183 184 uint32_t getPrimaryOutputSamplingRate() const final EXCLUDES_AudioFlinger_Mutex; 185 size_t getPrimaryOutputFrameCount() const final EXCLUDES_AudioFlinger_Mutex; 186 187 status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) final 188 EXCLUDES_AudioFlinger_Mutex; 189 190 /* Get attributes for a given audio port */ 191 status_t getAudioPort(struct audio_port_v7* port) const final EXCLUDES_AudioFlinger_Mutex; 192 193 /* Create an audio patch between several source and sink ports */ 194 status_t createAudioPatch(const struct audio_patch *patch, 195 audio_patch_handle_t* handle) final EXCLUDES_AudioFlinger_Mutex; 196 197 /* Release an audio patch */ 198 status_t releaseAudioPatch(audio_patch_handle_t handle) final EXCLUDES_AudioFlinger_Mutex; 199 200 /* List existing audio patches */ 201 status_t listAudioPatches(unsigned int* num_patches, 202 struct audio_patch* patches) const final EXCLUDES_AudioFlinger_Mutex; 203 204 /* Set audio port configuration */ 205 status_t setAudioPortConfig(const struct audio_port_config* config) final 206 EXCLUDES_AudioFlinger_Mutex; 207 208 /* Get the HW synchronization source used for an audio session */ 209 audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) final 210 EXCLUDES_AudioFlinger_Mutex; 211 212 /* Indicate JAVA services are ready (scheduling, power management ...) */ 213 status_t systemReady() final EXCLUDES_AudioFlinger_Mutex; audioPolicyReady()214 status_t audioPolicyReady() final { mAudioPolicyReady.store(true); return NO_ERROR; } 215 216 status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const final 217 EXCLUDES_AudioFlinger_Mutex; 218 219 status_t setAudioHalPids(const std::vector<pid_t>& pids) final 220 EXCLUDES_AudioFlinger_Mutex; 221 222 status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) final 223 EXCLUDES_AudioFlinger_Mutex; 224 225 status_t updateSecondaryOutputs( 226 const TrackSecondaryOutputsMap& trackSecondaryOutputs) final 227 EXCLUDES_AudioFlinger_Mutex; 228 229 status_t getMmapPolicyInfos( 230 media::audio::common::AudioMMapPolicyType policyType, 231 std::vector<media::audio::common::AudioMMapPolicyInfo>* policyInfos) final 232 EXCLUDES_AudioFlinger_Mutex; 233 234 int32_t getAAudioMixerBurstCount() const final EXCLUDES_AudioFlinger_Mutex; 235 236 int32_t getAAudioHardwareBurstMinUsec() const final EXCLUDES_AudioFlinger_Mutex; 237 238 status_t setDeviceConnectedState(const struct audio_port_v7* port, 239 media::DeviceConnectedState state) final EXCLUDES_AudioFlinger_Mutex; 240 241 status_t setSimulateDeviceConnections(bool enabled) final EXCLUDES_AudioFlinger_Mutex; 242 243 status_t setRequestedLatencyMode( 244 audio_io_handle_t output, audio_latency_mode_t mode) final 245 EXCLUDES_AudioFlinger_Mutex; 246 247 status_t getSupportedLatencyModes(audio_io_handle_t output, 248 std::vector<audio_latency_mode_t>* modes) const final EXCLUDES_AudioFlinger_Mutex; 249 250 status_t setBluetoothVariableLatencyEnabled(bool enabled) final EXCLUDES_AudioFlinger_Mutex; 251 252 status_t isBluetoothVariableLatencyEnabled(bool* enabled) const final 253 EXCLUDES_AudioFlinger_Mutex; 254 255 status_t supportsBluetoothVariableLatency(bool* support) const final 256 EXCLUDES_AudioFlinger_Mutex; 257 258 status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, 259 sp<media::ISoundDose>* soundDose) const final EXCLUDES_AudioFlinger_Mutex; 260 261 status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) final 262 EXCLUDES_AudioFlinger_Mutex; 263 264 status_t getAudioPolicyConfig(media::AudioPolicyConfig* config) final 265 EXCLUDES_AudioFlinger_Mutex; 266 267 // Get the attributes of the mix port when connecting to the given device port. 268 status_t getAudioMixPort(const struct audio_port_v7* devicePort, 269 struct audio_port_v7* mixPort) const final EXCLUDES_AudioFlinger_Mutex; 270 271 status_t setTracksInternalMute( 272 const std::vector<media::TrackInternalMuteInfo>& tracksInternalMute) final 273 EXCLUDES_AudioFlinger_Mutex; 274 275 status_t onTransactWrapper(TransactionCode code, const Parcel& data, uint32_t flags, 276 const std::function<status_t()>& delegate) final EXCLUDES_AudioFlinger_Mutex; 277 278 // ---- end of IAudioFlinger interface 279 280 // ---- begin IAfClientCallback interface 281 clientMutex()282 audio_utils::mutex& clientMutex() const final 283 RETURN_CAPABILITY(audio_utils::AudioFlinger_ClientMutex) { 284 return mClientMutex; 285 } 286 void removeClient_l(pid_t pid) REQUIRES(clientMutex()) final; 287 void removeNotificationClient(pid_t pid) final EXCLUDES_AudioFlinger_Mutex; 288 status_t moveAuxEffectToIo( 289 int effectId, 290 const sp<IAfPlaybackThread>& dstThread, 291 sp<IAfPlaybackThread>* srcThread) final EXCLUDES_AudioFlinger_Mutex; 292 293 // ---- end of IAfClientCallback interface 294 295 // ---- begin IAfDeviceEffectManagerCallback interface 296 297 // also used by IAfThreadCallback isAudioPolicyReady()298 bool isAudioPolicyReady() const final { return mAudioPolicyReady.load(); } 299 // below also used by IAfMelReporterCallback, IAfPatchPanelCallback getPatchCommandThread()300 const sp<PatchCommandThread>& getPatchCommandThread() final { return mPatchCommandThread; } 301 status_t addEffectToHal( 302 const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final 303 EXCLUDES_AudioFlinger_HardwareMutex; 304 status_t removeEffectFromHal( 305 const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final 306 EXCLUDES_AudioFlinger_HardwareMutex; 307 308 // ---- end of IAfDeviceEffectManagerCallback interface 309 310 // ---- begin IAfMelReporterCallback interface 311 312 // below also used by IAfThreadCallback mutex()313 audio_utils::mutex& mutex() const final 314 RETURN_CAPABILITY(audio_utils::AudioFlinger_Mutex) 315 EXCLUDES_BELOW_AudioFlinger_Mutex { return mMutex; } 316 sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const final 317 REQUIRES(mutex()); 318 319 // ---- end of IAfMelReporterCallback interface 320 321 // ---- begin IAfPatchPanelCallback interface 322 323 void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread) final REQUIRES(mutex()); 324 void closeThreadInternal_l(const sp<IAfRecordThread>& thread) final REQUIRES(mutex()); 325 // return thread associated with primary hardware device, or NULL 326 IAfPlaybackThread* primaryPlaybackThread_l() const final REQUIRES(mutex()); 327 IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const final 328 REQUIRES(mutex()); 329 IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const final REQUIRES(mutex()); 330 IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const final REQUIRES(mutex()); 331 sp<IAfThreadBase> openInput_l(audio_module_handle_t module, 332 audio_io_handle_t* input, 333 audio_config_t* config, 334 audio_devices_t device, 335 const char* address, 336 audio_source_t source, 337 audio_input_flags_t flags, 338 audio_devices_t outputDevice, 339 const String8& outputDeviceAddress) final REQUIRES(mutex()); 340 sp<IAfThreadBase> openOutput_l(audio_module_handle_t module, 341 audio_io_handle_t* output, 342 audio_config_t* halConfig, 343 audio_config_base_t* mixerConfig, 344 audio_devices_t deviceType, 345 const String8& address, 346 audio_output_flags_t* flags, 347 audio_attributes_t attributes) final REQUIRES(mutex()); 348 const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>& getAudioHwDevs_l()349 getAudioHwDevs_l() const final REQUIRES(mutex(), hardwareMutex()) { 350 return mAudioHwDevs; 351 } 352 void updateDownStreamPatches_l(const struct audio_patch* patch, 353 const std::set<audio_io_handle_t>& streams) final REQUIRES(mutex()); 354 void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices) final 355 REQUIRES(mutex()); 356 357 // ---- end of IAfPatchPanelCallback interface 358 359 // ----- begin IAfThreadCallback interface 360 361 bool isNonOffloadableGlobalEffectEnabled_l() const final 362 REQUIRES(mutex()) EXCLUDES_ThreadBase_Mutex; btNrecIsOff()363 bool btNrecIsOff() const final { return mBtNrecIsOff.load(); } 364 float masterVolume_l() const final REQUIRES(mutex()); 365 bool masterMute_l() const final REQUIRES(mutex()); 366 float getMasterBalance_l() const REQUIRES(mutex()); 367 // no range check, AudioFlinger::mutex() held streamMute_l(audio_stream_type_t stream)368 bool streamMute_l(audio_stream_type_t stream) const final REQUIRES(mutex()) { 369 return mStreamTypes[stream].mute; 370 } getMode()371 audio_mode_t getMode() const final { return mMode; } isLowRamDevice()372 bool isLowRamDevice() const final { return mIsLowRamDevice; } getScreenState()373 uint32_t getScreenState() const final { return mScreenState; } 374 375 std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l() const final 376 REQUIRES(mutex()); getPatchPanel()377 const sp<IAfPatchPanel>& getPatchPanel() const final { return mPatchPanel; } getMelReporter()378 const sp<MelReporter>& getMelReporter() const final { return mMelReporter; } getEffectsFactoryHal()379 const sp<EffectsFactoryHalInterface>& getEffectsFactoryHal() const final { 380 return mEffectsFactoryHal; 381 } 382 sp<IAudioManager> getOrCreateAudioManager() final; 383 384 // Called when the last effect handle on an effect instance is removed. If this 385 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated 386 // and removed from mOrphanEffectChains if it does not contain any effect. 387 // Return true if the effect was found in mOrphanEffectChains, false otherwise. 388 bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect) final 389 EXCLUDES_AudioFlinger_Mutex; 390 391 status_t moveEffectChain_ll(audio_session_t sessionId, 392 IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread, 393 IAfEffectChain* srcChain = nullptr) final 394 REQUIRES(mutex(), audio_utils::ThreadBase_Mutex); 395 396 // This is a helper that is called during incoming binder calls. 397 // Requests media.log to start merging log buffers 398 void requestLogMerge() final; 399 sp<NBLog::Writer> newWriter_l(size_t size, const char *name) final REQUIRES(mutex()); 400 void unregisterWriter(const sp<NBLog::Writer>& writer) final; 401 402 sp<audioflinger::SyncEvent> createSyncEvent(AudioSystem::sync_event_t type, 403 audio_session_t triggerSession, 404 audio_session_t listenerSession, 405 const audioflinger::SyncEventCallback& callBack, 406 const wp<IAfTrackBase>& cookie) final EXCLUDES_AudioFlinger_Mutex; 407 408 // Hold either AudioFlinger::mutex or ThreadBase::mutex 409 void ioConfigChanged_l(audio_io_config_event_t event, 410 const sp<AudioIoDescriptor>& ioDesc, 411 pid_t pid = 0) final EXCLUDES_AudioFlinger_ClientMutex; 412 void onNonOffloadableGlobalEffectEnable() final EXCLUDES_AudioFlinger_Mutex; 413 void onSupportedLatencyModesChanged( 414 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) final 415 EXCLUDES_AudioFlinger_ClientMutex; 416 void onHardError(std::set<audio_port_handle_t>& trackPortIds) final 417 EXCLUDES_AudioFlinger_ClientMutex; 418 419 const ::com::android::media::permission::IPermissionProvider& getPermissionProvider() final; 420 421 // ---- end of IAfThreadCallback interface 422 423 /* List available audio ports and their attributes */ 424 status_t listAudioPorts(unsigned int* num_ports, struct audio_port* ports) const 425 EXCLUDES_AudioFlinger_Mutex; 426 427 sp<EffectsFactoryHalInterface> getEffectsFactory(); 428 getStartupFinishedTime()429 int64_t getStartupFinishedTime() { 430 return mStartupFinishedTime.load(std::memory_order_acquire); 431 } 432 433 public: 434 // TODO(b/292281786): Remove this when Oboeservice can get access to 435 // openMmapStream through an IAudioFlinger handle directly. 436 static inline std::atomic<AudioFlinger*> gAudioFlinger = nullptr; 437 438 status_t openMmapStream(MmapStreamInterface::stream_direction_t direction, 439 const audio_attributes_t *attr, 440 audio_config_base_t *config, 441 const AudioClient& client, 442 DeviceIdVector *deviceIds, 443 audio_session_t *sessionId, 444 const sp<MmapStreamCallback>& callback, 445 sp<MmapStreamInterface>& interface, 446 audio_port_handle_t *handle) EXCLUDES_AudioFlinger_Mutex; 447 initAudioPolicyLocal(sp<media::IAudioPolicyServiceLocal> audioPolicyLocal)448 void initAudioPolicyLocal(sp<media::IAudioPolicyServiceLocal> audioPolicyLocal) { 449 if (mAudioPolicyServiceLocal.load() == nullptr) { 450 mAudioPolicyServiceLocal = std::move(audioPolicyLocal); 451 } 452 } 453 454 private: 455 // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed. 456 static const size_t kLogMemorySize = 400 * 1024; 457 sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled 458 // When a log writer is unregistered, it is done lazily so that media.log can continue to see it 459 // for as long as possible. The memory is only freed when it is needed for another log writer. 460 Vector< sp<NBLog::Writer> > mUnregisteredWriters; unregisteredWritersMutex()461 audio_utils::mutex& unregisteredWritersMutex() const { return mUnregisteredWritersMutex; } 462 mutable audio_utils::mutex mUnregisteredWritersMutex{ 463 audio_utils::MutexOrder::kAudioFlinger_UnregisteredWritersMutex}; 464 465 AudioFlinger() ANDROID_API; 466 ~AudioFlinger() override; 467 468 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev initCheck()469 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? 470 NO_INIT : NO_ERROR; } 471 472 // RefBase 473 void onFirstRef() override; 474 475 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module, 476 audio_devices_t deviceType) REQUIRES(mutex()); 477 478 // incremented by 2 when screen state changes, bit 0 == 1 means "off" 479 // AudioFlinger::setParameters() updates with mutex(). 480 std::atomic_uint32_t mScreenState{}; 481 482 void dumpPermissionDenial(int fd); 483 void dumpClients_ll(int fd, bool dumpAllocators) REQUIRES(mutex(), clientMutex()); 484 void dumpInternals_l(int fd) REQUIRES(mutex()); 485 void dumpStats(int fd); 486 487 SimpleLog mThreadLog{16}; // 16 Thread history limit 488 489 void dumpToThreadLog_l(const sp<IAfThreadBase>& thread) REQUIRES(mutex()); 490 491 // --- Notification Client --- 492 class NotificationClient : public IBinder::DeathRecipient { 493 public: 494 NotificationClient(const sp<AudioFlinger>& audioFlinger, 495 const sp<media::IAudioFlingerClient>& client, 496 pid_t pid, 497 uid_t uid); 498 virtual ~NotificationClient(); 499 audioFlingerClient()500 sp<media::IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } getPid()501 pid_t getPid() const { return mPid; } getUid()502 uid_t getUid() const { return mUid; } 503 504 // IBinder::DeathRecipient 505 virtual void binderDied(const wp<IBinder>& who); 506 507 private: 508 DISALLOW_COPY_AND_ASSIGN(NotificationClient); 509 510 const sp<AudioFlinger> mAudioFlinger; 511 const pid_t mPid; 512 const uid_t mUid; 513 const sp<media::IAudioFlingerClient> mAudioFlingerClient; 514 const std::unique_ptr<media::psh_utils::Token> mClientToken; 515 }; 516 517 // --- MediaLogNotifier --- 518 // Thread in charge of notifying MediaLogService to start merging. 519 // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of 520 // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls. 521 class MediaLogNotifier : public Thread { 522 public: 523 MediaLogNotifier(); 524 525 // Requests a MediaLogService notification. It's ignored if there has recently been another 526 void requestMerge(); 527 private: 528 // Every iteration blocks waiting for a request, then interacts with MediaLogService to 529 // start merging. 530 // As every MediaLogService binder call is expensive, once it gets a request it ignores the 531 // following ones for a period of time. 532 virtual bool threadLoop() override; 533 534 bool mPendingRequests; 535 536 // Mutex and condition variable around mPendingRequests' value 537 audio_utils::mutex mMutex{audio_utils::MutexOrder::kMediaLogNotifier_Mutex}; 538 audio_utils::condition_variable mCondition; 539 540 // Duration of the sleep period after a processed request 541 static const int kPostTriggerSleepPeriod = 1000000; 542 }; 543 544 const sp<MediaLogNotifier> mMediaLogNotifier = sp<MediaLogNotifier>::make(); 545 546 // Find io handle by session id. 547 // Preference is given to an io handle with a matching effect chain to session id. 548 // If none found, AUDIO_IO_HANDLE_NONE is returned. 549 template <typename T> findIoHandleBySessionId_l(audio_session_t sessionId,const T & threads)550 static audio_io_handle_t findIoHandleBySessionId_l( 551 audio_session_t sessionId, const T& threads) 552 REQUIRES(audio_utils::AudioFlinger_Mutex) { 553 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE; 554 555 for (size_t i = 0; i < threads.size(); i++) { 556 const uint32_t sessionType = threads.valueAt(i)->hasAudioSession(sessionId); 557 if (sessionType != 0) { 558 io = threads.keyAt(i); 559 if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) { 560 break; // effect chain here. 561 } 562 } 563 } 564 return io; 565 } 566 567 IAfThreadBase* checkThread_l(audio_io_handle_t ioHandle) const REQUIRES(mutex()); 568 IAfPlaybackThread* checkMixerThread_l(audio_io_handle_t output) const REQUIRES(mutex()); 569 570 sp<VolumeInterface> getVolumeInterface_l(audio_io_handle_t output) const REQUIRES(mutex()); 571 572 std::vector<sp<VolumeInterface>> getAllVolumeInterfaces_l() const REQUIRES(mutex()); 573 574 575 static void closeOutputFinish(const sp<IAfPlaybackThread>& thread); 576 void closeInputFinish(const sp<IAfRecordThread>& thread); 577 578 // Allocate an audio_unique_id_t. 579 // Specific types are audio_io_handle_t, audio_session_t, effect ID (int), 580 // audio_module_handle_t, and audio_patch_handle_t. 581 // They all share the same ID space, but the namespaces are actually independent 582 // because there are separate KeyedVectors for each kind of ID. 583 // The return value is cast to the specific type depending on how the ID will be used. 584 // FIXME This API does not handle rollover to zero (for unsigned IDs), 585 // or from positive to negative (for signed IDs). 586 // Thus it may fail by returning an ID of the wrong sign, 587 // or by returning a non-unique ID. 588 // This is the internal API. For the binder API see newAudioUniqueId(). 589 // used by IAfDeviceEffectManagerCallback, IAfPatchPanelCallback, IAfThreadCallback 590 audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) final; 591 592 status_t moveEffectChain_ll(audio_session_t sessionId, 593 IAfRecordThread* srcThread, IAfRecordThread* dstThread) 594 REQUIRES(mutex(), audio_utils::ThreadBase_Mutex); 595 596 // return thread associated with primary hardware device, or NULL 597 DeviceTypeSet primaryOutputDevice_l() const REQUIRES(mutex()); 598 599 // return the playback thread with smallest HAL buffer size, and prefer fast 600 IAfPlaybackThread* fastPlaybackThread_l() const REQUIRES(mutex()); 601 602 sp<IAfThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId) 603 REQUIRES(mutex()); 604 605 IAfThreadBase* hapticPlaybackThread_l() const REQUIRES(mutex()); 606 607 void updateSecondaryOutputsForTrack_l( 608 IAfTrack* track, 609 IAfPlaybackThread* thread, 610 const std::vector<audio_io_handle_t>& secondaryOutputs) const REQUIRES(mutex()); 611 612 bool isSessionAcquired_l(audio_session_t audioSession) REQUIRES(mutex()); 613 614 // Store an effect chain to mOrphanEffectChains keyed vector. 615 // Called when a thread exits and effects are still attached to it. 616 // If effects are later created on the same session, they will reuse the same 617 // effect chain and same instances in the effect library. 618 // return ALREADY_EXISTS if a chain with the same session already exists in 619 // mOrphanEffectChains. Note that this should never happen as there is only one 620 // chain for a given session and it is attached to only one thread at a time. 621 status_t putOrphanEffectChain_l(const sp<IAfEffectChain>& chain) REQUIRES(mutex()); 622 // Get an effect chain for the specified session in mOrphanEffectChains and remove 623 // it if found. Returns 0 if not found (this is the most common case). 624 sp<IAfEffectChain> getOrphanEffectChain_l(audio_session_t session) REQUIRES(mutex()); 625 626 std::vector< sp<IAfEffectModule> > purgeStaleEffects_l() REQUIRES(mutex()); 627 628 std::vector< sp<IAfEffectModule> > purgeOrphanEffectChains_l() REQUIRES(mutex()); 629 bool updateOrphanEffectChains_l(const sp<IAfEffectModule>& effect) REQUIRES(mutex()); 630 631 void broadcastParametersToRecordThreads_l(const String8& keyValuePairs) REQUIRES(mutex()); 632 void forwardParametersToDownstreamPatches_l( 633 audio_io_handle_t upStream, const String8& keyValuePairs, 634 const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread = nullptr) 635 REQUIRES(mutex()); 636 637 // for mAudioSessionRefs only 638 struct AudioSessionRef { AudioSessionRefAudioSessionRef639 AudioSessionRef(audio_session_t sessionid, pid_t pid, uid_t uid) : 640 mSessionid(sessionid), mPid(pid), mUid(uid), mCnt(1) {} 641 const audio_session_t mSessionid; 642 const pid_t mPid; 643 const uid_t mUid; 644 int mCnt; 645 }; 646 647 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioFlinger_Mutex}; 648 // protects mClients and mNotificationClients. 649 // must be locked after mutex() and ThreadBase::mutex() if both must be locked 650 // avoids acquiring AudioFlinger::mutex() from inside thread loop. 651 652 mutable audio_utils::mutex mClientMutex{audio_utils::MutexOrder::kAudioFlinger_ClientMutex}; 653 654 DefaultKeyedVector<pid_t, wp<Client>> mClients GUARDED_BY(clientMutex()); // see ~Client() 655 hardwareMutex()656 audio_utils::mutex& hardwareMutex() const { return mHardwareMutex; } 657 658 mutable audio_utils::mutex mHardwareMutex{ 659 audio_utils::MutexOrder::kAudioFlinger_HardwareMutex}; 660 // NOTE: If both mMutex and mHardwareMutex mutexes must be held, 661 // always take mMutex before mHardwareMutex 662 663 std::atomic<AudioHwDevice*> mPrimaryHardwareDev = nullptr; 664 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs GUARDED_BY(hardwareMutex ())665 GUARDED_BY(hardwareMutex()) {nullptr /* defValue */}; 666 667 static bool inputBufferSizeDevsCmp(const AudioHwDevice* lhs, const AudioHwDevice* rhs); 668 std::set<AudioHwDevice*, decltype(&inputBufferSizeDevsCmp)> GUARDED_BY(hardwareMutex ())669 mInputBufferSizeOrderedDevs GUARDED_BY(hardwareMutex()) {inputBufferSizeDevsCmp}; 670 671 const sp<DevicesFactoryHalInterface> mDevicesFactoryHal = 672 DevicesFactoryHalInterface::create(); 673 /* const */ sp<DevicesFactoryHalCallback> mDevicesFactoryHalCallback; // set onFirstRef(). 674 675 // for dump, indicates which hardware operation is currently in progress (but not stream ops) 676 enum hardware_call_state { 677 AUDIO_HW_IDLE = 0, // no operation in progress 678 AUDIO_HW_INIT, // init_check 679 AUDIO_HW_OUTPUT_OPEN, // open_output_stream 680 AUDIO_HW_OUTPUT_CLOSE, // unused 681 AUDIO_HW_INPUT_OPEN, // unused 682 AUDIO_HW_INPUT_CLOSE, // unused 683 AUDIO_HW_STANDBY, // unused 684 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume 685 AUDIO_HW_GET_ROUTING, // unused 686 AUDIO_HW_SET_ROUTING, // unused 687 AUDIO_HW_GET_MODE, // unused 688 AUDIO_HW_SET_MODE, // set_mode 689 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute 690 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute 691 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume 692 AUDIO_HW_SET_PARAMETER, // set_parameters 693 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size 694 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume 695 AUDIO_HW_GET_PARAMETER, // get_parameters 696 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute 697 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute 698 AUDIO_HW_GET_MICROPHONES, // getMicrophones 699 AUDIO_HW_SET_CONNECTED_STATE, // setConnectedState 700 AUDIO_HW_SET_SIMULATE_CONNECTIONS, // setSimulateDeviceConnections 701 }; 702 703 mutable hardware_call_state mHardwareStatus = AUDIO_HW_IDLE; // for dump only 704 DefaultKeyedVector<audio_io_handle_t, sp<IAfPlaybackThread>> mPlaybackThreads 705 GUARDED_BY(mutex()); 706 stream_type_t mStreamTypes[AUDIO_STREAM_CNT] GUARDED_BY(mutex()); 707 708 float mMasterVolume GUARDED_BY(mutex()) = 1.f; 709 bool mMasterMute GUARDED_BY(mutex()) = false; 710 float mMasterBalance GUARDED_BY(mutex()) = 0.f; 711 712 DefaultKeyedVector<audio_io_handle_t, sp<IAfRecordThread>> mRecordThreads GUARDED_BY(mutex()); 713 714 std::map<pid_t, sp<NotificationClient>> mNotificationClients GUARDED_BY(clientMutex()); 715 716 // updated by atomic_fetch_add_explicit 717 volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX]; // ctor init 718 719 std::atomic<audio_mode_t> mMode = AUDIO_MODE_INVALID; 720 std::atomic<bool> mBtNrecIsOff = false; 721 722 Vector<AudioSessionRef*> mAudioSessionRefs GUARDED_BY(mutex()); 723 724 AudioHwDevice* loadHwModule_ll(const char *name) REQUIRES(mutex(), hardwareMutex()); 725 726 // sync events awaiting for a session to be created. 727 std::list<sp<audioflinger::SyncEvent>> mPendingSyncEvents GUARDED_BY(mutex()); 728 729 // Effect chains without a valid thread 730 DefaultKeyedVector<audio_session_t, sp<IAfEffectChain>> mOrphanEffectChains 731 GUARDED_BY(mutex()); 732 733 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL 734 DefaultKeyedVector<audio_session_t, audio_hw_sync_t> mHwAvSyncIds GUARDED_BY(mutex()); 735 736 // list of MMAP stream control threads. Those threads allow for wake lock, routing 737 // and volume control for activity on the associated MMAP stream at the HAL. 738 // Audio data transfer is directly handled by the client creating the MMAP stream 739 DefaultKeyedVector<audio_io_handle_t, sp<IAfMmapThread>> mMmapThreads GUARDED_BY(mutex()); 740 741 // always returns non-null 742 sp<Client> registerClient(pid_t pid, uid_t uid) EXCLUDES_AudioFlinger_ClientMutex; 743 744 sp<IAfEffectHandle> createOrphanEffect_l(const sp<Client>& client, 745 const sp<media::IEffectClient>& effectClient, 746 int32_t priority, 747 audio_session_t sessionId, 748 effect_descriptor_t *desc, 749 int *enabled, 750 status_t *status /*non-NULL*/, 751 bool pinned, 752 bool notifyFramesProcessed) REQUIRES(mutex()); 753 754 // for use from destructor 755 status_t closeOutput_nonvirtual(audio_io_handle_t output) EXCLUDES_AudioFlinger_Mutex; 756 status_t closeInput_nonvirtual(audio_io_handle_t input) EXCLUDES_AudioFlinger_Mutex; 757 void setAudioHwSyncForSession_l(IAfPlaybackThread* thread, audio_session_t sessionId) 758 REQUIRES(mutex()); 759 760 static status_t checkStreamType(audio_stream_type_t stream); 761 762 // no mutex needed. 763 void filterReservedParameters(String8& keyValuePairs, uid_t callingUid); 764 void logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs, 765 size_t rejectedKVPSize, const String8& rejectedKVPs, 766 uid_t callingUid); 767 768 // These methods read variables atomically without mLock, 769 // though the variables are updated with mLock. 770 size_t getClientSharedHeapSize() const; 771 772 std::atomic<bool> mIsLowRamDevice = true; 773 bool mIsDeviceTypeKnown GUARDED_BY(mutex()) = false; 774 int64_t mTotalMemory GUARDED_BY(mutex()) = 0; 775 std::atomic<size_t> mClientSharedHeapSize = kMinimumClientSharedHeapSizeBytes; 776 static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB 777 778 /* const */ sp<IAfPatchPanel> mPatchPanel; 779 780 const sp<EffectsFactoryHalInterface> mEffectsFactoryHal = 781 audioflinger::EffectConfiguration::getEffectsFactoryHal(); 782 783 const sp<PatchCommandThread> mPatchCommandThread = sp<PatchCommandThread>::make(); 784 /* const */ sp<DeviceEffectManager> mDeviceEffectManager; // set onFirstRef 785 /* const */ sp<MelReporter> mMelReporter; // set onFirstRef 786 787 bool mSystemReady GUARDED_BY(mutex()) = false; 788 std::atomic<bool> mAudioPolicyReady = false; 789 790 // no mutex needed. 791 SimpleLog mRejectedSetParameterLog; 792 SimpleLog mAppSetParameterLog; 793 SimpleLog mSystemSetParameterLog; 794 795 std::vector<media::AudioVibratorInfo> mAudioVibratorInfos GUARDED_BY(mutex()); 796 797 static inline constexpr const char *mMetricsId = AMEDIAMETRICS_KEY_AUDIO_FLINGER; 798 799 std::map<media::audio::common::AudioMMapPolicyType, 800 std::vector<media::audio::common::AudioMMapPolicyInfo>> mPolicyInfos 801 GUARDED_BY(mutex()); 802 int32_t mAAudioBurstsPerBuffer GUARDED_BY(mutex()) = 0; 803 int32_t mAAudioHwBurstMinMicros GUARDED_BY(mutex()) = 0; 804 805 /** Interface for interacting with the AudioService. */ 806 mediautils::atomic_sp<IAudioManager> mAudioManager; 807 808 // Bluetooth Variable latency control logic is enabled or disabled 809 std::atomic<bool> mBluetoothLatencyModesEnabled = true; 810 811 // Local interface to AudioPolicyService, late inited, but logically const 812 mediautils::atomic_sp<media::IAudioPolicyServiceLocal> mAudioPolicyServiceLocal; 813 814 const int64_t mStartTime = audio_utils_get_real_time_ns(); 815 // Late-inited from main() 816 std::atomic<int64_t> mStartupFinishedTime {}; 817 }; 818 819 // ---------------------------------------------------------------------------- 820 821 } // namespace android 822