blob: 1b2f6c3401d59b91797cf8d41bf18f95a1aab60d [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;
166 for (int i = 0; i < patch.mAudioPatch.num_sinks; ++ i) {
167 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
Vlad Popa7e81cea2023-01-19 16:34:16 +0100187void AudioFlinger::MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch) {
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100188 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
189 if (outputThread == nullptr) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100190 ALOGE("%s cannot find thread for stream handle %d", __func__, patch.streamHandle);
191 return;
192 }
193
194 for (const auto& deviceHandle : patch.deviceHandles) {
195 ++mActiveDevices[deviceHandle];
196 ALOGI("%s add stream %d that uses device %d for CSD, nr of streams: %d", __func__,
197 patch.streamHandle, deviceHandle, mActiveDevices[deviceHandle]);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100198
199 if (outputThread != nullptr) {
200 outputThread->startMelComputation_l(mSoundDoseManager->getOrCreateProcessorForDevice(
201 deviceHandle,
202 patch.streamHandle,
203 outputThread->mSampleRate,
204 outputThread->mChannelCount,
205 outputThread->mFormat));
Vlad Popa7e81cea2023-01-19 16:34:16 +0100206 }
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100207 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100208}
209
Vlad Popab042ee62022-10-20 18:05:00 +0200210void AudioFlinger::MelReporter::onReleaseAudioPatch(audio_patch_handle_t handle) {
Vlad Popa2a06fca2023-02-06 16:45:45 +0100211 if (mSoundDoseManager->isCsdDisabled()) {
212 ALOGV("%s csd is disabled", __func__);
213 return;
214 }
215
Vlad Popab042ee62022-10-20 18:05:00 +0200216 ActiveMelPatch melPatch;
217 {
218 std::lock_guard _l(mLock);
219
220 auto patchIt = mActiveMelPatches.find(handle);
221 if (patchIt == mActiveMelPatches.end()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +0100222 ALOGV("%s patch handle %d does not contain any mix sources with active MEL calculation",
223 __func__, handle);
Vlad Popab042ee62022-10-20 18:05:00 +0200224 return;
225 }
226
227 melPatch = patchIt->second;
228 mActiveMelPatches.erase(patchIt);
229 }
230
Vlad Popa7e81cea2023-01-19 16:34:16 +0100231 std::lock_guard _afl(mAudioFlinger.mLock);
232 std::lock_guard _l(mLock);
233 stopMelComputationForPatch_l(melPatch);
Vlad Popab042ee62022-10-20 18:05:00 +0200234}
235
Vlad Popae3fd1c22022-11-07 21:03:18 +0100236sp<media::ISoundDose> AudioFlinger::MelReporter::getSoundDoseInterface(
Vlad Popa63f047e2022-11-05 14:09:19 +0100237 const sp<media::ISoundDoseCallback>& callback) {
Vlad Popae3fd1c22022-11-07 21:03:18 +0100238 // no need to lock since getSoundDoseInterface is synchronized
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100239 return mSoundDoseManager->getSoundDoseInterface(callback);
240}
241
242void AudioFlinger::MelReporter::stopInternalMelComputation() {
243 ALOGV("%s", __func__);
Vlad Popa870f6d62022-12-22 12:15:47 +0100244 std::lock_guard _l(mLock);
245 mActiveMelPatches.clear();
246 mUseHalSoundDoseInterface = true;
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100247}
248
Vlad Popa7e81cea2023-01-19 16:34:16 +0100249void AudioFlinger::MelReporter::stopMelComputationForPatch_l(const ActiveMelPatch& patch) {
Vlad Popaeafa0482023-02-23 14:35:56 +0100250 if (!patch.csdActive) {
251 // no need to stop CSD inactive patches
252 return;
253 }
254
Vlad Popa1c2f7e12023-03-28 02:08:56 +0200255 auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100256
Vlad Popa7e81cea2023-01-19 16:34:16 +0100257 ALOGV("%s: stop MEL for stream id: %d", __func__, patch.streamHandle);
258 for (const auto& deviceId : patch.deviceHandles) {
259 if (mActiveDevices[deviceId] > 0) {
260 --mActiveDevices[deviceId];
261 if (mActiveDevices[deviceId] == 0) {
262 // no stream is using deviceId anymore
263 ALOGI("%s removing device %d from active CSD devices", __func__, deviceId);
264 mSoundDoseManager->clearMapDeviceIdEntries(deviceId);
265 }
266 }
267 }
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100268
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100269 if (outputThread != nullptr) {
270 outputThread->stopMelComputation_l();
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100271 }
Vlad Popa63f047e2022-11-05 14:09:19 +0100272}
273
Vlad Popa7e81cea2023-01-19 16:34:16 +0100274
275std::optional<audio_patch_handle_t> AudioFlinger::MelReporter::activePatchStreamHandle_l(
276 audio_io_handle_t streamHandle) {
277 for(const auto& patchIt : mActiveMelPatches) {
278 if (patchIt.second.streamHandle == streamHandle) {
279 return patchIt.first;
280 }
281 }
282 return std::nullopt;
283}
284
285bool AudioFlinger::MelReporter::useHalSoundDoseInterface() {
286 bool useHalSoundDoseInterface = !mSoundDoseManager->forceUseFrameworkMel();
287 {
288 std::lock_guard _l(mLock);
289 useHalSoundDoseInterface &= mUseHalSoundDoseInterface;
290 }
291 return useHalSoundDoseInterface;
292}
293
Vlad Popab042ee62022-10-20 18:05:00 +0200294std::string AudioFlinger::MelReporter::dump() {
295 std::lock_guard _l(mLock);
Vlad Popa2900c0a2022-10-24 13:38:00 +0200296 std::string output("\nSound Dose:\n");
Vlad Popa1d5f0d52022-12-18 12:21:26 +0100297 output.append(mSoundDoseManager->dump());
Vlad Popab042ee62022-10-20 18:05:00 +0200298 return output;
299}
300
301} // namespace android