blob: 7c786d7e4313c833711782aa97f131da12091670 [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 Popa617bbf02023-04-24 19:10:36 +020084 if (!mSoundDoseManager->isCsdEnabled()) {
Vlad Popa2a06fca2023-02-06 16:45:45 +010085 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:
Vlad Popaa6316942023-04-14 18:16:18 +020095 // TODO(b/278265907): enable A2DP when we can distinguish A2DP headsets
96 // case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
Vlad Popab042ee62022-10-20 18:05:00 +020097 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
Vlad Popab042ee62022-10-20 18:05:00 +020098 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 Popa617bbf02023-04-24 19:10:36 +0200109 if (!mSoundDoseManager->isCsdEnabled()) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100110 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,
Andy Hung8e6b62a2023-07-13 18:11:33 -0700144 const IAfPatchPanel::Patch& patch) {
Vlad Popa617bbf02023-04-24 19:10:36 +0200145 if (!mSoundDoseManager->isCsdEnabled()) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100146 ALOGV("%s csd is disabled", __func__);
147 return;
148 }
Vlad Popa7e81cea2023-01-19 16:34:16 +0100149
Vlad Popab042ee62022-10-20 18:05:00 +0200150 ALOGV("%s: handle %d mHalHandle %d device sink %08x",
151 __func__, handle, patch.mHalHandle,
152 patch.mAudioPatch.num_sinks > 0 ? patch.mAudioPatch.sinks[0].ext.device.type : 0);
153 if (patch.mAudioPatch.num_sources == 0
154 || patch.mAudioPatch.sources[0].type != AUDIO_PORT_TYPE_MIX) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100155 ALOGV("%s: patch does not contain any mix sources", __func__);
Vlad Popab042ee62022-10-20 18:05:00 +0200156 return;
157 }
158
159 audio_io_handle_t streamHandle = patch.mAudioPatch.sources[0].ext.mix.handle;
160 ActiveMelPatch newPatch;
161 newPatch.streamHandle = streamHandle;
Andy Hung920f6572022-10-06 12:09:49 -0700162 for (size_t i = 0; i < patch.mAudioPatch.num_sinks; ++i) {
Vlad Popab042ee62022-10-20 18:05:00 +0200163 if (patch.mAudioPatch.sinks[i].type == AUDIO_PORT_TYPE_DEVICE
164 && shouldComputeMelForDeviceType(patch.mAudioPatch.sinks[i].ext.device.type)) {
165 audio_port_handle_t deviceId = patch.mAudioPatch.sinks[i].id;
166 newPatch.deviceHandles.push_back(deviceId);
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100167 AudioDeviceTypeAddr adt{patch.mAudioPatch.sinks[i].ext.device.type,
168 patch.mAudioPatch.sinks[i].ext.device.address};
169 mSoundDoseManager->mapAddressToDeviceId(adt, deviceId);
Vlad Popab042ee62022-10-20 18:05:00 +0200170 }
171 }
172
Vlad Popa1c2f7e12023-03-28 02:08:56 +0200173 if (!newPatch.deviceHandles.empty()) {
174 std::lock_guard _afl(mAudioFlinger.mLock);
175 std::lock_guard _l(mLock);
176 ALOGV("%s add patch handle %d to active devices", __func__, handle);
177 startMelComputationForActivePatch_l(newPatch);
178 newPatch.csdActive = true;
179 mActiveMelPatches[handle] = newPatch;
180 }
Vlad Popab042ee62022-10-20 18:05:00 +0200181}
182
Andy Hung920f6572022-10-06 12:09:49 -0700183void AudioFlinger::MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch)
184NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
185{
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100186 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
187 if (outputThread == nullptr) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100188 ALOGE("%s cannot find thread for stream handle %d", __func__, patch.streamHandle);
189 return;
190 }
191
192 for (const auto& deviceHandle : patch.deviceHandles) {
193 ++mActiveDevices[deviceHandle];
194 ALOGI("%s add stream %d that uses device %d for CSD, nr of streams: %d", __func__,
195 patch.streamHandle, deviceHandle, mActiveDevices[deviceHandle]);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100196
Vlad Popa69fbbee2023-04-25 12:23:24 +0200197 if (outputThread != nullptr && !useHalSoundDoseInterface_l()) {
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100198 outputThread->startMelComputation_l(mSoundDoseManager->getOrCreateProcessorForDevice(
199 deviceHandle,
200 patch.streamHandle,
Andy Hung87c693c2023-07-06 20:56:16 -0700201 outputThread->sampleRate(),
202 outputThread->channelCount(),
203 outputThread->format()));
Vlad Popa7e81cea2023-01-19 16:34:16 +0100204 }
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100205 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100206}
207
Vlad Popab042ee62022-10-20 18:05:00 +0200208void AudioFlinger::MelReporter::onReleaseAudioPatch(audio_patch_handle_t handle) {
Vlad Popa617bbf02023-04-24 19:10:36 +0200209 if (!mSoundDoseManager->isCsdEnabled()) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100210 ALOGV("%s csd is disabled", __func__);
211 return;
212 }
213
Vlad Popab042ee62022-10-20 18:05:00 +0200214 ActiveMelPatch melPatch;
215 {
216 std::lock_guard _l(mLock);
217
218 auto patchIt = mActiveMelPatches.find(handle);
219 if (patchIt == mActiveMelPatches.end()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100220 ALOGV("%s patch handle %d does not contain any mix sources with active MEL calculation",
221 __func__, handle);
Vlad Popab042ee62022-10-20 18:05:00 +0200222 return;
223 }
224
225 melPatch = patchIt->second;
226 mActiveMelPatches.erase(patchIt);
227 }
228
Vlad Popa7e81cea2023-01-19 16:34:16 +0100229 std::lock_guard _afl(mAudioFlinger.mLock);
230 std::lock_guard _l(mLock);
231 stopMelComputationForPatch_l(melPatch);
Vlad Popab042ee62022-10-20 18:05:00 +0200232}
233
François Gaffie58e73af2023-02-15 11:47:24 +0100234void AudioFlinger::MelReporter::onUpdateAudioPatch(audio_patch_handle_t oldHandle,
Andy Hung8e6b62a2023-07-13 18:11:33 -0700235 audio_patch_handle_t newHandle, const IAfPatchPanel::Patch& patch) {
François Gaffie58e73af2023-02-15 11:47:24 +0100236 onReleaseAudioPatch(oldHandle);
237 onCreateAudioPatch(newHandle, patch);
238}
239
Vlad Popae3fd1c22022-11-07 21:03:18 +0100240sp<media::ISoundDose> AudioFlinger::MelReporter::getSoundDoseInterface(
Vlad Popa63f047e2022-11-05 14:09:19 +0100241 const sp<media::ISoundDoseCallback>& callback) {
Vlad Popae3fd1c22022-11-07 21:03:18 +0100242 // no need to lock since getSoundDoseInterface is synchronized
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100243 return mSoundDoseManager->getSoundDoseInterface(callback);
244}
245
246void AudioFlinger::MelReporter::stopInternalMelComputation() {
247 ALOGV("%s", __func__);
Vlad Popa870f6d62022-12-22 12:15:47 +0100248 std::lock_guard _l(mLock);
249 mActiveMelPatches.clear();
250 mUseHalSoundDoseInterface = true;
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100251}
252
Andy Hung920f6572022-10-06 12:09:49 -0700253void AudioFlinger::MelReporter::stopMelComputationForPatch_l(const ActiveMelPatch& patch)
254NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
255{
Vlad Popaeafa0482023-02-23 14:35:56 +0100256 if (!patch.csdActive) {
257 // no need to stop CSD inactive patches
258 return;
259 }
260
Vlad Popa1c2f7e12023-03-28 02:08:56 +0200261 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100262
Vlad Popa7e81cea2023-01-19 16:34:16 +0100263 ALOGV("%s: stop MEL for stream id: %d", __func__, patch.streamHandle);
264 for (const auto& deviceId : patch.deviceHandles) {
265 if (mActiveDevices[deviceId] > 0) {
266 --mActiveDevices[deviceId];
267 if (mActiveDevices[deviceId] == 0) {
268 // no stream is using deviceId anymore
269 ALOGI("%s removing device %d from active CSD devices", __func__, deviceId);
270 mSoundDoseManager->clearMapDeviceIdEntries(deviceId);
271 }
272 }
273 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100274
Vlad Popa69fbbee2023-04-25 12:23:24 +0200275 if (outputThread != nullptr && !useHalSoundDoseInterface_l()) {
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100276 outputThread->stopMelComputation_l();
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100277 }
Vlad Popa63f047e2022-11-05 14:09:19 +0100278}
279
Vlad Popa7e81cea2023-01-19 16:34:16 +0100280
281std::optional<audio_patch_handle_t> AudioFlinger::MelReporter::activePatchStreamHandle_l(
282 audio_io_handle_t streamHandle) {
283 for(const auto& patchIt : mActiveMelPatches) {
284 if (patchIt.second.streamHandle == streamHandle) {
285 return patchIt.first;
286 }
287 }
288 return std::nullopt;
289}
290
Vlad Popa69fbbee2023-04-25 12:23:24 +0200291bool AudioFlinger::MelReporter::useHalSoundDoseInterface_l() {
292 return !mSoundDoseManager->forceUseFrameworkMel() & mUseHalSoundDoseInterface;
Vlad Popa7e81cea2023-01-19 16:34:16 +0100293}
294
Vlad Popab042ee62022-10-20 18:05:00 +0200295std::string AudioFlinger::MelReporter::dump() {
296 std::lock_guard _l(mLock);
Vlad Popa2900c0a2022-10-24 13:38:00 +0200297 std::string output("\nSound Dose:\n");
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100298 output.append(mSoundDoseManager->dump());
Vlad Popab042ee62022-10-20 18:05:00 +0200299 return output;
300}
301
302} // namespace android