blob: 3d5aae2064bc5e4a2b8737dcf5d5b50a93364ab6 [file] [log] [blame]
Vlad Popab042ee62022-10-20 18:05:00 +02001/*
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// #define LOG_NDEBUG 0
19#define LOG_TAG "AudioFlinger::MelReporter"
20
Vlad Popab042ee62022-10-20 18:05:00 +020021#include "AudioFlinger.h"
22
Vlad Popa63f047e2022-11-05 14:09:19 +010023#include <android/media/ISoundDoseCallback.h>
Vlad Popa2900c0a2022-10-24 13:38:00 +020024#include <audio_utils/power.h>
25#include <utils/Log.h>
26
Vlad Popadebe0a72022-12-28 16:55:13 +010027using aidl::android::hardware::audio::core::sounddose::ISoundDose;
Vlad Popa1d5f0d52022-12-18 12:21:26 +010028
Vlad Popab042ee62022-10-20 18:05:00 +020029namespace android {
30
Vlad Popa03bd5bc2023-01-17 16:16:51 +010031bool AudioFlinger::MelReporter::activateHalSoundDoseComputation(const std::string& module,
32 const sp<DeviceHalInterface>& device) {
Vlad Popa3d6d39d2022-12-21 18:59:16 +010033 if (mSoundDoseManager->forceUseFrameworkMel()) {
34 ALOGD("%s: Forcing use of internal MEL computation.", __func__);
35 activateInternalSoundDoseComputation();
36 return false;
37 }
38
Vlad Popa03bd5bc2023-01-17 16:16:51 +010039 ndk::SpAIBinder soundDoseBinder;
40 if (device->getSoundDoseInterface(module, &soundDoseBinder) != OK) {
41 ALOGW("%s: HAL cannot provide sound dose interface for module %s, use internal MEL",
Vlad Popa1d5f0d52022-12-18 12:21:26 +010042 __func__, module.c_str());
43 activateInternalSoundDoseComputation();
44 return false;
45 }
46
Vlad Popa03bd5bc2023-01-17 16:16:51 +010047 if (soundDoseBinder == nullptr) {
48 ALOGW("%s: HAL doesn't implement a sound dose interface for module %s, use internal MEL",
49 __func__, module.c_str());
50 activateInternalSoundDoseComputation();
51 return false;
52 }
53
54 std::shared_ptr<ISoundDose> soundDoseInterface = ISoundDose::fromBinder(soundDoseBinder);
55
Vlad Popa1d5f0d52022-12-18 12:21:26 +010056 if (!mSoundDoseManager->setHalSoundDoseInterface(soundDoseInterface)) {
Vlad Popa3d6d39d2022-12-21 18:59:16 +010057 ALOGW("%s: cannot activate HAL MEL reporting for module %s", __func__, module.c_str());
Vlad Popa1d5f0d52022-12-18 12:21:26 +010058 activateInternalSoundDoseComputation();
59 return false;
60 }
61
Vlad Popa1d5f0d52022-12-18 12:21:26 +010062 stopInternalMelComputation();
63 return true;
64}
65
66void AudioFlinger::MelReporter::activateInternalSoundDoseComputation() {
Vlad Popa3d6d39d2022-12-21 18:59:16 +010067 {
68 std::lock_guard _l(mLock);
69 if (!mUseHalSoundDoseInterface) {
70 // no need to start internal MEL on active patches
71 return;
72 }
73 mUseHalSoundDoseInterface = false;
74 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +010075
Vlad Popa3d6d39d2022-12-21 18:59:16 +010076 mSoundDoseManager->setHalSoundDoseInterface(nullptr);
Vlad Popa1d5f0d52022-12-18 12:21:26 +010077}
78
79void AudioFlinger::MelReporter::onFirstRef() {
80 mAudioFlinger.mPatchCommandThread->addListener(this);
Vlad Popa1d5f0d52022-12-18 12:21:26 +010081}
82
Vlad Popab042ee62022-10-20 18:05:00 +020083bool AudioFlinger::MelReporter::shouldComputeMelForDeviceType(audio_devices_t device) {
Vlad Popa2a06fca2023-02-06 16:45:45 +010084 if (mSoundDoseManager->isCsdDisabled()) {
85 ALOGV("%s csd is disabled", __func__);
86 return false;
87 }
Vlad Popa3d6d39d2022-12-21 18:59:16 +010088 if (mSoundDoseManager->forceComputeCsdOnAllDevices()) {
Vlad Popa91930462022-12-20 22:42:48 +010089 return true;
90 }
91
Vlad Popab042ee62022-10-20 18:05:00 +020092 switch (device) {
93 case AUDIO_DEVICE_OUT_WIRED_HEADSET:
94 case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
95 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
96 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
97 case AUDIO_DEVICE_OUT_HEARING_AID:
98 case AUDIO_DEVICE_OUT_USB_HEADSET:
99 case AUDIO_DEVICE_OUT_BLE_HEADSET:
100 case AUDIO_DEVICE_OUT_BLE_BROADCAST:
101 return true;
102 default:
103 return false;
104 }
105}
106
Vlad Popa7e81cea2023-01-19 16:34:16 +0100107void AudioFlinger::MelReporter::updateMetadataForCsd(audio_io_handle_t streamHandle,
108 const std::vector<playback_track_metadata_v7_t>& metadataVec) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100109 if (mSoundDoseManager->isCsdDisabled()) {
110 ALOGV("%s csd is disabled", __func__);
111 return;
112 }
113
Vlad Popa7e81cea2023-01-19 16:34:16 +0100114 std::lock_guard _laf(mAudioFlinger.mLock);
115 std::lock_guard _l(mLock);
116 auto activeMelPatchId = activePatchStreamHandle_l(streamHandle);
117 if (!activeMelPatchId) {
118 ALOGV("%s stream handle %d does not have an active patch", __func__, streamHandle);
119 return;
120 }
121
122 bool shouldActivateCsd = false;
123 for (const auto& metadata : metadataVec) {
124 if (metadata.base.usage == AUDIO_USAGE_GAME || metadata.base.usage == AUDIO_USAGE_MEDIA) {
125 shouldActivateCsd = true;
126 }
127 }
128
129 auto activeMelPatchIt = mActiveMelPatches.find(activeMelPatchId.value());
130 if (activeMelPatchIt != mActiveMelPatches.end()
131 && shouldActivateCsd != activeMelPatchIt->second.csdActive) {
132 if (activeMelPatchIt->second.csdActive) {
133 ALOGV("%s should not compute CSD for stream handle %d", __func__, streamHandle);
134 stopMelComputationForPatch_l(activeMelPatchIt->second);
135 } else {
136 ALOGV("%s should compute CSD for stream handle %d", __func__, streamHandle);
137 startMelComputationForActivePatch_l(activeMelPatchIt->second);
138 }
139 activeMelPatchIt->second.csdActive = shouldActivateCsd;
140 }
141}
142
Vlad Popab042ee62022-10-20 18:05:00 +0200143void AudioFlinger::MelReporter::onCreateAudioPatch(audio_patch_handle_t handle,
144 const PatchPanel::Patch& patch) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100145 if (mSoundDoseManager->isCsdDisabled()) {
146 ALOGV("%s csd is disabled", __func__);
147 return;
148 }
Vlad Popa7e81cea2023-01-19 16:34:16 +0100149 if (useHalSoundDoseInterface()) {
150 ALOGV("%s using HAL sound dose, ignore new patch", __func__);
151 return;
152 }
153
Vlad Popab042ee62022-10-20 18:05:00 +0200154 ALOGV("%s: handle %d mHalHandle %d device sink %08x",
155 __func__, handle, patch.mHalHandle,
156 patch.mAudioPatch.num_sinks > 0 ? patch.mAudioPatch.sinks[0].ext.device.type : 0);
157 if (patch.mAudioPatch.num_sources == 0
158 || patch.mAudioPatch.sources[0].type != AUDIO_PORT_TYPE_MIX) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100159 ALOGV("%s: patch does not contain any mix sources", __func__);
Vlad Popab042ee62022-10-20 18:05:00 +0200160 return;
161 }
162
163 audio_io_handle_t streamHandle = patch.mAudioPatch.sources[0].ext.mix.handle;
164 ActiveMelPatch newPatch;
165 newPatch.streamHandle = streamHandle;
Andy Hung920f6572022-10-06 12:09:49 -0700166 for (size_t i = 0; i < patch.mAudioPatch.num_sinks; ++i) {
Vlad Popab042ee62022-10-20 18:05:00 +0200167 if (patch.mAudioPatch.sinks[i].type == AUDIO_PORT_TYPE_DEVICE
168 && shouldComputeMelForDeviceType(patch.mAudioPatch.sinks[i].ext.device.type)) {
169 audio_port_handle_t deviceId = patch.mAudioPatch.sinks[i].id;
170 newPatch.deviceHandles.push_back(deviceId);
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100171 AudioDeviceTypeAddr adt{patch.mAudioPatch.sinks[i].ext.device.type,
172 patch.mAudioPatch.sinks[i].ext.device.address};
173 mSoundDoseManager->mapAddressToDeviceId(adt, deviceId);
Vlad Popab042ee62022-10-20 18:05:00 +0200174 }
175 }
176
Vlad Popa1c2f7e12023-03-28 02:08:56 +0200177 if (!newPatch.deviceHandles.empty()) {
178 std::lock_guard _afl(mAudioFlinger.mLock);
179 std::lock_guard _l(mLock);
180 ALOGV("%s add patch handle %d to active devices", __func__, handle);
181 startMelComputationForActivePatch_l(newPatch);
182 newPatch.csdActive = true;
183 mActiveMelPatches[handle] = newPatch;
184 }
Vlad Popab042ee62022-10-20 18:05:00 +0200185}
186
Andy Hung920f6572022-10-06 12:09:49 -0700187void AudioFlinger::MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch)
188NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
189{
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100190 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
191 if (outputThread == nullptr) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100192 ALOGE("%s cannot find thread for stream handle %d", __func__, patch.streamHandle);
193 return;
194 }
195
196 for (const auto& deviceHandle : patch.deviceHandles) {
197 ++mActiveDevices[deviceHandle];
198 ALOGI("%s add stream %d that uses device %d for CSD, nr of streams: %d", __func__,
199 patch.streamHandle, deviceHandle, mActiveDevices[deviceHandle]);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100200
201 if (outputThread != nullptr) {
202 outputThread->startMelComputation_l(mSoundDoseManager->getOrCreateProcessorForDevice(
203 deviceHandle,
204 patch.streamHandle,
205 outputThread->mSampleRate,
206 outputThread->mChannelCount,
207 outputThread->mFormat));
Vlad Popa7e81cea2023-01-19 16:34:16 +0100208 }
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100209 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100210}
211
Vlad Popab042ee62022-10-20 18:05:00 +0200212void AudioFlinger::MelReporter::onReleaseAudioPatch(audio_patch_handle_t handle) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100213 if (mSoundDoseManager->isCsdDisabled()) {
214 ALOGV("%s csd is disabled", __func__);
215 return;
216 }
217
Vlad Popab042ee62022-10-20 18:05:00 +0200218 ActiveMelPatch melPatch;
219 {
220 std::lock_guard _l(mLock);
221
222 auto patchIt = mActiveMelPatches.find(handle);
223 if (patchIt == mActiveMelPatches.end()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100224 ALOGV("%s patch handle %d does not contain any mix sources with active MEL calculation",
225 __func__, handle);
Vlad Popab042ee62022-10-20 18:05:00 +0200226 return;
227 }
228
229 melPatch = patchIt->second;
230 mActiveMelPatches.erase(patchIt);
231 }
232
Vlad Popa7e81cea2023-01-19 16:34:16 +0100233 std::lock_guard _afl(mAudioFlinger.mLock);
234 std::lock_guard _l(mLock);
235 stopMelComputationForPatch_l(melPatch);
Vlad Popab042ee62022-10-20 18:05:00 +0200236}
237
Vlad Popae3fd1c22022-11-07 21:03:18 +0100238sp<media::ISoundDose> AudioFlinger::MelReporter::getSoundDoseInterface(
Vlad Popa63f047e2022-11-05 14:09:19 +0100239 const sp<media::ISoundDoseCallback>& callback) {
Vlad Popae3fd1c22022-11-07 21:03:18 +0100240 // no need to lock since getSoundDoseInterface is synchronized
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100241 return mSoundDoseManager->getSoundDoseInterface(callback);
242}
243
244void AudioFlinger::MelReporter::stopInternalMelComputation() {
245 ALOGV("%s", __func__);
Vlad Popa870f6d62022-12-22 12:15:47 +0100246 std::lock_guard _l(mLock);
247 mActiveMelPatches.clear();
248 mUseHalSoundDoseInterface = true;
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100249}
250
Andy Hung920f6572022-10-06 12:09:49 -0700251void AudioFlinger::MelReporter::stopMelComputationForPatch_l(const ActiveMelPatch& patch)
252NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
253{
Vlad Popaeafa0482023-02-23 14:35:56 +0100254 if (!patch.csdActive) {
255 // no need to stop CSD inactive patches
256 return;
257 }
258
Vlad Popa1c2f7e12023-03-28 02:08:56 +0200259 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100260
Vlad Popa7e81cea2023-01-19 16:34:16 +0100261 ALOGV("%s: stop MEL for stream id: %d", __func__, patch.streamHandle);
262 for (const auto& deviceId : patch.deviceHandles) {
263 if (mActiveDevices[deviceId] > 0) {
264 --mActiveDevices[deviceId];
265 if (mActiveDevices[deviceId] == 0) {
266 // no stream is using deviceId anymore
267 ALOGI("%s removing device %d from active CSD devices", __func__, deviceId);
268 mSoundDoseManager->clearMapDeviceIdEntries(deviceId);
269 }
270 }
271 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100272
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100273 if (outputThread != nullptr) {
274 outputThread->stopMelComputation_l();
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100275 }
Vlad Popa63f047e2022-11-05 14:09:19 +0100276}
277
Vlad Popa7e81cea2023-01-19 16:34:16 +0100278
279std::optional<audio_patch_handle_t> AudioFlinger::MelReporter::activePatchStreamHandle_l(
280 audio_io_handle_t streamHandle) {
281 for(const auto& patchIt : mActiveMelPatches) {
282 if (patchIt.second.streamHandle == streamHandle) {
283 return patchIt.first;
284 }
285 }
286 return std::nullopt;
287}
288
289bool AudioFlinger::MelReporter::useHalSoundDoseInterface() {
290 bool useHalSoundDoseInterface = !mSoundDoseManager->forceUseFrameworkMel();
291 {
292 std::lock_guard _l(mLock);
293 useHalSoundDoseInterface &= mUseHalSoundDoseInterface;
294 }
295 return useHalSoundDoseInterface;
296}
297
Vlad Popab042ee62022-10-20 18:05:00 +0200298std::string AudioFlinger::MelReporter::dump() {
299 std::lock_guard _l(mLock);
Vlad Popa2900c0a2022-10-24 13:38:00 +0200300 std::string output("\nSound Dose:\n");
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100301 output.append(mSoundDoseManager->dump());
Vlad Popab042ee62022-10-20 18:05:00 +0200302 return output;
303}
304
305} // namespace android