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