1 /* 2 ** 3 ** Copyright 2022, 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 #include "IAfPatchPanel.h" 21 #include "PatchCommandThread.h" 22 23 #include <audio_utils/mutex.h> 24 #include <sounddose/SoundDoseManager.h> 25 26 #include <unordered_map> 27 28 namespace android { 29 30 class IAfMelReporterCallback : public virtual RefBase { 31 public: 32 virtual audio_utils::mutex& mutex() const 33 RETURN_CAPABILITY(audio_utils::AudioFlinger_Mutex) = 0; 34 virtual const sp<PatchCommandThread>& getPatchCommandThread() = 0; 35 virtual sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const 36 REQUIRES(mutex()) = 0; 37 }; 38 39 /** 40 * Class for listening to new patches and starting the MEL computation. MelReporter is 41 * concealed within AudioFlinger, their lifetimes are the same. 42 */ 43 class MelReporter : public PatchCommandThread::PatchCommandListener, 44 public IMelReporterCallback { 45 public: MelReporter(const sp<IAfMelReporterCallback> & afMelReporterCallback,const sp<IAfPatchPanel> & afPatchPanel)46 MelReporter(const sp<IAfMelReporterCallback>& afMelReporterCallback, 47 const sp<IAfPatchPanel>& afPatchPanel) 48 : mAfMelReporterCallback(afMelReporterCallback), 49 mAfPatchPanel(afPatchPanel) {} 50 51 void onFirstRef() override; 52 53 /** 54 * Activates the MEL reporting from the HAL sound dose interface. If the HAL 55 * does not support the sound dose interface for this module, the internal MEL 56 * calculation will be use. 57 * 58 * <p>If the device is using the audio AIDL HAL then this method will try to get the sound 59 * dose interface from IModule#getSoundDose(). Otherwise, if the legacy audio HIDL HAL is used 60 * this method will be looking for the standalone sound dose implementation. It falls back to 61 * the internal MEL computation if no valid sound dose interface can be retrieved. 62 * 63 * @return true if the MEL reporting will be done from any sound dose HAL interface 64 * implementation, false otherwise. 65 */ 66 bool activateHalSoundDoseComputation(const std::string& module, 67 const sp<DeviceHalInterface>& device) EXCLUDES_MelReporter_Mutex; 68 69 /** 70 * Activates the MEL reporting from internal framework values. These are used 71 * as a fallback when there is no sound dose interface implementation from HAL. 72 * Note: the internal CSD computation does not guarantee a certification with 73 * IEC62368-1 3rd edition or EN50332-3 74 */ 75 void activateInternalSoundDoseComputation() EXCLUDES_MelReporter_Mutex; 76 77 sp<media::ISoundDose> getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback); 78 79 std::string dump(); 80 81 // IMelReporterCallback methods 82 void stopMelComputationForDeviceId(audio_port_handle_t deviceId) final 83 EXCLUDES_AudioFlinger_Mutex EXCLUDES_MelReporter_Mutex; 84 void startMelComputationForDeviceId(audio_port_handle_t deviceId) final 85 EXCLUDES_AudioFlinger_Mutex EXCLUDES_MelReporter_Mutex; 86 void applyAllAudioPatches() final EXCLUDES_AudioFlinger_Mutex EXCLUDES_MelReporter_Mutex; 87 88 // PatchCommandListener methods 89 void onCreateAudioPatch(audio_patch_handle_t handle, 90 const IAfPatchPanel::Patch& patch) final 91 EXCLUDES_AudioFlinger_Mutex; 92 void onReleaseAudioPatch(audio_patch_handle_t handle) final EXCLUDES_AudioFlinger_Mutex; 93 void onUpdateAudioPatch(audio_patch_handle_t oldHandle, 94 audio_patch_handle_t newHandle, 95 const IAfPatchPanel::Patch& patch) final EXCLUDES_AudioFlinger_Mutex; 96 97 /** 98 * The new metadata can determine whether we should compute MEL for the given thread. 99 * This is the case only if one of the tracks in the thread mix is using MEDIA or GAME. 100 * Otherwise, this method will disable CSD. 101 **/ 102 void updateMetadataForCsd(audio_io_handle_t streamHandle, 103 const std::vector<playback_track_metadata_v7_t>& metadataVec) 104 EXCLUDES_AudioFlinger_Mutex; 105 106 void resetReferencesForTest(); 107 108 private: 109 struct ActiveMelPatch { 110 audio_io_handle_t streamHandle{AUDIO_IO_HANDLE_NONE}; 111 /** 112 * Stores device ids and whether they are compatible for CSD calculation. 113 * The boolean value can change since BT audio device types are user-configurable 114 * to headphones/headsets or other device types. 115 */ 116 std::vector<std::pair<audio_port_handle_t,bool>> deviceStates; 117 bool csdActive; 118 }; 119 120 void stopInternalMelComputation(); mutex()121 audio_utils::mutex& mutex() const RETURN_CAPABILITY(audio_utils::MelReporter_Mutex) { 122 return mMutex; 123 } 124 125 /** Should be called with the following order of locks: mAudioFlinger.mutex() -> mutex(). */ 126 void stopMelComputationForPatch_l(const ActiveMelPatch& patch) REQUIRES(mutex()); 127 128 /** Should be called with the following order of locks: mAudioFlinger.mutex() -> mutex(). */ 129 void startMelComputationForActivePatch_l(const ActiveMelPatch& patch) REQUIRES(mutex()); 130 131 std::optional<audio_patch_handle_t> 132 activePatchStreamHandle_l(audio_io_handle_t streamHandle) REQUIRES(mutex()); 133 134 bool useHalSoundDoseInterface_l() REQUIRES(mutex()); 135 136 sp<IAfMelReporterCallback> mAfMelReporterCallback; 137 const sp<IAfPatchPanel> mAfPatchPanel; 138 139 /* const */ sp<SoundDoseManager> mSoundDoseManager; // set onFirstRef 140 141 /** 142 * Lock for protecting the active mel patches. Do not mix with the AudioFlinger lock. 143 * Locking order AudioFlinger::mutex() -> PatchCommandThread::mutex() -> MelReporter::mutex(). 144 */ 145 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kMelReporter_Mutex}; 146 std::unordered_map<audio_patch_handle_t, ActiveMelPatch> mActiveMelPatches 147 GUARDED_BY(mutex()); 148 std::unordered_map<audio_port_handle_t, int> mActiveDevices GUARDED_BY(mutex()); 149 bool mUseHalSoundDoseInterface GUARDED_BY(mutex()) = false; 150 }; 151 152 } // namespace android 153