blob: c48b2c39ac31f4c392af5c6dd02f7e785ff5af51 [file] [log] [blame]
Eric Laurentca7cc822012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, 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
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
Andy Hung5fd10da2023-07-19 11:31:15 -070022#include "Effects.h"
rago94a1ee82017-07-21 15:11:02 -070023
Andy Hung5fd10da2023-07-19 11:31:15 -070024#include "Client.h"
25#include "EffectConfiguration.h"
26
27#include <afutils/DumpTryLock.h>
28#include <audio_utils/channels.h>
29#include <audio_utils/primitives.h>
30#include <media/AudioCommonTypes.h>
31#include <media/AudioContainers.h>
32#include <media/AudioDeviceTypeAddr.h>
33#include <media/AudioEffect.h>
34#include <media/ShmemCompat.h>
35#include <media/TypeConverter.h>
36#include <media/audiohal/EffectHalInterface.h>
37#include <media/audiohal/EffectsFactoryHalInterface.h>
38#include <mediautils/MethodStatistics.h>
39#include <mediautils/ServiceUtilities.h>
40#include <mediautils/TimeCheck.h>
Eric Laurentd8365c52017-07-16 15:27:05 -070041#include <system/audio_effects/effect_aec.h>
Eric Laurentb62d0362021-10-26 17:40:18 +020042#include <system/audio_effects/effect_downmix.h>
Ricardo Garciac2a3a822019-07-17 14:29:12 -070043#include <system/audio_effects/effect_dynamicsprocessing.h>
jiabineb3bda02020-06-30 14:07:03 -070044#include <system/audio_effects/effect_hapticgenerator.h>
Eric Laurentd8365c52017-07-16 15:27:05 -070045#include <system/audio_effects/effect_ns.h>
Eric Laurentb62d0362021-10-26 17:40:18 +020046#include <system/audio_effects/effect_spatializer.h>
Eric Laurentd8365c52017-07-16 15:27:05 -070047#include <system/audio_effects/effect_visualizer.h>
Andy Hung5fd10da2023-07-19 11:31:15 -070048#include <utils/Log.h>
Eric Laurentca7cc822012-11-19 14:55:58 -080049
Andy Hung5fd10da2023-07-19 11:31:15 -070050#include <algorithm>
Eric Laurentca7cc822012-11-19 14:55:58 -080051
52// ----------------------------------------------------------------------------
53
54// Note: the following macro is used for extremely verbose logging message. In
55// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
56// 0; but one side effect of this is to turn all LOGV's as well. Some messages
57// are so verbose that we want to suppress them even when we have ALOG_ASSERT
58// turned on. Do not uncomment the #def below unless you really know what you
59// are doing and want to see all of the extremely verbose messages.
60//#define VERY_VERY_VERBOSE_LOGGING
61#ifdef VERY_VERY_VERBOSE_LOGGING
62#define ALOGVV ALOGV
63#else
64#define ALOGVV(a...) do { } while(0)
65#endif
66
Yuuki Yokoyamae17f8312017-05-26 19:06:33 +090067#define DEFAULT_OUTPUT_SAMPLE_RATE 48000
68
Eric Laurentca7cc822012-11-19 14:55:58 -080069namespace android {
70
Andy Hung1131b6e2020-12-08 20:47:45 -080071using aidl_utils::statusTFromBinderStatus;
Andy Hungba8e52b2023-05-11 14:33:03 -070072using audioflinger::EffectConfiguration;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -070073using binder::Status;
74
75namespace {
76
77// Append a POD value into a vector of bytes.
78template<typename T>
79void appendToBuffer(const T& value, std::vector<uint8_t>* buffer) {
80 const uint8_t* ar(reinterpret_cast<const uint8_t*>(&value));
81 buffer->insert(buffer->end(), ar, ar + sizeof(T));
82}
83
84// Write a POD value into a vector of bytes (clears the previous buffer
85// content).
86template<typename T>
87void writeToBuffer(const T& value, std::vector<uint8_t>* buffer) {
88 buffer->clear();
89 appendToBuffer(value, buffer);
90}
91
92} // namespace
93
Eric Laurentca7cc822012-11-19 14:55:58 -080094// ----------------------------------------------------------------------------
Eric Laurent41709552019-12-16 19:34:05 -080095// EffectBase implementation
Eric Laurentca7cc822012-11-19 14:55:58 -080096// ----------------------------------------------------------------------------
97
98#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -070099#define LOG_TAG "EffectBase"
Eric Laurentca7cc822012-11-19 14:55:58 -0800100
Andy Hung6ac17eb2023-06-20 18:56:17 -0700101EffectBase::EffectBase(const sp<EffectCallbackInterface>& callback,
Eric Laurentca7cc822012-11-19 14:55:58 -0800102 effect_descriptor_t *desc,
103 int id,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800104 audio_session_t sessionId,
105 bool pinned)
106 : mPinned(pinned),
Eric Laurent6b446ce2019-12-13 10:56:31 -0800107 mCallback(callback), mId(id), mSessionId(sessionId),
Eric Laurent41709552019-12-16 19:34:05 -0800108 mDescriptor(*desc)
Eric Laurentca7cc822012-11-19 14:55:58 -0800109{
Eric Laurentca7cc822012-11-19 14:55:58 -0800110}
111
Andy Hungf65f5a72023-08-29 12:19:17 -0700112// must be called with EffectModule::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -0700113status_t EffectBase::setEnabled_l(bool enabled)
Eric Laurentca7cc822012-11-19 14:55:58 -0800114{
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800115
Eric Laurent41709552019-12-16 19:34:05 -0800116 ALOGV("setEnabled %p enabled %d", this, enabled);
117
118 if (enabled != isEnabled()) {
119 switch (mState) {
120 // going from disabled to enabled
121 case IDLE:
122 mState = STARTING;
123 break;
124 case STOPPED:
125 mState = RESTART;
126 break;
127 case STOPPING:
128 mState = ACTIVE;
129 break;
130
131 // going from enabled to disabled
132 case RESTART:
133 mState = STOPPED;
134 break;
135 case STARTING:
136 mState = IDLE;
137 break;
138 case ACTIVE:
139 mState = STOPPING;
140 break;
141 case DESTROYED:
142 return NO_ERROR; // simply ignore as we are being destroyed
143 }
144 for (size_t i = 1; i < mHandles.size(); i++) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700145 IAfEffectHandle *h = mHandles[i];
Eric Laurent41709552019-12-16 19:34:05 -0800146 if (h != NULL && !h->disconnected()) {
147 h->setEnabled(enabled);
148 }
149 }
150 }
151 return NO_ERROR;
Eric Laurentca7cc822012-11-19 14:55:58 -0800152}
153
Andy Hung6ac17eb2023-06-20 18:56:17 -0700154status_t EffectBase::setEnabled(bool enabled, bool fromHandle)
Eric Laurent41709552019-12-16 19:34:05 -0800155{
156 status_t status;
157 {
Andy Hungf65f5a72023-08-29 12:19:17 -0700158 audio_utils::lock_guard _l(mutex());
Eric Laurent41709552019-12-16 19:34:05 -0800159 status = setEnabled_l(enabled);
160 }
161 if (fromHandle) {
162 if (enabled) {
163 if (status != NO_ERROR) {
Andy Hungfda44002021-06-03 17:23:16 -0700164 getCallback()->checkSuspendOnEffectEnabled(this, false, false /*threadLocked*/);
Eric Laurent41709552019-12-16 19:34:05 -0800165 } else {
Andy Hungfda44002021-06-03 17:23:16 -0700166 getCallback()->onEffectEnable(this);
Eric Laurent41709552019-12-16 19:34:05 -0800167 }
168 } else {
Andy Hungfda44002021-06-03 17:23:16 -0700169 getCallback()->onEffectDisable(this);
Eric Laurent41709552019-12-16 19:34:05 -0800170 }
171 }
172 return status;
173}
174
Andy Hung6ac17eb2023-06-20 18:56:17 -0700175bool EffectBase::isEnabled() const
Eric Laurent41709552019-12-16 19:34:05 -0800176{
177 switch (mState) {
178 case RESTART:
179 case STARTING:
180 case ACTIVE:
181 return true;
182 case IDLE:
183 case STOPPING:
184 case STOPPED:
185 case DESTROYED:
186 default:
187 return false;
188 }
189}
190
Andy Hung6ac17eb2023-06-20 18:56:17 -0700191void EffectBase::setSuspended(bool suspended)
Eric Laurent41709552019-12-16 19:34:05 -0800192{
Andy Hungf65f5a72023-08-29 12:19:17 -0700193 audio_utils::lock_guard _l(mutex());
Eric Laurent41709552019-12-16 19:34:05 -0800194 mSuspended = suspended;
195}
196
Andy Hung6ac17eb2023-06-20 18:56:17 -0700197bool EffectBase::suspended() const
Eric Laurent41709552019-12-16 19:34:05 -0800198{
Andy Hungf65f5a72023-08-29 12:19:17 -0700199 audio_utils::lock_guard _l(mutex());
Eric Laurent41709552019-12-16 19:34:05 -0800200 return mSuspended;
201}
202
Andy Hung6ac17eb2023-06-20 18:56:17 -0700203status_t EffectBase::addHandle(IAfEffectHandle *handle)
Eric Laurentca7cc822012-11-19 14:55:58 -0800204{
205 status_t status;
206
Andy Hungf65f5a72023-08-29 12:19:17 -0700207 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -0800208 int priority = handle->priority();
209 size_t size = mHandles.size();
Andy Hung6ac17eb2023-06-20 18:56:17 -0700210 IAfEffectHandle *controlHandle = nullptr;
Eric Laurentca7cc822012-11-19 14:55:58 -0800211 size_t i;
212 for (i = 0; i < size; i++) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700213 IAfEffectHandle *h = mHandles[i];
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800214 if (h == NULL || h->disconnected()) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800215 continue;
216 }
217 // first non destroyed handle is considered in control
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700218 if (controlHandle == NULL) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800219 controlHandle = h;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700220 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800221 if (h->priority() <= priority) {
222 break;
223 }
224 }
225 // if inserted in first place, move effect control from previous owner to this handle
226 if (i == 0) {
227 bool enabled = false;
228 if (controlHandle != NULL) {
229 enabled = controlHandle->enabled();
230 controlHandle->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
231 }
232 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
233 status = NO_ERROR;
234 } else {
235 status = ALREADY_EXISTS;
236 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700237 ALOGV("addHandle() %p added handle %p in position %zu", this, handle, i);
Eric Laurentca7cc822012-11-19 14:55:58 -0800238 mHandles.insertAt(handle, i);
239 return status;
240}
241
Andy Hung6ac17eb2023-06-20 18:56:17 -0700242status_t EffectBase::updatePolicyState()
Eric Laurent6c796322019-04-09 14:13:17 -0700243{
244 status_t status = NO_ERROR;
245 bool doRegister = false;
246 bool registered = false;
247 bool doEnable = false;
248 bool enabled = false;
Mikhail Naganov379d6872020-03-26 13:04:11 -0700249 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800250 product_strategy_t strategy = PRODUCT_STRATEGY_NONE;
Eric Laurent6c796322019-04-09 14:13:17 -0700251
252 {
Andy Hungf65f5a72023-08-29 12:19:17 -0700253 audio_utils::lock_guard _l(mutex());
Eric Laurentd66d7a12021-07-13 13:35:32 +0200254
255 if ((isInternal_l() && !mPolicyRegistered)
256 || !getCallback()->isAudioPolicyReady()) {
257 return NO_ERROR;
258 }
259
Eric Laurent6c796322019-04-09 14:13:17 -0700260 // register effect when first handle is attached and unregister when last handle is removed
261 if (mPolicyRegistered != mHandles.size() > 0) {
262 doRegister = true;
263 mPolicyRegistered = mHandles.size() > 0;
264 if (mPolicyRegistered) {
Andy Hungfda44002021-06-03 17:23:16 -0700265 const auto callback = getCallback();
266 io = callback->io();
267 strategy = callback->strategy();
Eric Laurent6c796322019-04-09 14:13:17 -0700268 }
269 }
270 // enable effect when registered according to enable state requested by controlling handle
271 if (mHandles.size() > 0) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700272 IAfEffectHandle *handle = controlHandle_l();
Eric Laurent6c796322019-04-09 14:13:17 -0700273 if (handle != nullptr && mPolicyEnabled != handle->enabled()) {
274 doEnable = true;
275 mPolicyEnabled = handle->enabled();
276 }
277 }
278 registered = mPolicyRegistered;
279 enabled = mPolicyEnabled;
Eric Laurentb9d06642021-03-18 15:52:11 +0100280 // The simultaneous release of two EffectHandles with the same EffectModule
281 // may cause us to call this method at the same time.
282 // This may deadlock under some circumstances (b/180941720). Avoid this.
283 if (!doRegister && !(registered && doEnable)) {
284 return NO_ERROR;
285 }
Eric Laurent6c796322019-04-09 14:13:17 -0700286 }
Andy Hungf65f5a72023-08-29 12:19:17 -0700287 policyMutex().lock();
Eric Laurent6c796322019-04-09 14:13:17 -0700288 ALOGV("%s name %s id %d session %d doRegister %d registered %d doEnable %d enabled %d",
289 __func__, mDescriptor.name, mId, mSessionId, doRegister, registered, doEnable, enabled);
290 if (doRegister) {
291 if (registered) {
292 status = AudioSystem::registerEffect(
293 &mDescriptor,
294 io,
295 strategy,
296 mSessionId,
297 mId);
298 } else {
299 status = AudioSystem::unregisterEffect(mId);
300 }
301 }
302 if (registered && doEnable) {
303 status = AudioSystem::setEffectEnabled(mId, enabled);
304 }
Andy Hungf65f5a72023-08-29 12:19:17 -0700305 policyMutex().unlock();
Eric Laurent6c796322019-04-09 14:13:17 -0700306
307 return status;
308}
309
310
Andy Hung6ac17eb2023-06-20 18:56:17 -0700311ssize_t EffectBase::removeHandle(IAfEffectHandle *handle)
Eric Laurentca7cc822012-11-19 14:55:58 -0800312{
Andy Hungf65f5a72023-08-29 12:19:17 -0700313 audio_utils::lock_guard _l(mutex());
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800314 return removeHandle_l(handle);
315}
316
Andy Hung6ac17eb2023-06-20 18:56:17 -0700317ssize_t EffectBase::removeHandle_l(IAfEffectHandle *handle)
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800318{
Eric Laurentca7cc822012-11-19 14:55:58 -0800319 size_t size = mHandles.size();
320 size_t i;
321 for (i = 0; i < size; i++) {
322 if (mHandles[i] == handle) {
323 break;
324 }
325 }
326 if (i == size) {
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800327 ALOGW("%s %p handle not found %p", __FUNCTION__, this, handle);
328 return BAD_VALUE;
Eric Laurentca7cc822012-11-19 14:55:58 -0800329 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800330 ALOGV("removeHandle_l() %p removed handle %p in position %zu", this, handle, i);
Eric Laurentca7cc822012-11-19 14:55:58 -0800331
332 mHandles.removeAt(i);
333 // if removed from first place, move effect control from this handle to next in line
334 if (i == 0) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700335 IAfEffectHandle *h = controlHandle_l();
Eric Laurentca7cc822012-11-19 14:55:58 -0800336 if (h != NULL) {
337 h->setControl(true /*hasControl*/, true /*signal*/ , handle->enabled() /*enabled*/);
338 }
339 }
340
Jaideep Sharmaed8688022020-08-07 14:09:16 +0530341 // Prevent calls to process() and other functions on effect interface from now on.
342 // The effect engine will be released by the destructor when the last strong reference on
343 // this object is released which can happen after next process is called.
Eric Laurentca7cc822012-11-19 14:55:58 -0800344 if (mHandles.size() == 0 && !mPinned) {
345 mState = DESTROYED;
346 }
347
348 return mHandles.size();
349}
350
Andy Hungf65f5a72023-08-29 12:19:17 -0700351// must be called with EffectModule::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -0700352IAfEffectHandle *EffectBase::controlHandle_l()
Eric Laurentca7cc822012-11-19 14:55:58 -0800353{
354 // the first valid handle in the list has control over the module
355 for (size_t i = 0; i < mHandles.size(); i++) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700356 IAfEffectHandle *h = mHandles[i];
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800357 if (h != NULL && !h->disconnected()) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800358 return h;
359 }
360 }
361
362 return NULL;
363}
364
Eric Laurentf10c7092016-12-06 17:09:56 -0800365// unsafe method called when the effect parent thread has been destroyed
Andy Hung6ac17eb2023-06-20 18:56:17 -0700366ssize_t EffectBase::disconnectHandle(IAfEffectHandle *handle, bool unpinIfLast)
Eric Laurentf10c7092016-12-06 17:09:56 -0800367{
Andy Hungfda44002021-06-03 17:23:16 -0700368 const auto callback = getCallback();
Eric Laurentf10c7092016-12-06 17:09:56 -0800369 ALOGV("disconnect() %p handle %p", this, handle);
Andy Hungfda44002021-06-03 17:23:16 -0700370 if (callback->disconnectEffectHandle(handle, unpinIfLast)) {
Eric Laurent6b446ce2019-12-13 10:56:31 -0800371 return mHandles.size();
372 }
373
Andy Hungf65f5a72023-08-29 12:19:17 -0700374 audio_utils::lock_guard _l(mutex());
Eric Laurentf10c7092016-12-06 17:09:56 -0800375 ssize_t numHandles = removeHandle_l(handle);
376 if ((numHandles == 0) && (!mPinned || unpinIfLast)) {
Andy Hungf65f5a72023-08-29 12:19:17 -0700377 mutex().unlock();
Andy Hungfda44002021-06-03 17:23:16 -0700378 callback->updateOrphanEffectChains(this);
Andy Hungf65f5a72023-08-29 12:19:17 -0700379 mutex().lock();
Eric Laurentf10c7092016-12-06 17:09:56 -0800380 }
381 return numHandles;
382}
383
Andy Hung6ac17eb2023-06-20 18:56:17 -0700384bool EffectBase::purgeHandles()
Eric Laurent41709552019-12-16 19:34:05 -0800385{
386 bool enabled = false;
Andy Hungf65f5a72023-08-29 12:19:17 -0700387 audio_utils::lock_guard _l(mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -0700388 IAfEffectHandle *handle = controlHandle_l();
Eric Laurent41709552019-12-16 19:34:05 -0800389 if (handle != NULL) {
390 enabled = handle->enabled();
391 }
392 mHandles.clear();
393 return enabled;
394}
395
Andy Hung6ac17eb2023-06-20 18:56:17 -0700396void EffectBase::checkSuspendOnEffectEnabled(bool enabled, bool threadLocked) {
Andy Hungfda44002021-06-03 17:23:16 -0700397 getCallback()->checkSuspendOnEffectEnabled(this, enabled, threadLocked);
Eric Laurent41709552019-12-16 19:34:05 -0800398}
399
400static String8 effectFlagsToString(uint32_t flags) {
401 String8 s;
402
403 s.append("conn. mode: ");
404 switch (flags & EFFECT_FLAG_TYPE_MASK) {
405 case EFFECT_FLAG_TYPE_INSERT: s.append("insert"); break;
406 case EFFECT_FLAG_TYPE_AUXILIARY: s.append("auxiliary"); break;
407 case EFFECT_FLAG_TYPE_REPLACE: s.append("replace"); break;
408 case EFFECT_FLAG_TYPE_PRE_PROC: s.append("preproc"); break;
409 case EFFECT_FLAG_TYPE_POST_PROC: s.append("postproc"); break;
410 default: s.append("unknown/reserved"); break;
411 }
412 s.append(", ");
413
414 s.append("insert pref: ");
415 switch (flags & EFFECT_FLAG_INSERT_MASK) {
416 case EFFECT_FLAG_INSERT_ANY: s.append("any"); break;
417 case EFFECT_FLAG_INSERT_FIRST: s.append("first"); break;
418 case EFFECT_FLAG_INSERT_LAST: s.append("last"); break;
419 case EFFECT_FLAG_INSERT_EXCLUSIVE: s.append("exclusive"); break;
420 default: s.append("unknown/reserved"); break;
421 }
422 s.append(", ");
423
424 s.append("volume mgmt: ");
425 switch (flags & EFFECT_FLAG_VOLUME_MASK) {
426 case EFFECT_FLAG_VOLUME_NONE: s.append("none"); break;
427 case EFFECT_FLAG_VOLUME_CTRL: s.append("implements control"); break;
428 case EFFECT_FLAG_VOLUME_IND: s.append("requires indication"); break;
429 case EFFECT_FLAG_VOLUME_MONITOR: s.append("monitors volume"); break;
430 default: s.append("unknown/reserved"); break;
431 }
432 s.append(", ");
433
434 uint32_t devind = flags & EFFECT_FLAG_DEVICE_MASK;
435 if (devind) {
436 s.append("device indication: ");
437 switch (devind) {
438 case EFFECT_FLAG_DEVICE_IND: s.append("requires updates"); break;
439 default: s.append("unknown/reserved"); break;
440 }
441 s.append(", ");
442 }
443
444 s.append("input mode: ");
445 switch (flags & EFFECT_FLAG_INPUT_MASK) {
446 case EFFECT_FLAG_INPUT_DIRECT: s.append("direct"); break;
447 case EFFECT_FLAG_INPUT_PROVIDER: s.append("provider"); break;
448 case EFFECT_FLAG_INPUT_BOTH: s.append("direct+provider"); break;
449 default: s.append("not set"); break;
450 }
451 s.append(", ");
452
453 s.append("output mode: ");
454 switch (flags & EFFECT_FLAG_OUTPUT_MASK) {
455 case EFFECT_FLAG_OUTPUT_DIRECT: s.append("direct"); break;
456 case EFFECT_FLAG_OUTPUT_PROVIDER: s.append("provider"); break;
457 case EFFECT_FLAG_OUTPUT_BOTH: s.append("direct+provider"); break;
458 default: s.append("not set"); break;
459 }
460 s.append(", ");
461
462 uint32_t accel = flags & EFFECT_FLAG_HW_ACC_MASK;
463 if (accel) {
464 s.append("hardware acceleration: ");
465 switch (accel) {
466 case EFFECT_FLAG_HW_ACC_SIMPLE: s.append("non-tunneled"); break;
467 case EFFECT_FLAG_HW_ACC_TUNNEL: s.append("tunneled"); break;
468 default: s.append("unknown/reserved"); break;
469 }
470 s.append(", ");
471 }
472
473 uint32_t modeind = flags & EFFECT_FLAG_AUDIO_MODE_MASK;
474 if (modeind) {
475 s.append("mode indication: ");
476 switch (modeind) {
477 case EFFECT_FLAG_AUDIO_MODE_IND: s.append("required"); break;
478 default: s.append("unknown/reserved"); break;
479 }
480 s.append(", ");
481 }
482
483 uint32_t srcind = flags & EFFECT_FLAG_AUDIO_SOURCE_MASK;
484 if (srcind) {
485 s.append("source indication: ");
486 switch (srcind) {
487 case EFFECT_FLAG_AUDIO_SOURCE_IND: s.append("required"); break;
488 default: s.append("unknown/reserved"); break;
489 }
490 s.append(", ");
491 }
492
493 if (flags & EFFECT_FLAG_OFFLOAD_MASK) {
494 s.append("offloadable, ");
495 }
496
497 int len = s.length();
498 if (s.length() > 2) {
499 (void) s.lockBuffer(len);
500 s.unlockBuffer(len - 2);
501 }
502 return s;
503}
504
Andy Hung6ac17eb2023-06-20 18:56:17 -0700505void EffectBase::dump(int fd, const Vector<String16>& args __unused) const
Andy Hung920f6572022-10-06 12:09:49 -0700506NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Eric Laurent41709552019-12-16 19:34:05 -0800507{
508 String8 result;
509
510 result.appendFormat("\tEffect ID %d:\n", mId);
511
Andy Hungf65f5a72023-08-29 12:19:17 -0700512 const bool locked = afutils::dumpTryLock(mutex());
Eric Laurent41709552019-12-16 19:34:05 -0800513 // failed to lock - AudioFlinger is probably deadlocked
514 if (!locked) {
515 result.append("\t\tCould not lock Fx mutex:\n");
516 }
François Gaffie163ce832023-06-28 11:36:35 +0200517 bool isInternal = isInternal_l();
518 result.append("\t\tSession State Registered Internal Enabled Suspended:\n");
519 result.appendFormat("\t\t%05d %03d %s %s %s %s\n",
520 mSessionId, mState, mPolicyRegistered ? "y" : "n", isInternal ? "y" : "n",
521 ((isInternal && isEnabled()) || (!isInternal && mPolicyEnabled)) ? "y" : "n",
522 mSuspended ? "y" : "n");
Eric Laurent41709552019-12-16 19:34:05 -0800523
524 result.append("\t\tDescriptor:\n");
525 char uuidStr[64];
526 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
527 result.appendFormat("\t\t- UUID: %s\n", uuidStr);
528 AudioEffect::guidToString(&mDescriptor.type, uuidStr, sizeof(uuidStr));
529 result.appendFormat("\t\t- TYPE: %s\n", uuidStr);
530 result.appendFormat("\t\t- apiVersion: %08X\n\t\t- flags: %08X (%s)\n",
531 mDescriptor.apiVersion,
532 mDescriptor.flags,
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000533 effectFlagsToString(mDescriptor.flags).c_str());
Eric Laurent41709552019-12-16 19:34:05 -0800534 result.appendFormat("\t\t- name: %s\n",
535 mDescriptor.name);
536
537 result.appendFormat("\t\t- implementor: %s\n",
538 mDescriptor.implementor);
539
540 result.appendFormat("\t\t%zu Clients:\n", mHandles.size());
541 result.append("\t\t\t Pid Priority Ctrl Locked client server\n");
542 char buffer[256];
543 for (size_t i = 0; i < mHandles.size(); ++i) {
Andy Hung6ac17eb2023-06-20 18:56:17 -0700544 IAfEffectHandle *handle = mHandles[i];
Eric Laurent41709552019-12-16 19:34:05 -0800545 if (handle != NULL && !handle->disconnected()) {
546 handle->dumpToBuffer(buffer, sizeof(buffer));
547 result.append(buffer);
548 }
549 }
550 if (locked) {
Andy Hungf65f5a72023-08-29 12:19:17 -0700551 mutex().unlock();
Eric Laurent41709552019-12-16 19:34:05 -0800552 }
553
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000554 write(fd, result.c_str(), result.length());
Eric Laurent41709552019-12-16 19:34:05 -0800555}
556
557// ----------------------------------------------------------------------------
558// EffectModule implementation
559// ----------------------------------------------------------------------------
560
561#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -0700562#define LOG_TAG "EffectModule"
Eric Laurent41709552019-12-16 19:34:05 -0800563
Andy Hung6ac17eb2023-06-20 18:56:17 -0700564EffectModule::EffectModule(const sp<EffectCallbackInterface>& callback,
Eric Laurent41709552019-12-16 19:34:05 -0800565 effect_descriptor_t *desc,
566 int id,
567 audio_session_t sessionId,
Eric Laurentb82e6b72019-11-22 17:25:04 -0800568 bool pinned,
569 audio_port_handle_t deviceId)
Eric Laurent41709552019-12-16 19:34:05 -0800570 : EffectBase(callback, desc, id, sessionId, pinned),
571 // clear mConfig to ensure consistent initial value of buffer framecount
572 // in case buffers are associated by setInBuffer() or setOutBuffer()
Shunkai Yaod125e402024-01-20 03:19:06 +0000573 // prior to configure_l().
Eric Laurent41709552019-12-16 19:34:05 -0800574 mConfig{{}, {}},
575 mStatus(NO_INIT),
Shunkai Yaod125e402024-01-20 03:19:06 +0000576 mMaxDisableWaitCnt(1), // set by configure_l(), should be >= 1
Eric Laurent41709552019-12-16 19:34:05 -0800577 mDisableWaitCnt(0), // set by process() and updateState()
David Li6c8ac4b2021-06-22 22:17:52 +0800578 mOffloaded(false),
Mikhail Naganov8d7da002022-04-19 21:21:23 +0000579 mIsOutput(false)
Eric Laurent41709552019-12-16 19:34:05 -0800580 , mSupportsFloat(false)
Eric Laurent41709552019-12-16 19:34:05 -0800581{
582 ALOGV("Constructor %p pinned %d", this, pinned);
583 int lStatus;
584
585 // create effect engine from effect factory
586 mStatus = callback->createEffectHal(
Eric Laurentb82e6b72019-11-22 17:25:04 -0800587 &desc->uuid, sessionId, deviceId, &mEffectInterface);
Eric Laurent41709552019-12-16 19:34:05 -0800588 if (mStatus != NO_ERROR) {
589 return;
590 }
Shunkai Yaod125e402024-01-20 03:19:06 +0000591 lStatus = init_l();
Eric Laurent41709552019-12-16 19:34:05 -0800592 if (lStatus < 0) {
593 mStatus = lStatus;
594 goto Error;
595 }
596
Shunkai Yaod125e402024-01-20 03:19:06 +0000597 setOffloaded_l(callback->isOffload(), callback->io());
Eric Laurent41709552019-12-16 19:34:05 -0800598 ALOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface.get());
599
600 return;
601Error:
602 mEffectInterface.clear();
603 ALOGV("Constructor Error %d", mStatus);
604}
605
Andy Hung6ac17eb2023-06-20 18:56:17 -0700606EffectModule::~EffectModule()
Eric Laurent41709552019-12-16 19:34:05 -0800607{
608 ALOGV("Destructor %p", this);
609 if (mEffectInterface != 0) {
610 char uuidStr[64];
611 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
612 ALOGW("EffectModule %p destructor called with unreleased interface, effect %s",
613 this, uuidStr);
614 release_l();
615 }
616
617}
618
Shunkai Yaod125e402024-01-20 03:19:06 +0000619bool EffectModule::updateState_l() {
Andy Hungf65f5a72023-08-29 12:19:17 -0700620 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -0800621
Eric Laurentfa1e1232016-08-02 19:01:49 -0700622 bool started = false;
Eric Laurentca7cc822012-11-19 14:55:58 -0800623 switch (mState) {
624 case RESTART:
625 reset_l();
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -0700626 FALLTHROUGH_INTENDED;
Eric Laurentca7cc822012-11-19 14:55:58 -0800627
628 case STARTING:
629 // clear auxiliary effect input buffer for next accumulation
630 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
631 memset(mConfig.inputCfg.buffer.raw,
632 0,
633 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
634 }
Shunkai Yaod125e402024-01-20 03:19:06 +0000635 if (start_ll() == NO_ERROR) {
Eric Laurentd0ebb532013-04-02 16:41:41 -0700636 mState = ACTIVE;
Eric Laurentfa1e1232016-08-02 19:01:49 -0700637 started = true;
Eric Laurentd0ebb532013-04-02 16:41:41 -0700638 } else {
639 mState = IDLE;
640 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800641 break;
642 case STOPPING:
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900643 // volume control for offload and direct threads must take effect immediately.
Shunkai Yaod125e402024-01-20 03:19:06 +0000644 if (stop_ll() == NO_ERROR
645 && !(isVolumeControl() && isOffloadedOrDirect_l())) {
Eric Laurentd0ebb532013-04-02 16:41:41 -0700646 mDisableWaitCnt = mMaxDisableWaitCnt;
647 } else {
648 mDisableWaitCnt = 1; // will cause immediate transition to IDLE
649 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800650 mState = STOPPED;
651 break;
652 case STOPPED:
653 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
654 // turn off sequence.
655 if (--mDisableWaitCnt == 0) {
656 reset_l();
657 mState = IDLE;
658 }
659 break;
Eric Laurentde8caf42021-08-11 17:19:25 +0200660 case ACTIVE:
661 for (size_t i = 0; i < mHandles.size(); i++) {
662 if (!mHandles[i]->disconnected()) {
663 mHandles[i]->framesProcessed(mConfig.inputCfg.buffer.frameCount);
664 }
665 }
666 break;
Eric Laurentca7cc822012-11-19 14:55:58 -0800667 default: //IDLE , ACTIVE, DESTROYED
668 break;
669 }
Eric Laurentfa1e1232016-08-02 19:01:49 -0700670
671 return started;
Eric Laurentca7cc822012-11-19 14:55:58 -0800672}
673
Andy Hung6ac17eb2023-06-20 18:56:17 -0700674void EffectModule::process()
Eric Laurentca7cc822012-11-19 14:55:58 -0800675{
Andy Hungf65f5a72023-08-29 12:19:17 -0700676 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -0800677
Mikhail Naganov022b9952017-01-04 16:36:51 -0800678 if (mState == DESTROYED || mEffectInterface == 0 || mInBuffer == 0 || mOutBuffer == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800679 return;
680 }
681
rago94a1ee82017-07-21 15:11:02 -0700682 const uint32_t inChannelCount =
683 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
684 const uint32_t outChannelCount =
685 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
686 const bool auxType =
687 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
688
Andy Hungfa69ca32017-11-30 10:07:53 -0800689 // safeInputOutputSampleCount is 0 if the channel count between input and output
690 // buffers do not match. This prevents automatic accumulation or copying between the
691 // input and output effect buffers without an intermediary effect process.
692 // TODO: consider implementing channel conversion.
693 const size_t safeInputOutputSampleCount =
Andy Hungdd2e7a82018-10-31 14:19:13 -0700694 mInChannelCountRequested != mOutChannelCountRequested ? 0
695 : mOutChannelCountRequested * std::min(
Andy Hungfa69ca32017-11-30 10:07:53 -0800696 mConfig.inputCfg.buffer.frameCount,
697 mConfig.outputCfg.buffer.frameCount);
698 const auto accumulateInputToOutput = [this, safeInputOutputSampleCount]() {
Andy Hungfa69ca32017-11-30 10:07:53 -0800699 accumulate_float(
700 mConfig.outputCfg.buffer.f32,
701 mConfig.inputCfg.buffer.f32,
702 safeInputOutputSampleCount);
Andy Hungfa69ca32017-11-30 10:07:53 -0800703 };
704 const auto copyInputToOutput = [this, safeInputOutputSampleCount]() {
Andy Hungfa69ca32017-11-30 10:07:53 -0800705 memcpy(
706 mConfig.outputCfg.buffer.f32,
707 mConfig.inputCfg.buffer.f32,
708 safeInputOutputSampleCount * sizeof(*mConfig.outputCfg.buffer.f32));
Andy Hungfa69ca32017-11-30 10:07:53 -0800709 };
710
Eric Laurentca7cc822012-11-19 14:55:58 -0800711 if (isProcessEnabled()) {
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700712 int ret;
713 if (isProcessImplemented()) {
rago94a1ee82017-07-21 15:11:02 -0700714 if (auxType) {
715 // We overwrite the aux input buffer here and clear after processing.
Andy Hung9aad48c2017-11-29 10:29:19 -0800716 // aux input is always mono.
rago94a1ee82017-07-21 15:11:02 -0700717
Andy Hung26836922023-05-22 17:31:57 -0700718 if (!mSupportsFloat) {
Andy Hung116a4982017-11-30 10:15:08 -0800719 memcpy_to_i16_from_float(
720 mConfig.inputCfg.buffer.s16,
721 mConfig.inputCfg.buffer.f32,
722 mConfig.inputCfg.buffer.frameCount);
rago94a1ee82017-07-21 15:11:02 -0700723 }
rago94a1ee82017-07-21 15:11:02 -0700724 }
Andy Hung9aad48c2017-11-29 10:29:19 -0800725 sp<EffectBufferHalInterface> inBuffer = mInBuffer;
726 sp<EffectBufferHalInterface> outBuffer = mOutBuffer;
727
728 if (!auxType && mInChannelCountRequested != inChannelCount) {
729 adjust_channels(
730 inBuffer->audioBuffer()->f32, mInChannelCountRequested,
731 mInConversionBuffer->audioBuffer()->f32, inChannelCount,
732 sizeof(float),
733 sizeof(float)
734 * mInChannelCountRequested * mConfig.inputCfg.buffer.frameCount);
735 inBuffer = mInConversionBuffer;
736 }
737 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE
738 && mOutChannelCountRequested != outChannelCount) {
739 adjust_selected_channels(
740 outBuffer->audioBuffer()->f32, mOutChannelCountRequested,
741 mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
742 sizeof(float),
743 sizeof(float)
744 * mOutChannelCountRequested * mConfig.outputCfg.buffer.frameCount);
745 outBuffer = mOutConversionBuffer;
746 }
Andy Hungfa69ca32017-11-30 10:07:53 -0800747 if (!mSupportsFloat) { // convert input to int16_t as effect doesn't support float.
748 if (!auxType) {
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800749 if (mInConversionBuffer == nullptr) {
Andy Hungfa69ca32017-11-30 10:07:53 -0800750 ALOGW("%s: mInConversionBuffer is null, bypassing", __func__);
751 goto data_bypass;
rago94a1ee82017-07-21 15:11:02 -0700752 }
Andy Hungfa69ca32017-11-30 10:07:53 -0800753 memcpy_to_i16_from_float(
754 mInConversionBuffer->audioBuffer()->s16,
Andy Hung9aad48c2017-11-29 10:29:19 -0800755 inBuffer->audioBuffer()->f32,
Andy Hungfa69ca32017-11-30 10:07:53 -0800756 inChannelCount * mConfig.inputCfg.buffer.frameCount);
Andy Hung9aad48c2017-11-29 10:29:19 -0800757 inBuffer = mInConversionBuffer;
rago94a1ee82017-07-21 15:11:02 -0700758 }
Andy Hungfa69ca32017-11-30 10:07:53 -0800759 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800760 if (mOutConversionBuffer == nullptr) {
Andy Hungfa69ca32017-11-30 10:07:53 -0800761 ALOGW("%s: mOutConversionBuffer is null, bypassing", __func__);
762 goto data_bypass;
763 }
764 memcpy_to_i16_from_float(
765 mOutConversionBuffer->audioBuffer()->s16,
Andy Hung9aad48c2017-11-29 10:29:19 -0800766 outBuffer->audioBuffer()->f32,
Andy Hungfa69ca32017-11-30 10:07:53 -0800767 outChannelCount * mConfig.outputCfg.buffer.frameCount);
Andy Hung9aad48c2017-11-29 10:29:19 -0800768 outBuffer = mOutConversionBuffer;
rago94a1ee82017-07-21 15:11:02 -0700769 }
770 }
Mikhail Naganov022b9952017-01-04 16:36:51 -0800771 ret = mEffectInterface->process();
Andy Hungfa69ca32017-11-30 10:07:53 -0800772 if (!mSupportsFloat) { // convert output int16_t back to float.
Andy Hung9aad48c2017-11-29 10:29:19 -0800773 sp<EffectBufferHalInterface> target =
774 mOutChannelCountRequested != outChannelCount
775 ? mOutConversionBuffer : mOutBuffer;
776
Andy Hungfa69ca32017-11-30 10:07:53 -0800777 memcpy_to_float_from_i16(
Andy Hung9aad48c2017-11-29 10:29:19 -0800778 target->audioBuffer()->f32,
Andy Hungfa69ca32017-11-30 10:07:53 -0800779 mOutConversionBuffer->audioBuffer()->s16,
780 outChannelCount * mConfig.outputCfg.buffer.frameCount);
781 }
Andy Hung9aad48c2017-11-29 10:29:19 -0800782 if (mOutChannelCountRequested != outChannelCount) {
783 adjust_selected_channels(mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
784 mOutBuffer->audioBuffer()->f32, mOutChannelCountRequested,
785 sizeof(float),
786 sizeof(float) * outChannelCount * mConfig.outputCfg.buffer.frameCount);
787 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700788 } else {
rago94a1ee82017-07-21 15:11:02 -0700789 data_bypass:
rago94a1ee82017-07-21 15:11:02 -0700790 if (!auxType /* aux effects do not require data bypass */
Andy Hungfa69ca32017-11-30 10:07:53 -0800791 && mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700792 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
Andy Hungfa69ca32017-11-30 10:07:53 -0800793 accumulateInputToOutput();
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700794 } else {
Andy Hungfa69ca32017-11-30 10:07:53 -0800795 copyInputToOutput();
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700796 }
797 }
798 ret = -ENODATA;
799 }
Andy Hungfa69ca32017-11-30 10:07:53 -0800800
Eric Laurentca7cc822012-11-19 14:55:58 -0800801 // force transition to IDLE state when engine is ready
802 if (mState == STOPPED && ret == -ENODATA) {
803 mDisableWaitCnt = 1;
804 }
805
806 // clear auxiliary effect input buffer for next accumulation
rago94a1ee82017-07-21 15:11:02 -0700807 if (auxType) {
Andy Hung116a4982017-11-30 10:15:08 -0800808 const size_t size =
809 mConfig.inputCfg.buffer.frameCount * inChannelCount * sizeof(float);
rago94a1ee82017-07-21 15:11:02 -0700810 memset(mConfig.inputCfg.buffer.raw, 0, size);
Eric Laurentca7cc822012-11-19 14:55:58 -0800811 }
812 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
rago94a1ee82017-07-21 15:11:02 -0700813 // mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw
Eric Laurentca7cc822012-11-19 14:55:58 -0800814 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
815 // If an insert effect is idle and input buffer is different from output buffer,
816 // accumulate input onto output
Andy Hungfda44002021-06-03 17:23:16 -0700817 if (getCallback()->activeTrackCnt() != 0) {
Andy Hunge8ac1b22018-10-31 14:22:35 -0700818 // similar handling with data_bypass above.
819 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
820 accumulateInputToOutput();
821 } else { // EFFECT_BUFFER_ACCESS_WRITE
822 copyInputToOutput();
823 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800824 }
825 }
826}
827
Andy Hung6ac17eb2023-06-20 18:56:17 -0700828void EffectModule::reset_l()
Eric Laurentca7cc822012-11-19 14:55:58 -0800829{
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700830 if (mStatus != NO_ERROR || mEffectInterface == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800831 return;
832 }
Shunkai Yaoc92f3df2023-09-20 23:10:22 +0000833
834 int reply = 0;
835 uint32_t replySize = sizeof(reply);
836 mEffectInterface->command(EFFECT_CMD_RESET, 0, NULL, &replySize, &reply);
Eric Laurentca7cc822012-11-19 14:55:58 -0800837}
838
Shunkai Yaod125e402024-01-20 03:19:06 +0000839status_t EffectModule::configure_l()
Eric Laurentca7cc822012-11-19 14:55:58 -0800840{
Shunkai Yaod125e402024-01-20 03:19:06 +0000841 ALOGVV("%s started", __func__);
Eric Laurentd0ebb532013-04-02 16:41:41 -0700842 status_t status;
Eric Laurentd0ebb532013-04-02 16:41:41 -0700843 uint32_t size;
844 audio_channel_mask_t channelMask;
Andy Hungfda44002021-06-03 17:23:16 -0700845 sp<EffectCallbackInterface> callback;
Eric Laurentd0ebb532013-04-02 16:41:41 -0700846
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700847 if (mEffectInterface == 0) {
Eric Laurentd0ebb532013-04-02 16:41:41 -0700848 status = NO_INIT;
849 goto exit;
Eric Laurentca7cc822012-11-19 14:55:58 -0800850 }
851
Eric Laurentca7cc822012-11-19 14:55:58 -0800852 // TODO: handle configuration of effects replacing track process
Andy Hung9aad48c2017-11-29 10:29:19 -0800853 // TODO: handle configuration of input (record) SW effects above the HAL,
854 // similar to output EFFECT_FLAG_TYPE_INSERT/REPLACE,
855 // in which case input channel masks should be used here.
Andy Hungfda44002021-06-03 17:23:16 -0700856 callback = getCallback();
Eric Laurentf1f22e72021-07-13 14:04:14 +0200857 channelMask = callback->inChannelMask(mId);
Andy Hung9aad48c2017-11-29 10:29:19 -0800858 mConfig.inputCfg.channels = channelMask;
Eric Laurentf1f22e72021-07-13 14:04:14 +0200859 mConfig.outputCfg.channels = callback->outChannelMask();
Eric Laurentca7cc822012-11-19 14:55:58 -0800860
861 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Andy Hung9aad48c2017-11-29 10:29:19 -0800862 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_MONO) {
863 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
864 ALOGV("Overriding auxiliary effect input channels %#x as MONO",
865 mConfig.inputCfg.channels);
866 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800867 }
jiabineb3bda02020-06-30 14:07:03 -0700868 if (isHapticGenerator()) {
Andy Hungfda44002021-06-03 17:23:16 -0700869 audio_channel_mask_t hapticChannelMask = callback->hapticChannelMask();
jiabineb3bda02020-06-30 14:07:03 -0700870 mConfig.inputCfg.channels |= hapticChannelMask;
871 mConfig.outputCfg.channels |= hapticChannelMask;
872 }
Andy Hung9aad48c2017-11-29 10:29:19 -0800873 mInChannelCountRequested =
874 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
875 mOutChannelCountRequested =
876 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
Ricardo Garciad11da702015-05-28 12:14:12 -0700877
Andy Hung319587b2023-05-23 14:01:03 -0700878 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
879 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
Yuuki Yokoyamae17f8312017-05-26 19:06:33 +0900880
881 // Don't use sample rate for thread if effect isn't offloadable.
Shunkai Yaod125e402024-01-20 03:19:06 +0000882 if (callback->isOffloadOrDirect() && !isOffloaded_l()) {
Yuuki Yokoyamae17f8312017-05-26 19:06:33 +0900883 mConfig.inputCfg.samplingRate = DEFAULT_OUTPUT_SAMPLE_RATE;
884 ALOGV("Overriding effect input as 48kHz");
885 } else {
Andy Hungfda44002021-06-03 17:23:16 -0700886 mConfig.inputCfg.samplingRate = callback->sampleRate();
Yuuki Yokoyamae17f8312017-05-26 19:06:33 +0900887 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800888 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
889 mConfig.inputCfg.bufferProvider.cookie = NULL;
890 mConfig.inputCfg.bufferProvider.getBuffer = NULL;
891 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
892 mConfig.outputCfg.bufferProvider.cookie = NULL;
893 mConfig.outputCfg.bufferProvider.getBuffer = NULL;
894 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
895 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
896 // Insert effect:
Eric Laurent3f75a5b2019-11-12 15:55:51 -0800897 // - in global sessions (e.g AUDIO_SESSION_OUTPUT_MIX),
Eric Laurentca7cc822012-11-19 14:55:58 -0800898 // always overwrites output buffer: input buffer == output buffer
899 // - in other sessions:
900 // last effect in the chain accumulates in output buffer: input buffer != output buffer
901 // other effect: overwrites output buffer: input buffer == output buffer
902 // Auxiliary effect:
903 // accumulates in output buffer: input buffer != output buffer
904 // Therefore: accumulate <=> input buffer != output buffer
Andy Hung799c8d02021-10-28 17:05:40 -0700905 mConfig.outputCfg.accessMode = requiredEffectBufferAccessMode();
Eric Laurentca7cc822012-11-19 14:55:58 -0800906 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
907 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
Andy Hungfda44002021-06-03 17:23:16 -0700908 mConfig.inputCfg.buffer.frameCount = callback->frameCount();
Eric Laurentca7cc822012-11-19 14:55:58 -0800909 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
Mikhail Naganov8d7da002022-04-19 21:21:23 +0000910 mIsOutput = callback->isOutput();
Eric Laurentca7cc822012-11-19 14:55:58 -0800911
Shunkai Yaod125e402024-01-20 03:19:06 +0000912 ALOGV("%s %p chain %p buffer %p framecount %zu", __func__, this,
913 callback->chain().promote().get(), mConfig.inputCfg.buffer.raw,
914 mConfig.inputCfg.buffer.frameCount);
Eric Laurentca7cc822012-11-19 14:55:58 -0800915
916 status_t cmdStatus;
Eric Laurentd0ebb532013-04-02 16:41:41 -0700917 size = sizeof(int);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700918 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
Andy Hung9aad48c2017-11-29 10:29:19 -0800919 sizeof(mConfig),
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700920 &mConfig,
921 &size,
922 &cmdStatus);
rago94a1ee82017-07-21 15:11:02 -0700923 if (status == NO_ERROR) {
Eric Laurentca7cc822012-11-19 14:55:58 -0800924 status = cmdStatus;
925 }
Andy Hung9aad48c2017-11-29 10:29:19 -0800926
Andy Hung9aad48c2017-11-29 10:29:19 -0800927 if (status != NO_ERROR &&
Andy Hungba8e52b2023-05-11 14:33:03 -0700928 EffectConfiguration::isHidl() && // only HIDL effects support channel conversion
Mikhail Naganov8d7da002022-04-19 21:21:23 +0000929 mIsOutput &&
Andy Hung9aad48c2017-11-29 10:29:19 -0800930 (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
931 || mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO)) {
932 // Older effects may require exact STEREO position mask.
Andy Hung01b32722018-05-18 13:52:02 -0700933 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
934 && (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
Andy Hung9aad48c2017-11-29 10:29:19 -0800935 ALOGV("Overriding effect input channels %#x as STEREO", mConfig.inputCfg.channels);
936 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
937 }
938 if (mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
939 ALOGV("Overriding effect output channels %#x as STEREO", mConfig.outputCfg.channels);
940 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
941 }
942 size = sizeof(int);
rago94a1ee82017-07-21 15:11:02 -0700943 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
Andy Hung9aad48c2017-11-29 10:29:19 -0800944 sizeof(mConfig),
rago94a1ee82017-07-21 15:11:02 -0700945 &mConfig,
946 &size,
947 &cmdStatus);
948 if (status == NO_ERROR) {
949 status = cmdStatus;
Andy Hung9aad48c2017-11-29 10:29:19 -0800950 }
951 }
Andy Hung9aad48c2017-11-29 10:29:19 -0800952
Andy Hung9aad48c2017-11-29 10:29:19 -0800953 if (status == NO_ERROR) {
954 mSupportsFloat = true;
955 }
956
Andy Hungba8e52b2023-05-11 14:33:03 -0700957 // only HIDL effects support integer conversion.
958 if (status != NO_ERROR && EffectConfiguration::isHidl()) {
Andy Hung9aad48c2017-11-29 10:29:19 -0800959 ALOGV("EFFECT_CMD_SET_CONFIG failed with float format, retry with int16_t.");
960 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
961 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
962 size = sizeof(int);
963 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
964 sizeof(mConfig),
965 &mConfig,
966 &size,
967 &cmdStatus);
968 if (status == NO_ERROR) {
969 status = cmdStatus;
970 }
971 if (status == NO_ERROR) {
rago94a1ee82017-07-21 15:11:02 -0700972 mSupportsFloat = false;
973 ALOGVV("config worked with 16 bit");
974 } else {
975 ALOGE("%s failed %d with int16_t (as well as float)", __func__, status);
Eric Laurentca7cc822012-11-19 14:55:58 -0800976 }
rago94a1ee82017-07-21 15:11:02 -0700977 }
Eric Laurentca7cc822012-11-19 14:55:58 -0800978
rago94a1ee82017-07-21 15:11:02 -0700979 if (status == NO_ERROR) {
980 // Establish Buffer strategy
981 setInBuffer(mInBuffer);
982 setOutBuffer(mOutBuffer);
983
984 // Update visualizer latency
985 if (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) {
986 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
987 effect_param_t *p = (effect_param_t *)buf32;
988
989 p->psize = sizeof(uint32_t);
990 p->vsize = sizeof(uint32_t);
991 size = sizeof(int);
992 *(int32_t *)p->data = VISUALIZER_PARAM_LATENCY;
993
Andy Hungfda44002021-06-03 17:23:16 -0700994 uint32_t latency = callback->latency();
rago94a1ee82017-07-21 15:11:02 -0700995
996 *((int32_t *)p->data + 1)= latency;
997 mEffectInterface->command(EFFECT_CMD_SET_PARAM,
998 sizeof(effect_param_t) + 8,
999 &buf32,
1000 &size,
1001 &cmdStatus);
1002 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001003 }
1004
Andy Hung05083ac2017-12-14 15:00:28 -08001005 // mConfig.outputCfg.buffer.frameCount cannot be zero.
1006 mMaxDisableWaitCnt = (uint32_t)std::max(
1007 (uint64_t)1, // mMaxDisableWaitCnt must be greater than zero.
François Gaffieb8551f62023-02-15 11:36:35 +01001008 (uint64_t)mConfig.outputCfg.buffer.frameCount == 0 ? 1
1009 : (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate
1010 / ((uint64_t)1000 * mConfig.outputCfg.buffer.frameCount)));
Eric Laurentca7cc822012-11-19 14:55:58 -08001011
Eric Laurentd0ebb532013-04-02 16:41:41 -07001012exit:
Andy Hung6f88dc42017-12-13 16:19:39 -08001013 // TODO: consider clearing mConfig on error.
Eric Laurentd0ebb532013-04-02 16:41:41 -07001014 mStatus = status;
Shunkai Yaod125e402024-01-20 03:19:06 +00001015 ALOGVV("%s ended", __func__);
Eric Laurentca7cc822012-11-19 14:55:58 -08001016 return status;
1017}
1018
Shunkai Yaod125e402024-01-20 03:19:06 +00001019status_t EffectModule::init_l()
Eric Laurentca7cc822012-11-19 14:55:58 -08001020{
Andy Hungf65f5a72023-08-29 12:19:17 -07001021 audio_utils::lock_guard _l(mutex());
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001022 if (mEffectInterface == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001023 return NO_INIT;
1024 }
1025 status_t cmdStatus;
1026 uint32_t size = sizeof(status_t);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001027 status_t status = mEffectInterface->command(EFFECT_CMD_INIT,
1028 0,
1029 NULL,
1030 &size,
1031 &cmdStatus);
Eric Laurentca7cc822012-11-19 14:55:58 -08001032 if (status == 0) {
1033 status = cmdStatus;
1034 }
1035 return status;
1036}
1037
Andy Hung6ac17eb2023-06-20 18:56:17 -07001038void EffectModule::addEffectToHal_l()
Eric Laurent1b928682014-10-02 19:41:47 -07001039{
1040 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
1041 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
Eric Laurent9f57aa82023-03-17 19:28:37 +01001042 if (mCurrentHalStream == getCallback()->io()) {
David Li6c8ac4b2021-06-22 22:17:52 +08001043 return;
1044 }
1045
Andy Hungfda44002021-06-03 17:23:16 -07001046 (void)getCallback()->addEffectToHal(mEffectInterface);
Eric Laurent9f57aa82023-03-17 19:28:37 +01001047 mCurrentHalStream = getCallback()->io();
Eric Laurent1b928682014-10-02 19:41:47 -07001048 }
1049}
1050
Shunkai Yaod125e402024-01-20 03:19:06 +00001051// start_l() must be called with EffectChain::mutex() held
1052status_t EffectModule::start_l()
Eric Laurentca7cc822012-11-19 14:55:58 -08001053{
Eric Laurentfa1e1232016-08-02 19:01:49 -07001054 status_t status;
1055 {
Andy Hungf65f5a72023-08-29 12:19:17 -07001056 audio_utils::lock_guard _l(mutex());
Shunkai Yaod125e402024-01-20 03:19:06 +00001057 status = start_ll();
Eric Laurentfa1e1232016-08-02 19:01:49 -07001058 }
Eric Laurent6b446ce2019-12-13 10:56:31 -08001059 if (status == NO_ERROR) {
Shunkai Yaod125e402024-01-20 03:19:06 +00001060 getCallback()->resetVolume_l();
Eric Laurentfa1e1232016-08-02 19:01:49 -07001061 }
1062 return status;
Eric Laurentca7cc822012-11-19 14:55:58 -08001063}
1064
Shunkai Yaod125e402024-01-20 03:19:06 +00001065status_t EffectModule::start_ll()
Eric Laurentca7cc822012-11-19 14:55:58 -08001066{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001067 if (mEffectInterface == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001068 return NO_INIT;
1069 }
Eric Laurentd0ebb532013-04-02 16:41:41 -07001070 if (mStatus != NO_ERROR) {
1071 return mStatus;
1072 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001073 status_t cmdStatus;
1074 uint32_t size = sizeof(status_t);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001075 status_t status = mEffectInterface->command(EFFECT_CMD_ENABLE,
1076 0,
1077 NULL,
1078 &size,
1079 &cmdStatus);
Eric Laurentca7cc822012-11-19 14:55:58 -08001080 if (status == 0) {
1081 status = cmdStatus;
1082 }
Eric Laurentcb4b6e92014-10-01 14:26:10 -07001083 if (status == 0) {
Eric Laurent1b928682014-10-02 19:41:47 -07001084 addEffectToHal_l();
Eric Laurentca7cc822012-11-19 14:55:58 -08001085 }
1086 return status;
1087}
1088
Shunkai Yaod125e402024-01-20 03:19:06 +00001089status_t EffectModule::stop_l()
Eric Laurentca7cc822012-11-19 14:55:58 -08001090{
Andy Hungf65f5a72023-08-29 12:19:17 -07001091 audio_utils::lock_guard _l(mutex());
Shunkai Yaod125e402024-01-20 03:19:06 +00001092 return stop_ll();
Eric Laurentca7cc822012-11-19 14:55:58 -08001093}
1094
Shunkai Yaod125e402024-01-20 03:19:06 +00001095status_t EffectModule::stop_ll()
Eric Laurentca7cc822012-11-19 14:55:58 -08001096{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001097 if (mEffectInterface == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001098 return NO_INIT;
1099 }
Eric Laurentd0ebb532013-04-02 16:41:41 -07001100 if (mStatus != NO_ERROR) {
1101 return mStatus;
1102 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001103 status_t cmdStatus = NO_ERROR;
Eric Laurentca7cc822012-11-19 14:55:58 -08001104 uint32_t size = sizeof(status_t);
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001105
Shunkai Yaod125e402024-01-20 03:19:06 +00001106 if (isVolumeControl() && isOffloadedOrDirect_l()) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001107 // We have the EffectChain and EffectModule lock, permit a reentrant call to setVolume:
1108 // resetVolume_l --> setVolume_l --> EffectModule::setVolume
1109 mSetVolumeReentrantTid = gettid();
Shunkai Yaod125e402024-01-20 03:19:06 +00001110 getCallback()->resetVolume_l();
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001111 mSetVolumeReentrantTid = INVALID_PID;
1112 }
1113
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001114 status_t status = mEffectInterface->command(EFFECT_CMD_DISABLE,
1115 0,
1116 NULL,
1117 &size,
1118 &cmdStatus);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001119 if (status == NO_ERROR) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001120 status = cmdStatus;
1121 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001122 if (status == NO_ERROR) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001123 status = removeEffectFromHal_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001124 }
1125 return status;
1126}
1127
Andy Hungf65f5a72023-08-29 12:19:17 -07001128// must be called with EffectChain::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07001129void EffectModule::release_l()
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001130{
1131 if (mEffectInterface != 0) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001132 removeEffectFromHal_l();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001133 // release effect engine
Mikhail Naganov022b9952017-01-04 16:36:51 -08001134 mEffectInterface->close();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001135 mEffectInterface.clear();
1136 }
1137}
1138
Andy Hung6ac17eb2023-06-20 18:56:17 -07001139status_t EffectModule::removeEffectFromHal_l()
Eric Laurentbfb1b832013-01-07 09:53:42 -08001140{
1141 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
1142 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
Eric Laurent9f57aa82023-03-17 19:28:37 +01001143 if (mCurrentHalStream != getCallback()->io()) {
1144 return (mCurrentHalStream == AUDIO_IO_HANDLE_NONE) ? NO_ERROR : INVALID_OPERATION;
David Li6c8ac4b2021-06-22 22:17:52 +08001145 }
Andy Hungfda44002021-06-03 17:23:16 -07001146 getCallback()->removeEffectFromHal(mEffectInterface);
Eric Laurent9f57aa82023-03-17 19:28:37 +01001147 mCurrentHalStream = AUDIO_IO_HANDLE_NONE;
Eric Laurentca7cc822012-11-19 14:55:58 -08001148 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001149 return NO_ERROR;
Eric Laurentca7cc822012-11-19 14:55:58 -08001150}
1151
Andy Hunge4a1d912016-08-17 14:11:13 -07001152// round up delta valid if value and divisor are positive.
1153template <typename T>
1154static T roundUpDelta(const T &value, const T &divisor) {
1155 T remainder = value % divisor;
1156 return remainder == 0 ? 0 : divisor - remainder;
1157}
1158
Andy Hung6ac17eb2023-06-20 18:56:17 -07001159status_t EffectModule::command(int32_t cmdCode,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001160 const std::vector<uint8_t>& cmdData,
1161 int32_t maxReplySize,
1162 std::vector<uint8_t>* reply)
Eric Laurentca7cc822012-11-19 14:55:58 -08001163{
Andy Hungf65f5a72023-08-29 12:19:17 -07001164 audio_utils::lock_guard _l(mutex());
Shunkai Yaod125e402024-01-20 03:19:06 +00001165 ALOGVV("%s, cmdCode: %d, mEffectInterface: %p", __func__, cmdCode, mEffectInterface.get());
Eric Laurentca7cc822012-11-19 14:55:58 -08001166
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001167 if (mState == DESTROYED || mEffectInterface == 0) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001168 return NO_INIT;
1169 }
Eric Laurentd0ebb532013-04-02 16:41:41 -07001170 if (mStatus != NO_ERROR) {
1171 return mStatus;
1172 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001173 if (maxReplySize < 0 || maxReplySize > EFFECT_PARAM_SIZE_MAX) {
1174 return -EINVAL;
1175 }
1176 size_t cmdSize = cmdData.size();
1177 const effect_param_t* param = cmdSize >= sizeof(effect_param_t)
1178 ? reinterpret_cast<const effect_param_t*>(cmdData.data())
1179 : nullptr;
Andy Hung110bc952016-06-20 15:22:52 -07001180 if (cmdCode == EFFECT_CMD_GET_PARAM &&
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001181 (param == nullptr || param->psize > cmdSize - sizeof(effect_param_t))) {
Andy Hung6660f122016-11-04 19:40:53 -07001182 android_errorWriteLog(0x534e4554, "32438594");
Andy Hungb3456642016-11-28 13:50:21 -08001183 android_errorWriteLog(0x534e4554, "33003822");
1184 return -EINVAL;
1185 }
1186 if (cmdCode == EFFECT_CMD_GET_PARAM &&
Andy Hung920f6572022-10-06 12:09:49 -07001187 (maxReplySize < static_cast<signed>(sizeof(effect_param_t)) ||
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001188 param->psize > maxReplySize - sizeof(effect_param_t))) {
Andy Hungb3456642016-11-28 13:50:21 -08001189 android_errorWriteLog(0x534e4554, "29251553");
Andy Hung6660f122016-11-04 19:40:53 -07001190 return -EINVAL;
1191 }
ragoe2759072016-11-22 18:02:48 -08001192 if (cmdCode == EFFECT_CMD_GET_PARAM &&
Andy Hung920f6572022-10-06 12:09:49 -07001193 (static_cast<signed>(sizeof(effect_param_t)) > maxReplySize
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001194 || param->psize > maxReplySize - sizeof(effect_param_t)
1195 || param->vsize > maxReplySize - sizeof(effect_param_t)
1196 - param->psize
1197 || roundUpDelta(param->psize, (uint32_t) sizeof(int)) >
1198 maxReplySize
1199 - sizeof(effect_param_t)
1200 - param->psize
1201 - param->vsize)) {
ragoe2759072016-11-22 18:02:48 -08001202 ALOGV("\tLVM_ERROR : EFFECT_CMD_GET_PARAM: reply size inconsistent");
1203 android_errorWriteLog(0x534e4554, "32705438");
1204 return -EINVAL;
1205 }
Andy Hunge4a1d912016-08-17 14:11:13 -07001206 if ((cmdCode == EFFECT_CMD_SET_PARAM
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001207 || cmdCode == EFFECT_CMD_SET_PARAM_DEFERRED)
1208 && // DEFERRED not generally used
1209 (param == nullptr
1210 || param->psize > cmdSize - sizeof(effect_param_t)
1211 || param->vsize > cmdSize - sizeof(effect_param_t)
1212 - param->psize
1213 || roundUpDelta(param->psize,
1214 (uint32_t) sizeof(int)) >
1215 cmdSize
1216 - sizeof(effect_param_t)
1217 - param->psize
1218 - param->vsize)) {
Andy Hunge4a1d912016-08-17 14:11:13 -07001219 android_errorWriteLog(0x534e4554, "30204301");
1220 return -EINVAL;
1221 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001222 uint32_t replySize = maxReplySize;
1223 reply->resize(replySize);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001224 status_t status = mEffectInterface->command(cmdCode,
1225 cmdSize,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001226 const_cast<uint8_t*>(cmdData.data()),
1227 &replySize,
1228 reply->data());
1229 reply->resize(status == NO_ERROR ? replySize : 0);
Eric Laurentca7cc822012-11-19 14:55:58 -08001230 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001231 for (size_t i = 1; i < mHandles.size(); i++) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07001232 IAfEffectHandle *h = mHandles[i];
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001233 if (h != NULL && !h->disconnected()) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001234 h->commandExecuted(cmdCode, cmdData, *reply);
Eric Laurentca7cc822012-11-19 14:55:58 -08001235 }
1236 }
1237 }
1238 return status;
1239}
1240
Andy Hung6ac17eb2023-06-20 18:56:17 -07001241bool EffectModule::isProcessEnabled() const
Eric Laurentca7cc822012-11-19 14:55:58 -08001242{
Eric Laurentd0ebb532013-04-02 16:41:41 -07001243 if (mStatus != NO_ERROR) {
1244 return false;
1245 }
1246
Eric Laurentca7cc822012-11-19 14:55:58 -08001247 switch (mState) {
1248 case RESTART:
1249 case ACTIVE:
1250 case STOPPING:
1251 case STOPPED:
1252 return true;
1253 case IDLE:
1254 case STARTING:
1255 case DESTROYED:
1256 default:
1257 return false;
1258 }
1259}
1260
Shunkai Yaod125e402024-01-20 03:19:06 +00001261bool EffectModule::isOffloadedOrDirect_l() const
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001262{
Andy Hungfda44002021-06-03 17:23:16 -07001263 return getCallback()->isOffloadOrDirect();
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001264}
1265
Shunkai Yaod125e402024-01-20 03:19:06 +00001266bool EffectModule::isVolumeControlEnabled_l() const
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001267{
Shunkai Yaod125e402024-01-20 03:19:06 +00001268 return (isVolumeControl() && (isOffloadedOrDirect_l() ? isEnabled() : isProcessEnabled()));
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001269}
1270
Andy Hung6ac17eb2023-06-20 18:56:17 -07001271void EffectModule::setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
rago94a1ee82017-07-21 15:11:02 -07001272 ALOGVV("setInBuffer %p",(&buffer));
Andy Hung6f88dc42017-12-13 16:19:39 -08001273
Shunkai Yaod125e402024-01-20 03:19:06 +00001274 // mConfig.inputCfg.buffer.frameCount may be zero if configure_l() is not called yet.
Mikhail Naganov022b9952017-01-04 16:36:51 -08001275 if (buffer != 0) {
1276 mConfig.inputCfg.buffer.raw = buffer->audioBuffer()->raw;
1277 buffer->setFrameCount(mConfig.inputCfg.buffer.frameCount);
1278 } else {
1279 mConfig.inputCfg.buffer.raw = NULL;
1280 }
1281 mInBuffer = buffer;
Andy Hungc15aaee2017-11-27 17:02:40 -08001282 mEffectInterface->setInBuffer(buffer);
rago94a1ee82017-07-21 15:11:02 -07001283
Andy Hungbded9c82017-11-30 18:47:35 -08001284 // aux effects do in place conversion to float - we don't allocate mInConversionBuffer.
rago94a1ee82017-07-21 15:11:02 -07001285 // Theoretically insert effects can also do in-place conversions (destroying
1286 // the original buffer) when the output buffer is identical to the input buffer,
1287 // but we don't optimize for it here.
1288 const bool auxType = (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
Andy Hung9aad48c2017-11-29 10:29:19 -08001289 const uint32_t inChannelCount =
1290 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
1291 const bool formatMismatch = !mSupportsFloat || mInChannelCountRequested != inChannelCount;
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001292 if (!auxType && formatMismatch && mInBuffer != nullptr) {
rago94a1ee82017-07-21 15:11:02 -07001293 // we need to translate - create hidl shared buffer and intercept
1294 const size_t inFrameCount = mConfig.inputCfg.buffer.frameCount;
Andy Hung9aad48c2017-11-29 10:29:19 -08001295 // Use FCC_2 in case mInChannelCountRequested is mono and the effect is stereo.
1296 const uint32_t inChannels = std::max((uint32_t)FCC_2, mInChannelCountRequested);
1297 const size_t size = inChannels * inFrameCount * std::max(sizeof(int16_t), sizeof(float));
rago94a1ee82017-07-21 15:11:02 -07001298
1299 ALOGV("%s: setInBuffer updating for inChannels:%d inFrameCount:%zu total size:%zu",
1300 __func__, inChannels, inFrameCount, size);
1301
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001302 if (size > 0 && (mInConversionBuffer == nullptr
Andy Hungbded9c82017-11-30 18:47:35 -08001303 || size > mInConversionBuffer->getSize())) {
1304 mInConversionBuffer.clear();
1305 ALOGV("%s: allocating mInConversionBuffer %zu", __func__, size);
Andy Hungfda44002021-06-03 17:23:16 -07001306 (void)getCallback()->allocateHalBuffer(size, &mInConversionBuffer);
rago94a1ee82017-07-21 15:11:02 -07001307 }
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001308 if (mInConversionBuffer != nullptr) {
Andy Hungbded9c82017-11-30 18:47:35 -08001309 mInConversionBuffer->setFrameCount(inFrameCount);
1310 mEffectInterface->setInBuffer(mInConversionBuffer);
rago94a1ee82017-07-21 15:11:02 -07001311 } else if (size > 0) {
Andy Hungbded9c82017-11-30 18:47:35 -08001312 ALOGE("%s cannot create mInConversionBuffer", __func__);
rago94a1ee82017-07-21 15:11:02 -07001313 }
1314 }
Mikhail Naganov022b9952017-01-04 16:36:51 -08001315}
1316
Andy Hung6ac17eb2023-06-20 18:56:17 -07001317void EffectModule::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
rago94a1ee82017-07-21 15:11:02 -07001318 ALOGVV("setOutBuffer %p",(&buffer));
Andy Hung6f88dc42017-12-13 16:19:39 -08001319
Shunkai Yaod125e402024-01-20 03:19:06 +00001320 // mConfig.outputCfg.buffer.frameCount may be zero if configure_l() is not called yet.
Mikhail Naganov022b9952017-01-04 16:36:51 -08001321 if (buffer != 0) {
1322 mConfig.outputCfg.buffer.raw = buffer->audioBuffer()->raw;
1323 buffer->setFrameCount(mConfig.outputCfg.buffer.frameCount);
1324 } else {
1325 mConfig.outputCfg.buffer.raw = NULL;
1326 }
1327 mOutBuffer = buffer;
Andy Hungc15aaee2017-11-27 17:02:40 -08001328 mEffectInterface->setOutBuffer(buffer);
rago94a1ee82017-07-21 15:11:02 -07001329
Andy Hungbded9c82017-11-30 18:47:35 -08001330 // Note: Any effect that does not accumulate does not need mOutConversionBuffer and
rago94a1ee82017-07-21 15:11:02 -07001331 // can do in-place conversion from int16_t to float. We don't optimize here.
Andy Hung9aad48c2017-11-29 10:29:19 -08001332 const uint32_t outChannelCount =
1333 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
1334 const bool formatMismatch = !mSupportsFloat || mOutChannelCountRequested != outChannelCount;
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001335 if (formatMismatch && mOutBuffer != nullptr) {
rago94a1ee82017-07-21 15:11:02 -07001336 const size_t outFrameCount = mConfig.outputCfg.buffer.frameCount;
Andy Hung9aad48c2017-11-29 10:29:19 -08001337 // Use FCC_2 in case mOutChannelCountRequested is mono and the effect is stereo.
1338 const uint32_t outChannels = std::max((uint32_t)FCC_2, mOutChannelCountRequested);
1339 const size_t size = outChannels * outFrameCount * std::max(sizeof(int16_t), sizeof(float));
rago94a1ee82017-07-21 15:11:02 -07001340
1341 ALOGV("%s: setOutBuffer updating for outChannels:%d outFrameCount:%zu total size:%zu",
1342 __func__, outChannels, outFrameCount, size);
1343
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001344 if (size > 0 && (mOutConversionBuffer == nullptr
Andy Hungbded9c82017-11-30 18:47:35 -08001345 || size > mOutConversionBuffer->getSize())) {
1346 mOutConversionBuffer.clear();
1347 ALOGV("%s: allocating mOutConversionBuffer %zu", __func__, size);
Andy Hungfda44002021-06-03 17:23:16 -07001348 (void)getCallback()->allocateHalBuffer(size, &mOutConversionBuffer);
rago94a1ee82017-07-21 15:11:02 -07001349 }
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001350 if (mOutConversionBuffer != nullptr) {
Andy Hungbded9c82017-11-30 18:47:35 -08001351 mOutConversionBuffer->setFrameCount(outFrameCount);
1352 mEffectInterface->setOutBuffer(mOutConversionBuffer);
rago94a1ee82017-07-21 15:11:02 -07001353 } else if (size > 0) {
Andy Hungbded9c82017-11-30 18:47:35 -08001354 ALOGE("%s cannot create mOutConversionBuffer", __func__);
rago94a1ee82017-07-21 15:11:02 -07001355 }
1356 }
Mikhail Naganov022b9952017-01-04 16:36:51 -08001357}
1358
Shunkai Yaof4847652024-01-12 00:25:20 +00001359status_t EffectModule::setVolume(uint32_t* left, uint32_t* right, bool controller) {
Andy Hungf65f5a72023-08-29 12:19:17 -07001360 AutoLockReentrant _l(mutex(), mSetVolumeReentrantTid);
Eric Laurentd0ebb532013-04-02 16:41:41 -07001361 if (mStatus != NO_ERROR) {
1362 return mStatus;
1363 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001364 status_t status = NO_ERROR;
Eric Laurentca7cc822012-11-19 14:55:58 -08001365 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
1366 // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set)
1367 if (isProcessEnabled() &&
1368 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
Jasmine Cha934ecfb2019-01-23 18:19:14 +08001369 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND ||
1370 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_MONITOR)) {
jiabin4e246532022-08-23 16:37:30 -07001371 status = setVolumeInternal(left, right, controller);
1372 }
1373 return status;
1374}
1375
Andy Hung6ac17eb2023-06-20 18:56:17 -07001376status_t EffectModule::setVolumeInternal(
jiabin4e246532022-08-23 16:37:30 -07001377 uint32_t *left, uint32_t *right, bool controller) {
1378 uint32_t volume[2] = {*left, *right};
1379 uint32_t *pVolume = controller ? volume : nullptr;
1380 uint32_t size = sizeof(volume);
1381 status_t status = mEffectInterface->command(EFFECT_CMD_SET_VOLUME,
1382 size,
1383 volume,
1384 &size,
1385 pVolume);
1386 if (controller && status == NO_ERROR && size == sizeof(volume)) {
1387 *left = volume[0];
1388 *right = volume[1];
Eric Laurentca7cc822012-11-19 14:55:58 -08001389 }
1390 return status;
1391}
1392
Andy Hung6ac17eb2023-06-20 18:56:17 -07001393void EffectChain::setVolumeForOutput_l(uint32_t left, uint32_t right)
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001394{
Zhou Songd505c642020-02-20 16:35:37 +08001395 // for offload or direct thread, if the effect chain has non-offloadable
1396 // effect and any effect module within the chain has volume control, then
1397 // volume control is delegated to effect, otherwise, set volume to hal.
1398 if (mEffectCallback->isOffloadOrDirect() &&
1399 !(isNonOffloadableEnabled_l() && hasVolumeControlEnabled_l())) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001400 float vol_l = (float)left / (1 << 24);
1401 float vol_r = (float)right / (1 << 24);
Eric Laurent6b446ce2019-12-13 10:56:31 -08001402 mEffectCallback->setVolumeForOutput(vol_l, vol_r);
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09001403 }
1404}
1405
Andy Hung6ac17eb2023-06-20 18:56:17 -07001406status_t EffectModule::sendSetAudioDevicesCommand(
jiabin8f278ee2019-11-11 12:16:27 -08001407 const AudioDeviceTypeAddrVector &devices, uint32_t cmdCode)
Eric Laurentca7cc822012-11-19 14:55:58 -08001408{
jiabin8f278ee2019-11-11 12:16:27 -08001409 audio_devices_t deviceType = deviceTypesToBitMask(getAudioDeviceTypes(devices));
1410 if (deviceType == AUDIO_DEVICE_NONE) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001411 return NO_ERROR;
1412 }
1413
Andy Hungf65f5a72023-08-29 12:19:17 -07001414 audio_utils::lock_guard _l(mutex());
Eric Laurentd0ebb532013-04-02 16:41:41 -07001415 if (mStatus != NO_ERROR) {
1416 return mStatus;
1417 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001418 status_t status = NO_ERROR;
Eric Laurent7e1139c2013-06-06 18:29:01 -07001419 if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001420 status_t cmdStatus;
1421 uint32_t size = sizeof(status_t);
jiabin8f278ee2019-11-11 12:16:27 -08001422 // FIXME: use audio device types and addresses when the hal interface is ready.
1423 status = mEffectInterface->command(cmdCode,
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001424 sizeof(uint32_t),
jiabin8f278ee2019-11-11 12:16:27 -08001425 &deviceType,
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001426 &size,
1427 &cmdStatus);
Eric Laurentca7cc822012-11-19 14:55:58 -08001428 }
1429 return status;
1430}
1431
Andy Hung6ac17eb2023-06-20 18:56:17 -07001432status_t EffectModule::setDevices(const AudioDeviceTypeAddrVector &devices)
jiabin8f278ee2019-11-11 12:16:27 -08001433{
1434 return sendSetAudioDevicesCommand(devices, EFFECT_CMD_SET_DEVICE);
1435}
1436
Andy Hung6ac17eb2023-06-20 18:56:17 -07001437status_t EffectModule::setInputDevice(const AudioDeviceTypeAddr &device)
jiabin8f278ee2019-11-11 12:16:27 -08001438{
1439 return sendSetAudioDevicesCommand({device}, EFFECT_CMD_SET_INPUT_DEVICE);
1440}
1441
Andy Hung6ac17eb2023-06-20 18:56:17 -07001442status_t EffectModule::setMode(audio_mode_t mode)
Eric Laurentca7cc822012-11-19 14:55:58 -08001443{
Andy Hungf65f5a72023-08-29 12:19:17 -07001444 audio_utils::lock_guard _l(mutex());
Eric Laurentd0ebb532013-04-02 16:41:41 -07001445 if (mStatus != NO_ERROR) {
1446 return mStatus;
1447 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001448 status_t status = NO_ERROR;
1449 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
1450 status_t cmdStatus;
1451 uint32_t size = sizeof(status_t);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001452 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_MODE,
1453 sizeof(audio_mode_t),
1454 &mode,
1455 &size,
1456 &cmdStatus);
Eric Laurentca7cc822012-11-19 14:55:58 -08001457 if (status == NO_ERROR) {
1458 status = cmdStatus;
1459 }
1460 }
1461 return status;
1462}
1463
Andy Hung6ac17eb2023-06-20 18:56:17 -07001464status_t EffectModule::setAudioSource(audio_source_t source)
Eric Laurentca7cc822012-11-19 14:55:58 -08001465{
Andy Hungf65f5a72023-08-29 12:19:17 -07001466 audio_utils::lock_guard _l(mutex());
Eric Laurentd0ebb532013-04-02 16:41:41 -07001467 if (mStatus != NO_ERROR) {
1468 return mStatus;
1469 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001470 status_t status = NO_ERROR;
1471 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_SOURCE_MASK) == EFFECT_FLAG_AUDIO_SOURCE_IND) {
1472 uint32_t size = 0;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001473 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_SOURCE,
1474 sizeof(audio_source_t),
1475 &source,
1476 &size,
1477 NULL);
Eric Laurentca7cc822012-11-19 14:55:58 -08001478 }
1479 return status;
1480}
1481
Shunkai Yaod125e402024-01-20 03:19:06 +00001482status_t EffectModule::setOffloaded_l(bool offloaded, audio_io_handle_t io)
Eric Laurent5baf2af2013-09-12 17:37:00 -07001483{
Andy Hungf65f5a72023-08-29 12:19:17 -07001484 audio_utils::lock_guard _l(mutex());
Eric Laurent5baf2af2013-09-12 17:37:00 -07001485 if (mStatus != NO_ERROR) {
1486 return mStatus;
1487 }
1488 status_t status = NO_ERROR;
1489 if ((mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0) {
1490 status_t cmdStatus;
1491 uint32_t size = sizeof(status_t);
1492 effect_offload_param_t cmd;
1493
1494 cmd.isOffload = offloaded;
1495 cmd.ioHandle = io;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001496 status = mEffectInterface->command(EFFECT_CMD_OFFLOAD,
1497 sizeof(effect_offload_param_t),
1498 &cmd,
1499 &size,
1500 &cmdStatus);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001501 if (status == NO_ERROR) {
1502 status = cmdStatus;
1503 }
1504 mOffloaded = (status == NO_ERROR) ? offloaded : false;
1505 } else {
1506 if (offloaded) {
1507 status = INVALID_OPERATION;
1508 }
1509 mOffloaded = false;
1510 }
Shunkai Yaod125e402024-01-20 03:19:06 +00001511 ALOGV("%s offloaded %d io %d status %d", __func__, offloaded, io, status);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001512 return status;
1513}
1514
Shunkai Yaod125e402024-01-20 03:19:06 +00001515bool EffectModule::isOffloaded_l() const
Eric Laurent5baf2af2013-09-12 17:37:00 -07001516{
Andy Hungf65f5a72023-08-29 12:19:17 -07001517 audio_utils::lock_guard _l(mutex());
Eric Laurent5baf2af2013-09-12 17:37:00 -07001518 return mOffloaded;
1519}
1520
jiabineb3bda02020-06-30 14:07:03 -07001521/*static*/
Andy Hung6ac17eb2023-06-20 18:56:17 -07001522bool IAfEffectModule::isHapticGenerator(const effect_uuid_t *type) {
jiabineb3bda02020-06-30 14:07:03 -07001523 return memcmp(type, FX_IID_HAPTICGENERATOR, sizeof(effect_uuid_t)) == 0;
1524}
1525
Andy Hung6ac17eb2023-06-20 18:56:17 -07001526bool EffectModule::isHapticGenerator() const {
1527 return IAfEffectModule::isHapticGenerator(&mDescriptor.type);
jiabineb3bda02020-06-30 14:07:03 -07001528}
1529
Eric Laurent4eb45d02023-12-20 12:07:17 +01001530/*static*/
1531bool IAfEffectModule::isSpatializer(const effect_uuid_t *type) {
1532 return memcmp(type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0;
1533}
1534
1535bool EffectModule::isSpatializer() const {
1536 return IAfEffectModule::isSpatializer(&mDescriptor.type);
1537}
1538
Ahmad Khalil229466a2024-02-05 12:15:30 +00001539status_t EffectModule::setHapticScale_l(int id, os::HapticScale hapticScale) {
jiabine70bc7f2020-06-30 22:07:55 -07001540 if (mStatus != NO_ERROR) {
1541 return mStatus;
1542 }
1543 if (!isHapticGenerator()) {
1544 ALOGW("Should not set haptic intensity for effects that are not HapticGenerator");
1545 return INVALID_OPERATION;
1546 }
1547
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001548 std::vector<uint8_t> request(sizeof(effect_param_t) + 3 * sizeof(uint32_t));
1549 effect_param_t *param = (effect_param_t*) request.data();
jiabine70bc7f2020-06-30 22:07:55 -07001550 param->psize = sizeof(int32_t);
1551 param->vsize = sizeof(int32_t) * 2;
1552 *(int32_t*)param->data = HG_PARAM_HAPTIC_INTENSITY;
1553 *((int32_t*)param->data + 1) = id;
Ahmad Khalil229466a2024-02-05 12:15:30 +00001554 *((int32_t*)param->data + 2) = static_cast<int32_t>(hapticScale.getLevel());
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001555 std::vector<uint8_t> response;
1556 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
jiabine70bc7f2020-06-30 22:07:55 -07001557 if (status == NO_ERROR) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001558 LOG_ALWAYS_FATAL_IF(response.size() != 4);
1559 status = *reinterpret_cast<const status_t*>(response.data());
jiabine70bc7f2020-06-30 22:07:55 -07001560 }
1561 return status;
1562}
1563
Shunkai Yaod125e402024-01-20 03:19:06 +00001564status_t EffectModule::setVibratorInfo_l(const media::AudioVibratorInfo& vibratorInfo) {
jiabin1319f5a2021-03-30 22:21:24 +00001565 if (mStatus != NO_ERROR) {
1566 return mStatus;
1567 }
1568 if (!isHapticGenerator()) {
1569 ALOGW("Should not set vibrator info for effects that are not HapticGenerator");
1570 return INVALID_OPERATION;
1571 }
1572
Lais Andradebc3f37a2021-07-02 00:13:19 +01001573 const size_t paramCount = 3;
jiabin1319f5a2021-03-30 22:21:24 +00001574 std::vector<uint8_t> request(
Lais Andradebc3f37a2021-07-02 00:13:19 +01001575 sizeof(effect_param_t) + sizeof(int32_t) + paramCount * sizeof(float));
jiabin1319f5a2021-03-30 22:21:24 +00001576 effect_param_t *param = (effect_param_t*) request.data();
1577 param->psize = sizeof(int32_t);
Lais Andradebc3f37a2021-07-02 00:13:19 +01001578 param->vsize = paramCount * sizeof(float);
jiabin1319f5a2021-03-30 22:21:24 +00001579 *(int32_t*)param->data = HG_PARAM_VIBRATOR_INFO;
1580 float* vibratorInfoPtr = reinterpret_cast<float*>(param->data + sizeof(int32_t));
Lais Andradebc3f37a2021-07-02 00:13:19 +01001581 vibratorInfoPtr[0] = vibratorInfo.resonantFrequency;
1582 vibratorInfoPtr[1] = vibratorInfo.qFactor;
1583 vibratorInfoPtr[2] = vibratorInfo.maxAmplitude;
jiabin1319f5a2021-03-30 22:21:24 +00001584 std::vector<uint8_t> response;
1585 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
1586 if (status == NO_ERROR) {
1587 LOG_ALWAYS_FATAL_IF(response.size() != sizeof(status_t));
1588 status = *reinterpret_cast<const status_t*>(response.data());
1589 }
1590 return status;
1591}
1592
Shunkai Yaod125e402024-01-20 03:19:06 +00001593status_t EffectModule::getConfigs_l(audio_config_base_t* inputCfg, audio_config_base_t* outputCfg,
1594 bool* isOutput) const {
Andy Hungf65f5a72023-08-29 12:19:17 -07001595 audio_utils::lock_guard _l(mutex());
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001596 if (mConfig.inputCfg.mask == 0 || mConfig.outputCfg.mask == 0) {
1597 return NO_INIT;
1598 }
1599 inputCfg->sample_rate = mConfig.inputCfg.samplingRate;
1600 inputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.inputCfg.channels);
1601 inputCfg->format = static_cast<audio_format_t>(mConfig.inputCfg.format);
1602 outputCfg->sample_rate = mConfig.outputCfg.samplingRate;
1603 outputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.outputCfg.channels);
1604 outputCfg->format = static_cast<audio_format_t>(mConfig.outputCfg.format);
1605 *isOutput = mIsOutput;
1606 return NO_ERROR;
1607}
1608
Shunkai Yaod125e402024-01-20 03:19:06 +00001609status_t EffectModule::sendMetadata_ll(const std::vector<playback_track_metadata_v7_t>& metadata) {
Eric Laurent4eb45d02023-12-20 12:07:17 +01001610 if (mStatus != NO_ERROR) {
1611 return mStatus;
1612 }
1613 // TODO b/307368176: send all metadata to effects if requested by the implementation.
1614 // For now only send channel mask to Spatializer.
1615 if (!isSpatializer()) {
1616 return INVALID_OPERATION;
1617 }
1618
1619 std::vector<uint8_t> request(
1620 sizeof(effect_param_t) + sizeof(int32_t) + metadata.size() * sizeof(uint32_t));
1621 effect_param_t *param = (effect_param_t*) request.data();
1622 param->psize = sizeof(int32_t);
1623 param->vsize = metadata.size() * sizeof(uint32_t);
1624 *(int32_t*)param->data = SPATIALIZER_PARAM_INPUT_CHANNEL_MASK;
1625 uint32_t* channelMasks = reinterpret_cast<uint32_t*>(param->data + sizeof(int32_t));
1626 for (auto m : metadata) {
1627 *channelMasks++ = m.channel_mask;
1628 }
1629 std::vector<uint8_t> response;
1630 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
1631 if (status == NO_ERROR) {
1632 LOG_ALWAYS_FATAL_IF(response.size() != sizeof(status_t));
1633 status = *reinterpret_cast<const status_t*>(response.data());
1634 }
1635 return status;
1636}
1637
Andy Hungbded9c82017-11-30 18:47:35 -08001638static std::string dumpInOutBuffer(bool isInput, const sp<EffectBufferHalInterface> &buffer) {
1639 std::stringstream ss;
1640
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08001641 if (buffer == nullptr) {
Andy Hungbded9c82017-11-30 18:47:35 -08001642 return "nullptr"; // make different than below
1643 } else if (buffer->externalData() != nullptr) {
1644 ss << (isInput ? buffer->externalData() : buffer->audioBuffer()->raw)
1645 << " -> "
1646 << (isInput ? buffer->audioBuffer()->raw : buffer->externalData());
1647 } else {
1648 ss << buffer->audioBuffer()->raw;
1649 }
1650 return ss.str();
1651}
Marco Nelissenb2208842014-02-07 14:00:50 -08001652
Andy Hung6ac17eb2023-06-20 18:56:17 -07001653void EffectModule::dump(int fd, const Vector<String16>& args) const
Andy Hung920f6572022-10-06 12:09:49 -07001654NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Eric Laurentca7cc822012-11-19 14:55:58 -08001655{
Eric Laurent41709552019-12-16 19:34:05 -08001656 EffectBase::dump(fd, args);
1657
Eric Laurentca7cc822012-11-19 14:55:58 -08001658 String8 result;
Andy Hungf65f5a72023-08-29 12:19:17 -07001659 const bool locked = afutils::dumpTryLock(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08001660
Eric Laurent41709552019-12-16 19:34:05 -08001661 result.append("\t\tStatus Engine:\n");
1662 result.appendFormat("\t\t%03d %p\n",
1663 mStatus, mEffectInterface.get());
Andy Hung9718d662017-12-22 17:57:39 -08001664
1665 result.appendFormat("\t\t- data: %s\n", mSupportsFloat ? "float" : "int16");
Eric Laurentca7cc822012-11-19 14:55:58 -08001666
1667 result.append("\t\t- Input configuration:\n");
Andy Hung9718d662017-12-22 17:57:39 -08001668 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
1669 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
1670 mConfig.inputCfg.buffer.raw,
Eric Laurentca7cc822012-11-19 14:55:58 -08001671 mConfig.inputCfg.buffer.frameCount,
1672 mConfig.inputCfg.samplingRate,
1673 mConfig.inputCfg.channels,
Marco Nelissenb2208842014-02-07 14:00:50 -08001674 mConfig.inputCfg.format,
Andy Hung5fd10da2023-07-19 11:31:15 -07001675 toString(static_cast<audio_format_t>(mConfig.inputCfg.format)).c_str());
Eric Laurentca7cc822012-11-19 14:55:58 -08001676
1677 result.append("\t\t- Output configuration:\n");
1678 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
Andy Hung9718d662017-12-22 17:57:39 -08001679 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001680 mConfig.outputCfg.buffer.raw,
Eric Laurentca7cc822012-11-19 14:55:58 -08001681 mConfig.outputCfg.buffer.frameCount,
1682 mConfig.outputCfg.samplingRate,
1683 mConfig.outputCfg.channels,
Marco Nelissenb2208842014-02-07 14:00:50 -08001684 mConfig.outputCfg.format,
Andy Hung5fd10da2023-07-19 11:31:15 -07001685 toString(static_cast<audio_format_t>(mConfig.outputCfg.format)).c_str());
Eric Laurentca7cc822012-11-19 14:55:58 -08001686
Andy Hungbded9c82017-11-30 18:47:35 -08001687 result.appendFormat("\t\t- HAL buffers:\n"
1688 "\t\t\tIn(%s) InConversion(%s) Out(%s) OutConversion(%s)\n",
1689 dumpInOutBuffer(true /* isInput */, mInBuffer).c_str(),
1690 dumpInOutBuffer(true /* isInput */, mInConversionBuffer).c_str(),
1691 dumpInOutBuffer(false /* isInput */, mOutBuffer).c_str(),
1692 dumpInOutBuffer(false /* isInput */, mOutConversionBuffer).c_str());
rago94a1ee82017-07-21 15:11:02 -07001693
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001694 write(fd, result.c_str(), result.length());
Eric Laurentca7cc822012-11-19 14:55:58 -08001695
Mikhail Naganov4d547672019-02-22 14:19:19 -08001696 if (mEffectInterface != 0) {
1697 dprintf(fd, "\tEffect ID %d HAL dump:\n", mId);
1698 (void)mEffectInterface->dump(fd);
1699 }
1700
Eric Laurentca7cc822012-11-19 14:55:58 -08001701 if (locked) {
Andy Hungf65f5a72023-08-29 12:19:17 -07001702 mutex().unlock();
Eric Laurentca7cc822012-11-19 14:55:58 -08001703 }
1704}
1705
1706// ----------------------------------------------------------------------------
1707// EffectHandle implementation
1708// ----------------------------------------------------------------------------
1709
1710#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -07001711#define LOG_TAG "EffectHandle"
Eric Laurentca7cc822012-11-19 14:55:58 -08001712
Andy Hung6ac17eb2023-06-20 18:56:17 -07001713/* static */
1714sp<IAfEffectHandle> IAfEffectHandle::create(
1715 const sp<IAfEffectBase>& effect,
Andy Hung59867e42023-06-27 17:05:02 -07001716 const sp<Client>& client,
Andy Hung6ac17eb2023-06-20 18:56:17 -07001717 const sp<media::IEffectClient>& effectClient,
1718 int32_t priority, bool notifyFramesProcessed)
1719{
1720 return sp<EffectHandle>::make(
Andy Hung59867e42023-06-27 17:05:02 -07001721 effect, client, effectClient, priority, notifyFramesProcessed);
Andy Hung6ac17eb2023-06-20 18:56:17 -07001722}
1723
1724EffectHandle::EffectHandle(const sp<IAfEffectBase>& effect,
Andy Hung59867e42023-06-27 17:05:02 -07001725 const sp<Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001726 const sp<media::IEffectClient>& effectClient,
Eric Laurentde8caf42021-08-11 17:19:25 +02001727 int32_t priority, bool notifyFramesProcessed)
Eric Laurentca7cc822012-11-19 14:55:58 -08001728 : BnEffect(),
1729 mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL),
Eric Laurentde8caf42021-08-11 17:19:25 +02001730 mPriority(priority), mHasControl(false), mEnabled(false), mDisconnected(false),
1731 mNotifyFramesProcessed(notifyFramesProcessed)
Eric Laurentca7cc822012-11-19 14:55:58 -08001732{
Eric Laurentb82e6b72019-11-22 17:25:04 -08001733 ALOGV("constructor %p client %p", this, client.get());
Andy Hung225aef62022-12-06 16:33:20 -08001734 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Andy Hungd1bb2da2024-03-26 18:04:29 -07001735 setInheritRt(true);
Eric Laurentca7cc822012-11-19 14:55:58 -08001736
1737 if (client == 0) {
1738 return;
1739 }
1740 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
Atneya3c61d882021-09-20 14:52:15 -04001741 mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{
1742 {static_cast<size_t>(EFFECT_PARAM_BUFFER_SIZE + bufOffset)},
1743 std::string("Effect ID: ")
1744 .append(std::to_string(effect->id()))
1745 .append(" Session ID: ")
1746 .append(std::to_string(static_cast<int>(effect->sessionId())))
1747 .append(" \n")
1748 });
Glenn Kastene75da402013-11-20 13:54:52 -08001749 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001750 (mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001751 ALOGE("not enough memory for Effect size=%zu", EFFECT_PARAM_BUFFER_SIZE +
Eric Laurentca7cc822012-11-19 14:55:58 -08001752 sizeof(effect_param_cblk_t));
Glenn Kastene75da402013-11-20 13:54:52 -08001753 mCblkMemory.clear();
Eric Laurentca7cc822012-11-19 14:55:58 -08001754 return;
1755 }
Glenn Kastene75da402013-11-20 13:54:52 -08001756 new(mCblk) effect_param_cblk_t();
1757 mBuffer = (uint8_t *)mCblk + bufOffset;
Eric Laurentca7cc822012-11-19 14:55:58 -08001758}
1759
Andy Hung6ac17eb2023-06-20 18:56:17 -07001760EffectHandle::~EffectHandle()
Eric Laurentca7cc822012-11-19 14:55:58 -08001761{
1762 ALOGV("Destructor %p", this);
Eric Laurentca7cc822012-11-19 14:55:58 -08001763 disconnect(false);
1764}
1765
Andy Hungc747c532022-03-07 21:41:14 -08001766// Creates an association between Binder code to name for IEffect.
1767#define IEFFECT_BINDER_METHOD_MACRO_LIST \
1768BINDER_METHOD_ENTRY(enable) \
1769BINDER_METHOD_ENTRY(disable) \
1770BINDER_METHOD_ENTRY(command) \
1771BINDER_METHOD_ENTRY(disconnect) \
1772BINDER_METHOD_ENTRY(getCblk) \
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001773BINDER_METHOD_ENTRY(getConfig) \
Andy Hungc747c532022-03-07 21:41:14 -08001774
1775// singleton for Binder Method Statistics for IEffect
1776mediautils::MethodStatistics<int>& getIEffectStatistics() {
1777 using Code = int;
1778
1779#pragma push_macro("BINDER_METHOD_ENTRY")
1780#undef BINDER_METHOD_ENTRY
1781#define BINDER_METHOD_ENTRY(ENTRY) \
1782 {(Code)media::BnEffect::TRANSACTION_##ENTRY, #ENTRY},
1783
1784 static mediautils::MethodStatistics<Code> methodStatistics{
1785 IEFFECT_BINDER_METHOD_MACRO_LIST
1786 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
1787 };
1788#pragma pop_macro("BINDER_METHOD_ENTRY")
1789
1790 return methodStatistics;
1791}
1792
Andy Hung6ac17eb2023-06-20 18:56:17 -07001793status_t EffectHandle::onTransact(
Andy Hungc747c532022-03-07 21:41:14 -08001794 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Andy Hunga2a1ac32022-03-18 16:12:11 -07001795 const std::string methodName = getIEffectStatistics().getMethodForCode(code);
1796 mediautils::TimeCheck check(
1797 std::string("IEffect::").append(methodName),
1798 [code](bool timeout, float elapsedMs) {
1799 if (timeout) {
1800 ; // we don't timeout right now on the effect interface.
1801 } else {
1802 getIEffectStatistics().event(code, elapsedMs);
1803 }
Andy Hungf8ab0932022-06-13 19:49:43 -07001804 }, {} /* timeoutDuration */, {} /* secondChanceDuration */, false /* crashOnTimeout */);
Andy Hungc747c532022-03-07 21:41:14 -08001805 return BnEffect::onTransact(code, data, reply, flags);
1806}
1807
Andy Hung6ac17eb2023-06-20 18:56:17 -07001808status_t EffectHandle::initCheck() const
Glenn Kastene75da402013-11-20 13:54:52 -08001809{
1810 return mClient == 0 || mCblkMemory != 0 ? OK : NO_MEMORY;
1811}
1812
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001813#define RETURN(code) \
1814 *_aidl_return = (code); \
1815 return Status::ok();
1816
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001817#define VALUE_OR_RETURN_STATUS_AS_OUT(exp) \
1818 ({ \
1819 auto _tmp = (exp); \
1820 if (!_tmp.ok()) { RETURN(_tmp.error()); } \
1821 std::move(_tmp.value()); \
1822 })
1823
Andy Hung6ac17eb2023-06-20 18:56:17 -07001824Status EffectHandle::enable(int32_t* _aidl_return)
Eric Laurentca7cc822012-11-19 14:55:58 -08001825{
Andy Hungf65f5a72023-08-29 12:19:17 -07001826 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08001827 ALOGV("enable %p", this);
Andy Hung6ac17eb2023-06-20 18:56:17 -07001828 sp<IAfEffectBase> effect = mEffect.promote();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001829 if (effect == 0 || mDisconnected) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001830 RETURN(DEAD_OBJECT);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001831 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001832 if (!mHasControl) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001833 RETURN(INVALID_OPERATION);
Eric Laurentca7cc822012-11-19 14:55:58 -08001834 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001835
1836 if (mEnabled) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001837 RETURN(NO_ERROR);
Eric Laurentca7cc822012-11-19 14:55:58 -08001838 }
1839
1840 mEnabled = true;
1841
Eric Laurent6c796322019-04-09 14:13:17 -07001842 status_t status = effect->updatePolicyState();
1843 if (status != NO_ERROR) {
1844 mEnabled = false;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001845 RETURN(status);
Eric Laurent6c796322019-04-09 14:13:17 -07001846 }
1847
Eric Laurent6b446ce2019-12-13 10:56:31 -08001848 effect->checkSuspendOnEffectEnabled(true, false /*threadLocked*/);
Eric Laurentca7cc822012-11-19 14:55:58 -08001849
1850 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001851 if (effect->suspended()) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001852 RETURN(NO_ERROR);
Eric Laurentca7cc822012-11-19 14:55:58 -08001853 }
1854
Eric Laurent6b446ce2019-12-13 10:56:31 -08001855 status = effect->setEnabled(true, true /*fromHandle*/);
Eric Laurentca7cc822012-11-19 14:55:58 -08001856 if (status != NO_ERROR) {
Eric Laurentca7cc822012-11-19 14:55:58 -08001857 mEnabled = false;
1858 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001859 RETURN(status);
Eric Laurentca7cc822012-11-19 14:55:58 -08001860}
1861
Andy Hung6ac17eb2023-06-20 18:56:17 -07001862Status EffectHandle::disable(int32_t* _aidl_return)
Eric Laurentca7cc822012-11-19 14:55:58 -08001863{
1864 ALOGV("disable %p", this);
Andy Hungf65f5a72023-08-29 12:19:17 -07001865 audio_utils::lock_guard _l(mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -07001866 sp<IAfEffectBase> effect = mEffect.promote();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001867 if (effect == 0 || mDisconnected) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001868 RETURN(DEAD_OBJECT);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001869 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001870 if (!mHasControl) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001871 RETURN(INVALID_OPERATION);
Eric Laurentca7cc822012-11-19 14:55:58 -08001872 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001873
1874 if (!mEnabled) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001875 RETURN(NO_ERROR);
Eric Laurentca7cc822012-11-19 14:55:58 -08001876 }
1877 mEnabled = false;
1878
Eric Laurent6c796322019-04-09 14:13:17 -07001879 effect->updatePolicyState();
1880
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001881 if (effect->suspended()) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001882 RETURN(NO_ERROR);
Eric Laurentca7cc822012-11-19 14:55:58 -08001883 }
1884
Eric Laurent6b446ce2019-12-13 10:56:31 -08001885 status_t status = effect->setEnabled(false, true /*fromHandle*/);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001886 RETURN(status);
Eric Laurentca7cc822012-11-19 14:55:58 -08001887}
1888
Andy Hung6ac17eb2023-06-20 18:56:17 -07001889Status EffectHandle::disconnect()
Eric Laurentca7cc822012-11-19 14:55:58 -08001890{
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001891 ALOGV("%s %p", __FUNCTION__, this);
Eric Laurentca7cc822012-11-19 14:55:58 -08001892 disconnect(true);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001893 return Status::ok();
Eric Laurentca7cc822012-11-19 14:55:58 -08001894}
1895
Andy Hung6ac17eb2023-06-20 18:56:17 -07001896void EffectHandle::disconnect(bool unpinIfLast)
Eric Laurentca7cc822012-11-19 14:55:58 -08001897{
Andy Hungf65f5a72023-08-29 12:19:17 -07001898 audio_utils::lock_guard _l(mutex());
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001899 ALOGV("disconnect(%s) %p", unpinIfLast ? "true" : "false", this);
1900 if (mDisconnected) {
1901 if (unpinIfLast) {
1902 android_errorWriteLog(0x534e4554, "32707507");
1903 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001904 return;
1905 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001906 mDisconnected = true;
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001907 {
Andy Hung6ac17eb2023-06-20 18:56:17 -07001908 sp<IAfEffectBase> effect = mEffect.promote();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001909 if (effect != 0) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001910 if (effect->disconnectHandle(this, unpinIfLast) > 0) {
Eric Laurent6c796322019-04-09 14:13:17 -07001911 ALOGW("%s Effect handle %p disconnected after thread destruction",
1912 __func__, this);
1913 }
1914 effect->updatePolicyState();
Eric Laurentf10c7092016-12-06 17:09:56 -08001915 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001916 }
Eric Laurentca7cc822012-11-19 14:55:58 -08001917
Eric Laurentca7cc822012-11-19 14:55:58 -08001918 if (mClient != 0) {
1919 if (mCblk != NULL) {
1920 // unlike ~TrackBase(), mCblk is never a local new, so don't delete
1921 mCblk->~effect_param_cblk_t(); // destroy our shared-structure.
1922 }
1923 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
Eric Laurent021cf962014-05-13 10:18:14 -07001924 // Client destructor must run with AudioFlinger client mutex locked
Andy Hung954b9712023-08-28 18:36:53 -07001925 audio_utils::lock_guard _l2(mClient->afClientCallback()->clientMutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08001926 mClient.clear();
1927 }
1928}
1929
Andy Hung6ac17eb2023-06-20 18:56:17 -07001930Status EffectHandle::getCblk(media::SharedFileRegion* _aidl_return) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001931 LOG_ALWAYS_FATAL_IF(!convertIMemoryToSharedFileRegion(mCblkMemory, _aidl_return));
1932 return Status::ok();
1933}
1934
Andy Hung6ac17eb2023-06-20 18:56:17 -07001935Status EffectHandle::getConfig(
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001936 media::EffectConfig* _config, int32_t* _aidl_return) {
Andy Hungf65f5a72023-08-29 12:19:17 -07001937 audio_utils::lock_guard _l(mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -07001938 sp<IAfEffectBase> effect = mEffect.promote();
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001939 if (effect == nullptr || mDisconnected) {
1940 RETURN(DEAD_OBJECT);
1941 }
Andy Hung6ac17eb2023-06-20 18:56:17 -07001942 sp<IAfEffectModule> effectModule = effect->asEffectModule();
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001943 if (effectModule == nullptr) {
1944 RETURN(INVALID_OPERATION);
1945 }
1946 audio_config_base_t inputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
1947 audio_config_base_t outputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
1948 bool isOutput;
Shunkai Yaod125e402024-01-20 03:19:06 +00001949 status_t status = effectModule->getConfigs_l(&inputCfg, &outputCfg, &isOutput);
Mikhail Naganov8d7da002022-04-19 21:21:23 +00001950 if (status == NO_ERROR) {
1951 constexpr bool isInput = false; // effects always use 'OUT' channel masks.
1952 _config->inputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
1953 legacy2aidl_audio_config_base_t_AudioConfigBase(inputCfg, isInput));
1954 _config->outputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
1955 legacy2aidl_audio_config_base_t_AudioConfigBase(outputCfg, isInput));
1956 _config->isOnInputStream = !isOutput;
1957 }
1958 RETURN(status);
1959}
1960
Andy Hung6ac17eb2023-06-20 18:56:17 -07001961Status EffectHandle::command(int32_t cmdCode,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001962 const std::vector<uint8_t>& cmdData,
1963 int32_t maxResponseSize,
1964 std::vector<uint8_t>* response,
1965 int32_t* _aidl_return)
Eric Laurentca7cc822012-11-19 14:55:58 -08001966{
1967 ALOGVV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001968 cmdCode, mHasControl, mEffect.unsafe_get());
Eric Laurentca7cc822012-11-19 14:55:58 -08001969
Eric Laurentc7ab3092017-06-15 18:43:46 -07001970 // reject commands reserved for internal use by audio framework if coming from outside
1971 // of audioserver
1972 switch(cmdCode) {
1973 case EFFECT_CMD_ENABLE:
1974 case EFFECT_CMD_DISABLE:
1975 case EFFECT_CMD_SET_PARAM:
1976 case EFFECT_CMD_SET_PARAM_DEFERRED:
1977 case EFFECT_CMD_SET_PARAM_COMMIT:
1978 case EFFECT_CMD_GET_PARAM:
1979 break;
1980 default:
1981 if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY) {
1982 break;
1983 }
1984 android_errorWriteLog(0x534e4554, "62019992");
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001985 RETURN(BAD_VALUE);
Eric Laurentc7ab3092017-06-15 18:43:46 -07001986 }
1987
Eric Laurent1ffc5852016-12-15 14:46:09 -08001988 if (cmdCode == EFFECT_CMD_ENABLE) {
Andy Hung920f6572022-10-06 12:09:49 -07001989 if (maxResponseSize < static_cast<signed>(sizeof(int))) {
Eric Laurent1ffc5852016-12-15 14:46:09 -08001990 android_errorWriteLog(0x534e4554, "32095713");
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001991 RETURN(BAD_VALUE);
Eric Laurent1ffc5852016-12-15 14:46:09 -08001992 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001993 writeToBuffer(NO_ERROR, response);
1994 return enable(_aidl_return);
Eric Laurent1ffc5852016-12-15 14:46:09 -08001995 } else if (cmdCode == EFFECT_CMD_DISABLE) {
Andy Hung920f6572022-10-06 12:09:49 -07001996 if (maxResponseSize < static_cast<signed>(sizeof(int))) {
Eric Laurent1ffc5852016-12-15 14:46:09 -08001997 android_errorWriteLog(0x534e4554, "32095713");
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07001998 RETURN(BAD_VALUE);
Eric Laurent1ffc5852016-12-15 14:46:09 -08001999 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002000 writeToBuffer(NO_ERROR, response);
2001 return disable(_aidl_return);
Eric Laurent1ffc5852016-12-15 14:46:09 -08002002 }
2003
Andy Hungf65f5a72023-08-29 12:19:17 -07002004 audio_utils::lock_guard _l(mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -07002005 sp<IAfEffectBase> effect = mEffect.promote();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002006 if (effect == 0 || mDisconnected) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002007 RETURN(DEAD_OBJECT);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002008 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002009 // only get parameter command is permitted for applications not controlling the effect
2010 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002011 RETURN(INVALID_OPERATION);
Eric Laurentca7cc822012-11-19 14:55:58 -08002012 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002013
2014 // handle commands that are not forwarded transparently to effect engine
2015 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08002016 if (mClient == 0) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002017 RETURN(INVALID_OPERATION);
Eric Laurentb82e6b72019-11-22 17:25:04 -08002018 }
2019
Andy Hung920f6572022-10-06 12:09:49 -07002020 if (maxResponseSize < (signed)sizeof(int)) {
Eric Laurent1ffc5852016-12-15 14:46:09 -08002021 android_errorWriteLog(0x534e4554, "32095713");
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002022 RETURN(BAD_VALUE);
Eric Laurent1ffc5852016-12-15 14:46:09 -08002023 }
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002024 writeToBuffer(NO_ERROR, response);
Eric Laurent1ffc5852016-12-15 14:46:09 -08002025
Eric Laurentca7cc822012-11-19 14:55:58 -08002026 // No need to trylock() here as this function is executed in the binder thread serving a
2027 // particular client process: no risk to block the whole media server process or mixer
2028 // threads if we are stuck here
Andy Hung920f6572022-10-06 12:09:49 -07002029 Mutex::Autolock _l2(mCblk->lock);
Andy Hunga447a0f2016-11-15 17:19:58 -08002030 // keep local copy of index in case of client corruption b/32220769
2031 const uint32_t clientIndex = mCblk->clientIndex;
2032 const uint32_t serverIndex = mCblk->serverIndex;
2033 if (clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
2034 serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002035 mCblk->serverIndex = 0;
2036 mCblk->clientIndex = 0;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002037 RETURN(BAD_VALUE);
Eric Laurentca7cc822012-11-19 14:55:58 -08002038 }
2039 status_t status = NO_ERROR;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002040 std::vector<uint8_t> param;
Andy Hunga447a0f2016-11-15 17:19:58 -08002041 for (uint32_t index = serverIndex; index < clientIndex;) {
2042 int *p = (int *)(mBuffer + index);
2043 const int size = *p++;
2044 if (size < 0
2045 || size > EFFECT_PARAM_BUFFER_SIZE
2046 || ((uint8_t *)p + size) > mBuffer + clientIndex) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002047 ALOGW("command(): invalid parameter block size");
Andy Hunga447a0f2016-11-15 17:19:58 -08002048 status = BAD_VALUE;
Eric Laurentca7cc822012-11-19 14:55:58 -08002049 break;
2050 }
Andy Hunga447a0f2016-11-15 17:19:58 -08002051
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002052 std::copy(reinterpret_cast<const uint8_t*>(p),
2053 reinterpret_cast<const uint8_t*>(p) + size,
2054 std::back_inserter(param));
Andy Hunga447a0f2016-11-15 17:19:58 -08002055
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002056 std::vector<uint8_t> replyBuffer;
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002057 status_t ret = effect->command(EFFECT_CMD_SET_PARAM,
Andy Hunga447a0f2016-11-15 17:19:58 -08002058 param,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002059 sizeof(int),
2060 &replyBuffer);
2061 int reply = *reinterpret_cast<const int*>(replyBuffer.data());
Andy Hunga447a0f2016-11-15 17:19:58 -08002062
2063 // verify shared memory: server index shouldn't change; client index can't go back.
2064 if (serverIndex != mCblk->serverIndex
2065 || clientIndex > mCblk->clientIndex) {
2066 android_errorWriteLog(0x534e4554, "32220769");
2067 status = BAD_VALUE;
2068 break;
2069 }
2070
Eric Laurentca7cc822012-11-19 14:55:58 -08002071 // stop at first error encountered
2072 if (ret != NO_ERROR) {
2073 status = ret;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002074 writeToBuffer(reply, response);
Eric Laurentca7cc822012-11-19 14:55:58 -08002075 break;
2076 } else if (reply != NO_ERROR) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002077 writeToBuffer(reply, response);
Eric Laurentca7cc822012-11-19 14:55:58 -08002078 break;
2079 }
Andy Hunga447a0f2016-11-15 17:19:58 -08002080 index += size;
Eric Laurentca7cc822012-11-19 14:55:58 -08002081 }
2082 mCblk->serverIndex = 0;
2083 mCblk->clientIndex = 0;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002084 RETURN(status);
Eric Laurentca7cc822012-11-19 14:55:58 -08002085 }
2086
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002087 status_t status = effect->command(cmdCode,
2088 cmdData,
2089 maxResponseSize,
2090 response);
2091 RETURN(status);
Eric Laurentca7cc822012-11-19 14:55:58 -08002092}
2093
Andy Hung6ac17eb2023-06-20 18:56:17 -07002094void EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
Eric Laurentca7cc822012-11-19 14:55:58 -08002095{
2096 ALOGV("setControl %p control %d", this, hasControl);
2097
2098 mHasControl = hasControl;
2099 mEnabled = enabled;
2100
2101 if (signal && mEffectClient != 0) {
2102 mEffectClient->controlStatusChanged(hasControl);
2103 }
2104}
2105
Andy Hung6ac17eb2023-06-20 18:56:17 -07002106void EffectHandle::commandExecuted(uint32_t cmdCode,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002107 const std::vector<uint8_t>& cmdData,
2108 const std::vector<uint8_t>& replyData)
Eric Laurentca7cc822012-11-19 14:55:58 -08002109{
2110 if (mEffectClient != 0) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07002111 mEffectClient->commandExecuted(cmdCode, cmdData, replyData);
Eric Laurentca7cc822012-11-19 14:55:58 -08002112 }
2113}
2114
2115
2116
Andy Hung6ac17eb2023-06-20 18:56:17 -07002117void EffectHandle::setEnabled(bool enabled)
Eric Laurentca7cc822012-11-19 14:55:58 -08002118{
2119 if (mEffectClient != 0) {
2120 mEffectClient->enableStatusChanged(enabled);
2121 }
2122}
2123
Andy Hung6ac17eb2023-06-20 18:56:17 -07002124void EffectHandle::framesProcessed(int32_t frames) const
Eric Laurentde8caf42021-08-11 17:19:25 +02002125{
2126 if (mEffectClient != 0 && mNotifyFramesProcessed) {
2127 mEffectClient->framesProcessed(frames);
2128 }
2129}
2130
Andy Hung6ac17eb2023-06-20 18:56:17 -07002131void EffectHandle::dumpToBuffer(char* buffer, size_t size) const
Andy Hung920f6572022-10-06 12:09:49 -07002132NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Eric Laurentca7cc822012-11-19 14:55:58 -08002133{
Andy Hung0a51b5c2023-07-18 20:54:44 -07002134 const bool locked = mCblk != nullptr && afutils::dumpTryLock(mCblk->lock);
Eric Laurentca7cc822012-11-19 14:55:58 -08002135
Marco Nelissenb2208842014-02-07 14:00:50 -08002136 snprintf(buffer, size, "\t\t\t%5d %5d %3s %3s %5u %5u\n",
Andy Hung4ef19fa2018-05-15 19:35:29 -07002137 (mClient == 0) ? getpid() : mClient->pid(),
Eric Laurentca7cc822012-11-19 14:55:58 -08002138 mPriority,
Marco Nelissenb2208842014-02-07 14:00:50 -08002139 mHasControl ? "yes" : "no",
2140 locked ? "yes" : "no",
Eric Laurentca7cc822012-11-19 14:55:58 -08002141 mCblk ? mCblk->clientIndex : 0,
2142 mCblk ? mCblk->serverIndex : 0
2143 );
2144
2145 if (locked) {
2146 mCblk->lock.unlock();
2147 }
2148}
2149
2150#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -07002151#define LOG_TAG "EffectChain"
Eric Laurentca7cc822012-11-19 14:55:58 -08002152
Andy Hung6ac17eb2023-06-20 18:56:17 -07002153/* static */
2154sp<IAfEffectChain> IAfEffectChain::create(
Andy Hung583043b2023-07-17 17:05:00 -07002155 const sp<IAfThreadBase>& thread,
François Gaffie541fd402023-11-29 17:16:38 +01002156 audio_session_t sessionId,
2157 const sp<IAfThreadCallback>& afThreadCallback)
Andy Hung6ac17eb2023-06-20 18:56:17 -07002158{
François Gaffie541fd402023-11-29 17:16:38 +01002159 return sp<EffectChain>::make(thread, sessionId, afThreadCallback);
Andy Hung6ac17eb2023-06-20 18:56:17 -07002160}
2161
François Gaffie541fd402023-11-29 17:16:38 +01002162EffectChain::EffectChain(const sp<IAfThreadBase>& thread, audio_session_t sessionId,
2163 const sp<IAfThreadCallback>& afThreadCallback)
Eric Laurent6b446ce2019-12-13 10:56:31 -08002164 : mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
jiabinbd18c8e2023-08-24 21:10:44 +00002165 mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
Eric Laurent6b446ce2019-12-13 10:56:31 -08002166 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),
François Gaffie541fd402023-11-29 17:16:38 +01002167 mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread, afThreadCallback))
Eric Laurentca7cc822012-11-19 14:55:58 -08002168{
François Gaffie541fd402023-11-29 17:16:38 +01002169 if (thread != nullptr) {
2170 mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
2171 mMaxTailBuffers =
2172 ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
2173 thread->frameCount();
2174 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002175}
2176
François Gaffie541fd402023-11-29 17:16:38 +01002177sp<IAfEffectModule> EffectChain::getEffectFromDesc(
Andy Hung6ac17eb2023-06-20 18:56:17 -07002178 effect_descriptor_t *descriptor) const
Eric Laurentca7cc822012-11-19 14:55:58 -08002179{
François Gaffie541fd402023-11-29 17:16:38 +01002180 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002181 size_t size = mEffects.size();
2182
2183 for (size_t i = 0; i < size; i++) {
2184 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
2185 return mEffects[i];
2186 }
2187 }
2188 return 0;
2189}
2190
Andy Hung87c693c2023-07-06 20:56:16 -07002191// getEffectFromId_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002192sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const
Eric Laurentca7cc822012-11-19 14:55:58 -08002193{
François Gaffie541fd402023-11-29 17:16:38 +01002194 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002195 size_t size = mEffects.size();
2196
2197 for (size_t i = 0; i < size; i++) {
2198 // by convention, return first effect if id provided is 0 (0 is never a valid id)
2199 if (id == 0 || mEffects[i]->id() == id) {
2200 return mEffects[i];
2201 }
2202 }
2203 return 0;
2204}
2205
Andy Hung87c693c2023-07-06 20:56:16 -07002206// getEffectFromType_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002207sp<IAfEffectModule> EffectChain::getEffectFromType_l(
2208 const effect_uuid_t *type) const
Eric Laurentca7cc822012-11-19 14:55:58 -08002209{
François Gaffie541fd402023-11-29 17:16:38 +01002210 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002211 size_t size = mEffects.size();
2212
2213 for (size_t i = 0; i < size; i++) {
2214 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
2215 return mEffects[i];
2216 }
2217 }
2218 return 0;
2219}
2220
Shunkai Yaod125e402024-01-20 03:19:06 +00002221std::vector<int> EffectChain::getEffectIds_l() const
Eric Laurent6c796322019-04-09 14:13:17 -07002222{
2223 std::vector<int> ids;
Andy Hungf65f5a72023-08-29 12:19:17 -07002224 audio_utils::lock_guard _l(mutex());
Eric Laurent6c796322019-04-09 14:13:17 -07002225 for (size_t i = 0; i < mEffects.size(); i++) {
2226 ids.push_back(mEffects[i]->id());
2227 }
2228 return ids;
2229}
2230
Andy Hung6ac17eb2023-06-20 18:56:17 -07002231void EffectChain::clearInputBuffer()
Eric Laurentca7cc822012-11-19 14:55:58 -08002232{
Andy Hungf65f5a72023-08-29 12:19:17 -07002233 audio_utils::lock_guard _l(mutex());
Eric Laurent6b446ce2019-12-13 10:56:31 -08002234 clearInputBuffer_l();
Eric Laurentca7cc822012-11-19 14:55:58 -08002235}
2236
Andy Hungf65f5a72023-08-29 12:19:17 -07002237// Must be called with EffectChain::mutex() locked
Andy Hung6ac17eb2023-06-20 18:56:17 -07002238void EffectChain::clearInputBuffer_l()
Eric Laurentca7cc822012-11-19 14:55:58 -08002239{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002240 if (mInBuffer == NULL) {
2241 return;
2242 }
Andy Hung319587b2023-05-23 14:01:03 -07002243 const size_t frameSize = audio_bytes_per_sample(AUDIO_FORMAT_PCM_FLOAT)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002244 * mEffectCallback->inChannelCount(mEffects[0]->id());
rago94a1ee82017-07-21 15:11:02 -07002245
Eric Laurent6b446ce2019-12-13 10:56:31 -08002246 memset(mInBuffer->audioBuffer()->raw, 0, mEffectCallback->frameCount() * frameSize);
Mikhail Naganov022b9952017-01-04 16:36:51 -08002247 mInBuffer->commit();
Eric Laurentca7cc822012-11-19 14:55:58 -08002248}
2249
Andy Hungf65f5a72023-08-29 12:19:17 -07002250// Must be called with EffectChain::mutex() locked
Shunkai Yaod125e402024-01-20 03:19:06 +00002251void EffectChain::process_l() {
Jean-Michel Trivifed62922013-09-25 18:50:33 -07002252 // never process effects when:
2253 // - on an OFFLOAD thread
2254 // - no more tracks are on the session and the effect tail has been rendered
Eric Laurent6b446ce2019-12-13 10:56:31 -08002255 bool doProcess = !mEffectCallback->isOffloadOrMmap();
Eric Laurent3f75a5b2019-11-12 15:55:51 -08002256 if (!audio_is_global_session(mSessionId)) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002257 bool tracksOnSession = (trackCnt() != 0);
2258
2259 if (!tracksOnSession && mTailBufferCount == 0) {
2260 doProcess = false;
2261 }
2262
2263 if (activeTrackCnt() == 0) {
2264 // if no track is active and the effect tail has not been rendered,
2265 // the input buffer must be cleared here as the mixer process will not do it
2266 if (tracksOnSession || mTailBufferCount > 0) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08002267 clearInputBuffer_l();
Eric Laurentca7cc822012-11-19 14:55:58 -08002268 if (mTailBufferCount > 0) {
2269 mTailBufferCount--;
2270 }
2271 }
2272 }
2273 }
2274
2275 size_t size = mEffects.size();
2276 if (doProcess) {
Mikhail Naganov022b9952017-01-04 16:36:51 -08002277 // Only the input and output buffers of the chain can be external,
2278 // and 'update' / 'commit' do nothing for allocated buffers, thus
2279 // it's not needed to consider any other buffers here.
2280 mInBuffer->update();
Mikhail Naganov06888802017-01-19 12:47:55 -08002281 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
2282 mOutBuffer->update();
2283 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002284 for (size_t i = 0; i < size; i++) {
2285 mEffects[i]->process();
2286 }
Mikhail Naganov06888802017-01-19 12:47:55 -08002287 mInBuffer->commit();
2288 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
2289 mOutBuffer->commit();
2290 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002291 }
Eric Laurentfa1e1232016-08-02 19:01:49 -07002292 bool doResetVolume = false;
Eric Laurentca7cc822012-11-19 14:55:58 -08002293 for (size_t i = 0; i < size; i++) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002294 doResetVolume = mEffects[i]->updateState_l() || doResetVolume;
Eric Laurentfa1e1232016-08-02 19:01:49 -07002295 }
2296 if (doResetVolume) {
2297 resetVolume_l();
Eric Laurentca7cc822012-11-19 14:55:58 -08002298 }
2299}
2300
François Gaffie541fd402023-11-29 17:16:38 +01002301status_t EffectChain::createEffect(sp<IAfEffectModule>& effect,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002302 effect_descriptor_t *desc,
2303 int id,
2304 audio_session_t sessionId,
2305 bool pinned)
2306{
Andy Hungf65f5a72023-08-29 12:19:17 -07002307 audio_utils::lock_guard _l(mutex());
Eric Laurentb82e6b72019-11-22 17:25:04 -08002308 effect = new EffectModule(mEffectCallback, desc, id, sessionId, pinned, AUDIO_PORT_HANDLE_NONE);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002309 status_t lStatus = effect->status();
2310 if (lStatus == NO_ERROR) {
François Gaffie541fd402023-11-29 17:16:38 +01002311 lStatus = addEffect_l(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002312 }
2313 if (lStatus != NO_ERROR) {
2314 effect.clear();
2315 }
2316 return lStatus;
2317}
2318
François Gaffie541fd402023-11-29 17:16:38 +01002319status_t EffectChain::addEffect(const sp<IAfEffectModule>& effect)
Eric Laurentca7cc822012-11-19 14:55:58 -08002320{
Andy Hungf65f5a72023-08-29 12:19:17 -07002321 audio_utils::lock_guard _l(mutex());
François Gaffie541fd402023-11-29 17:16:38 +01002322 return addEffect_l(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002323}
François Gaffie541fd402023-11-29 17:16:38 +01002324// addEffect_l() must be called with EffectChain::mutex() held
2325status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002326{
Eric Laurent6b446ce2019-12-13 10:56:31 -08002327 effect->setCallback(mEffectCallback);
Eric Laurentca7cc822012-11-19 14:55:58 -08002328
Eric Laurentb62d0362021-10-26 17:40:18 +02002329 effect_descriptor_t desc = effect->desc();
Eric Laurentca7cc822012-11-19 14:55:58 -08002330 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2331 // Auxiliary effects are inserted at the beginning of mEffects vector as
2332 // they are processed first and accumulated in chain input buffer
2333 mEffects.insertAt(effect, 0);
2334
2335 // the input buffer for auxiliary effect contains mono samples in
2336 // 32 bit format. This is to avoid saturation in AudoMixer
2337 // accumulation stage. Saturation is done in EffectModule::process() before
2338 // calling the process in effect engine
Eric Laurent6b446ce2019-12-13 10:56:31 -08002339 size_t numSamples = mEffectCallback->frameCount();
Mikhail Naganov022b9952017-01-04 16:36:51 -08002340 sp<EffectBufferHalInterface> halBuffer;
Andy Hung26836922023-05-22 17:31:57 -07002341
Eric Laurent6b446ce2019-12-13 10:56:31 -08002342 status_t result = mEffectCallback->allocateHalBuffer(
rago94a1ee82017-07-21 15:11:02 -07002343 numSamples * sizeof(float), &halBuffer);
Mikhail Naganov022b9952017-01-04 16:36:51 -08002344 if (result != OK) return result;
Eric Laurentf1f22e72021-07-13 14:04:14 +02002345
Shunkai Yaod125e402024-01-20 03:19:06 +00002346 effect->configure_l();
Eric Laurentf1f22e72021-07-13 14:04:14 +02002347
Mikhail Naganov022b9952017-01-04 16:36:51 -08002348 effect->setInBuffer(halBuffer);
Eric Laurentca7cc822012-11-19 14:55:58 -08002349 // auxiliary effects output samples to chain input buffer for further processing
2350 // by insert effects
2351 effect->setOutBuffer(mInBuffer);
2352 } else {
François Gaffie541fd402023-11-29 17:16:38 +01002353 ssize_t idx_insert = getInsertIndex_l(desc);
Eric Laurentb62d0362021-10-26 17:40:18 +02002354 if (idx_insert < 0) {
2355 return INVALID_OPERATION;
Eric Laurentca7cc822012-11-19 14:55:58 -08002356 }
2357
Eric Laurentb62d0362021-10-26 17:40:18 +02002358 size_t previousSize = mEffects.size();
Eric Laurentf1f22e72021-07-13 14:04:14 +02002359 mEffects.insertAt(effect, idx_insert);
2360
Shunkai Yaod125e402024-01-20 03:19:06 +00002361 effect->configure_l();
Eric Laurentf1f22e72021-07-13 14:04:14 +02002362
Eric Laurentb62d0362021-10-26 17:40:18 +02002363 // - By default:
2364 // All effects read samples from chain input buffer.
2365 // The last effect in the chain, writes samples to chain output buffer,
2366 // otherwise to chain input buffer
2367 // - In the OUTPUT_STAGE chain of a spatializer mixer thread:
2368 // The spatializer effect (first effect) reads samples from the input buffer
2369 // and writes samples to the output buffer.
2370 // All other effects read and writes samples to the output buffer
2371 if (mEffectCallback->isSpatializer()
2372 && mSessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002373 effect->setOutBuffer(mOutBuffer);
Eric Laurentb62d0362021-10-26 17:40:18 +02002374 if (idx_insert == 0) {
2375 if (previousSize != 0) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002376 mEffects[1]->configure_l();
Eric Laurentb62d0362021-10-26 17:40:18 +02002377 mEffects[1]->setInBuffer(mOutBuffer);
Shunkai Yaod125e402024-01-20 03:19:06 +00002378 mEffects[1]->updateAccessMode_l(); // reconfig if needed.
Eric Laurentb62d0362021-10-26 17:40:18 +02002379 }
2380 effect->setInBuffer(mInBuffer);
2381 } else {
2382 effect->setInBuffer(mOutBuffer);
2383 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002384 } else {
Eric Laurentb62d0362021-10-26 17:40:18 +02002385 effect->setInBuffer(mInBuffer);
Andy Hung920f6572022-10-06 12:09:49 -07002386 if (idx_insert == static_cast<ssize_t>(previousSize)) {
Eric Laurentb62d0362021-10-26 17:40:18 +02002387 if (idx_insert != 0) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002388 mEffects[idx_insert-1]->configure_l();
Eric Laurentb62d0362021-10-26 17:40:18 +02002389 mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
Shunkai Yaod125e402024-01-20 03:19:06 +00002390 mEffects[idx_insert - 1]->updateAccessMode_l(); // reconfig if needed.
Eric Laurentb62d0362021-10-26 17:40:18 +02002391 }
2392 effect->setOutBuffer(mOutBuffer);
2393 } else {
2394 effect->setOutBuffer(mInBuffer);
2395 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002396 }
Eric Laurentb62d0362021-10-26 17:40:18 +02002397 ALOGV("%s effect %p, added in chain %p at rank %zu",
2398 __func__, effect.get(), this, idx_insert);
Eric Laurentca7cc822012-11-19 14:55:58 -08002399 }
Shunkai Yaod125e402024-01-20 03:19:06 +00002400 effect->configure_l();
Eric Laurentd8365c52017-07-16 15:27:05 -07002401
Eric Laurentca7cc822012-11-19 14:55:58 -08002402 return NO_ERROR;
2403}
2404
jiabinbd18c8e2023-08-24 21:10:44 +00002405std::optional<size_t> EffectChain::findVolumeControl_l(size_t from, size_t to) const {
2406 for (size_t i = std::min(to, mEffects.size()); i > from; i--) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002407 if (mEffects[i - 1]->isVolumeControlEnabled_l()) {
jiabinbd18c8e2023-08-24 21:10:44 +00002408 return i - 1;
2409 }
2410 }
2411 return std::nullopt;
2412}
2413
François Gaffie541fd402023-11-29 17:16:38 +01002414ssize_t EffectChain::getInsertIndex_l(const effect_descriptor_t& desc) {
Eric Laurentb62d0362021-10-26 17:40:18 +02002415 // Insert effects are inserted at the end of mEffects vector as they are processed
2416 // after track and auxiliary effects.
2417 // Insert effect order as a function of indicated preference:
2418 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
2419 // another effect is present
2420 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
2421 // last effect claiming first position
2422 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
2423 // first effect claiming last position
2424 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last
2425 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
2426 // already present
2427 // Spatializer or Downmixer effects are inserted in first position because
2428 // they adapt the channel count for all other effects in the chain
Eric Laurent4eb45d02023-12-20 12:07:17 +01002429 if (IAfEffectModule::isSpatializer(&desc.type)
Eric Laurentb62d0362021-10-26 17:40:18 +02002430 || (memcmp(&desc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0)) {
2431 return 0;
2432 }
2433
2434 size_t size = mEffects.size();
2435 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
2436 ssize_t idx_insert;
2437 ssize_t idx_insert_first = -1;
2438 ssize_t idx_insert_last = -1;
2439
2440 idx_insert = size;
2441 for (size_t i = 0; i < size; i++) {
2442 effect_descriptor_t d = mEffects[i]->desc();
2443 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
2444 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
2445 if (iMode == EFFECT_FLAG_TYPE_INSERT) {
2446 // check invalid effect chaining combinations
2447 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
2448 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
2449 ALOGW("%s could not insert effect %s: exclusive conflict with %s",
2450 __func__, desc.name, d.name);
2451 return -1;
2452 }
2453 // remember position of first insert effect and by default
2454 // select this as insert position for new effect
Andy Hung920f6572022-10-06 12:09:49 -07002455 if (idx_insert == static_cast<ssize_t>(size)) {
Eric Laurentb62d0362021-10-26 17:40:18 +02002456 idx_insert = i;
2457 }
2458 // remember position of last insert effect claiming
2459 // first position
2460 if (iPref == EFFECT_FLAG_INSERT_FIRST) {
2461 idx_insert_first = i;
2462 }
2463 // remember position of first insert effect claiming
2464 // last position
2465 if (iPref == EFFECT_FLAG_INSERT_LAST &&
2466 idx_insert_last == -1) {
2467 idx_insert_last = i;
2468 }
2469 }
2470 }
2471
2472 // modify idx_insert from first position if needed
2473 if (insertPref == EFFECT_FLAG_INSERT_LAST) {
2474 if (idx_insert_last != -1) {
2475 idx_insert = idx_insert_last;
2476 } else {
2477 idx_insert = size;
2478 }
2479 } else {
2480 if (idx_insert_first != -1) {
2481 idx_insert = idx_insert_first + 1;
2482 }
2483 }
2484 return idx_insert;
2485}
2486
François Gaffie541fd402023-11-29 17:16:38 +01002487size_t EffectChain::removeEffect(const sp<IAfEffectModule>& effect,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002488 bool release)
Eric Laurentca7cc822012-11-19 14:55:58 -08002489{
Andy Hungf65f5a72023-08-29 12:19:17 -07002490 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002491 size_t size = mEffects.size();
2492 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
2493
Francois Gaffie2b229cd2021-11-22 18:20:16 +01002494 const bool hasThreadAttached = mEffectCallback->hasThreadAttached();
Eric Laurentca7cc822012-11-19 14:55:58 -08002495 for (size_t i = 0; i < size; i++) {
2496 if (effect == mEffects[i]) {
2497 // calling stop here will remove pre-processing effect from the audio HAL.
2498 // This is safe as we hold the EffectChain mutex which guarantees that we are not in
2499 // the middle of a read from audio HAL
2500 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2501 mEffects[i]->state() == EffectModule::STOPPING) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002502 mEffects[i]->stop_l();
Eric Laurentca7cc822012-11-19 14:55:58 -08002503 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002504 if (release) {
2505 mEffects[i]->release_l();
2506 }
Francois Gaffie2b229cd2021-11-22 18:20:16 +01002507 // Skip operation when no thread attached (could lead to sigfpe as framecount is 0...)
2508 if (hasThreadAttached && type != EFFECT_FLAG_TYPE_AUXILIARY) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002509 if (i == size - 1 && i != 0) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002510 mEffects[i - 1]->configure_l();
Eric Laurentf1f22e72021-07-13 14:04:14 +02002511 mEffects[i - 1]->setOutBuffer(mOutBuffer);
Shunkai Yaod125e402024-01-20 03:19:06 +00002512 mEffects[i - 1]->updateAccessMode_l(); // reconfig if needed.
Eric Laurentca7cc822012-11-19 14:55:58 -08002513 }
2514 }
2515 mEffects.removeAt(i);
Eric Laurentf1f22e72021-07-13 14:04:14 +02002516
2517 // make sure the input buffer configuration for the new first effect in the chain
2518 // is updated if needed (can switch from HAL channel mask to mixer channel mask)
Nie Wei Feng4d2cb592023-05-26 15:18:04 -07002519 if (type != EFFECT_FLAG_TYPE_AUXILIARY // TODO(b/284522658) breaks for aux FX, why?
Francois Gaffie2b229cd2021-11-22 18:20:16 +01002520 && hasThreadAttached && i == 0 && size > 1) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002521 mEffects[0]->configure_l();
Eric Laurentf1f22e72021-07-13 14:04:14 +02002522 mEffects[0]->setInBuffer(mInBuffer);
Shunkai Yaod125e402024-01-20 03:19:06 +00002523 mEffects[0]->updateAccessMode_l(); // reconfig if needed.
Eric Laurentf1f22e72021-07-13 14:04:14 +02002524 }
2525
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002526 ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %zu", effect.get(),
Eric Laurentca7cc822012-11-19 14:55:58 -08002527 this, i);
2528 break;
2529 }
2530 }
2531
2532 return mEffects.size();
2533}
2534
Andy Hung87c693c2023-07-06 20:56:16 -07002535// setDevices_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002536void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices)
Eric Laurentca7cc822012-11-19 14:55:58 -08002537{
François Gaffie541fd402023-11-29 17:16:38 +01002538 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002539 size_t size = mEffects.size();
2540 for (size_t i = 0; i < size; i++) {
jiabin8f278ee2019-11-11 12:16:27 -08002541 mEffects[i]->setDevices(devices);
2542 }
2543}
2544
Andy Hung87c693c2023-07-06 20:56:16 -07002545// setInputDevice_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002546void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device)
jiabin8f278ee2019-11-11 12:16:27 -08002547{
François Gaffie541fd402023-11-29 17:16:38 +01002548 audio_utils::lock_guard _l(mutex());
jiabin8f278ee2019-11-11 12:16:27 -08002549 size_t size = mEffects.size();
2550 for (size_t i = 0; i < size; i++) {
2551 mEffects[i]->setInputDevice(device);
Eric Laurentca7cc822012-11-19 14:55:58 -08002552 }
2553}
2554
Andy Hung87c693c2023-07-06 20:56:16 -07002555// setMode_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002556void EffectChain::setMode_l(audio_mode_t mode)
Eric Laurentca7cc822012-11-19 14:55:58 -08002557{
François Gaffie541fd402023-11-29 17:16:38 +01002558 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002559 size_t size = mEffects.size();
2560 for (size_t i = 0; i < size; i++) {
2561 mEffects[i]->setMode(mode);
2562 }
2563}
2564
Andy Hung87c693c2023-07-06 20:56:16 -07002565// setAudioSource_l() must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002566void EffectChain::setAudioSource_l(audio_source_t source)
Eric Laurentca7cc822012-11-19 14:55:58 -08002567{
François Gaffie541fd402023-11-29 17:16:38 +01002568 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002569 size_t size = mEffects.size();
2570 for (size_t i = 0; i < size; i++) {
2571 mEffects[i]->setAudioSource(source);
2572 }
2573}
2574
Andy Hung6ac17eb2023-06-20 18:56:17 -07002575bool EffectChain::hasVolumeControlEnabled_l() const {
Zhou Songd505c642020-02-20 16:35:37 +08002576 for (const auto &effect : mEffects) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002577 if (effect->isVolumeControlEnabled_l()) return true;
Zhou Songd505c642020-02-20 16:35:37 +08002578 }
2579 return false;
2580}
2581
Shunkai Yaof4847652024-01-12 00:25:20 +00002582// setVolume() must be called without EffectChain::mutex()
2583bool EffectChain::setVolume(uint32_t* left, uint32_t* right, bool force) {
2584 audio_utils::lock_guard _l(mutex());
2585 return setVolume_l(left, right, force);
2586}
2587
2588// setVolume_l() must be called with EffectChain::mutex() held
2589bool EffectChain::setVolume_l(uint32_t* left, uint32_t* right, bool force) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002590 uint32_t newLeft = *left;
2591 uint32_t newRight = *right;
jiabinbd18c8e2023-08-24 21:10:44 +00002592 const size_t size = mEffects.size();
Eric Laurentca7cc822012-11-19 14:55:58 -08002593
2594 // first update volume controller
jiabinbd18c8e2023-08-24 21:10:44 +00002595 const auto volumeControlIndex = findVolumeControl_l(0, size);
2596 const int ctrlIdx = volumeControlIndex.value_or(-1);
2597 const sp<IAfEffectModule> volumeControlEffect =
2598 volumeControlIndex.has_value() ? mEffects[ctrlIdx] : nullptr;
2599 const sp<IAfEffectModule> cachedVolumeControlEffect = mVolumeControlEffect.promote();
Eric Laurentca7cc822012-11-19 14:55:58 -08002600
jiabinbd18c8e2023-08-24 21:10:44 +00002601 if (!force && volumeControlEffect == cachedVolumeControlEffect &&
Eric Laurentcb4b6e92014-10-01 14:26:10 -07002602 *left == mLeftVolume && *right == mRightVolume) {
jiabinbd18c8e2023-08-24 21:10:44 +00002603 if (volumeControlIndex.has_value()) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002604 *left = mNewLeftVolume;
2605 *right = mNewRightVolume;
2606 }
jiabinbd18c8e2023-08-24 21:10:44 +00002607 return volumeControlIndex.has_value();
Eric Laurentca7cc822012-11-19 14:55:58 -08002608 }
2609
jiabinbd18c8e2023-08-24 21:10:44 +00002610 if (volumeControlEffect != cachedVolumeControlEffect) {
2611 // The volume control effect is a new one. Set the old one as full volume. Set the new onw
2612 // as zero for safe ramping.
2613 if (cachedVolumeControlEffect != nullptr) {
2614 uint32_t leftMax = 1 << 24;
2615 uint32_t rightMax = 1 << 24;
2616 cachedVolumeControlEffect->setVolume(&leftMax, &rightMax, true /*controller*/);
2617 }
2618 if (volumeControlEffect != nullptr) {
2619 uint32_t leftZero = 0;
2620 uint32_t rightZero = 0;
2621 volumeControlEffect->setVolume(&leftZero, &rightZero, true /*controller*/);
2622 }
David Li05081252023-11-13 12:39:18 +08002623 mVolumeControlEffect = volumeControlEffect;
jiabinbd18c8e2023-08-24 21:10:44 +00002624 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002625 mLeftVolume = newLeft;
2626 mRightVolume = newRight;
2627
2628 // second get volume update from volume controller
2629 if (ctrlIdx >= 0) {
2630 mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true);
2631 mNewLeftVolume = newLeft;
2632 mNewRightVolume = newRight;
2633 }
2634 // then indicate volume to all other effects in chain.
2635 // Pass altered volume to effects before volume controller
Jasmine Cha934ecfb2019-01-23 18:19:14 +08002636 // and requested volume to effects after controller or with volume monitor flag
Eric Laurentca7cc822012-11-19 14:55:58 -08002637 uint32_t lVol = newLeft;
2638 uint32_t rVol = newRight;
2639
2640 for (size_t i = 0; i < size; i++) {
2641 if ((int)i == ctrlIdx) {
2642 continue;
2643 }
2644 // this also works for ctrlIdx == -1 when there is no volume controller
2645 if ((int)i > ctrlIdx) {
2646 lVol = *left;
2647 rVol = *right;
2648 }
Jasmine Cha934ecfb2019-01-23 18:19:14 +08002649 // Pass requested volume directly if this is volume monitor module
2650 if (mEffects[i]->isVolumeMonitor()) {
2651 mEffects[i]->setVolume(left, right, false);
2652 } else {
2653 mEffects[i]->setVolume(&lVol, &rVol, false);
2654 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002655 }
2656 *left = newLeft;
2657 *right = newRight;
2658
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09002659 setVolumeForOutput_l(*left, *right);
2660
jiabinbd18c8e2023-08-24 21:10:44 +00002661 return volumeControlIndex.has_value();
Eric Laurentca7cc822012-11-19 14:55:58 -08002662}
2663
Shunkai Yaof4847652024-01-12 00:25:20 +00002664// resetVolume_l() must be called with EffectChain::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002665void EffectChain::resetVolume_l()
Eric Laurentfa1e1232016-08-02 19:01:49 -07002666{
Eric Laurente7449bf2016-08-03 18:44:07 -07002667 if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) {
2668 uint32_t left = mLeftVolume;
2669 uint32_t right = mRightVolume;
2670 (void)setVolume_l(&left, &right, true);
2671 }
Eric Laurentfa1e1232016-08-02 19:01:49 -07002672}
2673
François Gaffie541fd402023-11-29 17:16:38 +01002674bool EffectChain::containsHapticGeneratingEffect()
2675{
2676 audio_utils::lock_guard _l(mutex());
2677 return containsHapticGeneratingEffect_l();
2678}
2679// containsHapticGeneratingEffect_l must be called with EffectChain::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002680bool EffectChain::containsHapticGeneratingEffect_l()
jiabineb3bda02020-06-30 14:07:03 -07002681{
2682 for (size_t i = 0; i < mEffects.size(); ++i) {
2683 if (mEffects[i]->isHapticGenerator()) {
2684 return true;
2685 }
2686 }
2687 return false;
2688}
2689
Ahmad Khalil229466a2024-02-05 12:15:30 +00002690void EffectChain::setHapticScale_l(int id, os::HapticScale hapticScale)
jiabine70bc7f2020-06-30 22:07:55 -07002691{
Andy Hungf65f5a72023-08-29 12:19:17 -07002692 audio_utils::lock_guard _l(mutex());
jiabine70bc7f2020-06-30 22:07:55 -07002693 for (size_t i = 0; i < mEffects.size(); ++i) {
Ahmad Khalil229466a2024-02-05 12:15:30 +00002694 mEffects[i]->setHapticScale_l(id, hapticScale);
jiabine70bc7f2020-06-30 22:07:55 -07002695 }
2696}
2697
Shunkai Yaod125e402024-01-20 03:19:06 +00002698void EffectChain::syncHalEffectsState_l()
Eric Laurent1b928682014-10-02 19:41:47 -07002699{
Andy Hungf65f5a72023-08-29 12:19:17 -07002700 audio_utils::lock_guard _l(mutex());
Eric Laurent1b928682014-10-02 19:41:47 -07002701 for (size_t i = 0; i < mEffects.size(); i++) {
2702 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2703 mEffects[i]->state() == EffectModule::STOPPING) {
2704 mEffects[i]->addEffectToHal_l();
2705 }
2706 }
2707}
2708
Andy Hung6ac17eb2023-06-20 18:56:17 -07002709void EffectChain::dump(int fd, const Vector<String16>& args) const
Andy Hung920f6572022-10-06 12:09:49 -07002710NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Eric Laurentca7cc822012-11-19 14:55:58 -08002711{
Eric Laurentca7cc822012-11-19 14:55:58 -08002712 String8 result;
2713
Mikhail Naganov19740ca2019-03-28 12:25:01 -07002714 const size_t numEffects = mEffects.size();
2715 result.appendFormat(" %zu effects for session %d\n", numEffects, mSessionId);
Eric Laurentca7cc822012-11-19 14:55:58 -08002716
Marco Nelissenb2208842014-02-07 14:00:50 -08002717 if (numEffects) {
Andy Hungf65f5a72023-08-29 12:19:17 -07002718 const bool locked = afutils::dumpTryLock(mutex());
Marco Nelissenb2208842014-02-07 14:00:50 -08002719 // failed to lock - AudioFlinger is probably deadlocked
2720 if (!locked) {
2721 result.append("\tCould not lock mutex:\n");
Eric Laurentca7cc822012-11-19 14:55:58 -08002722 }
Eric Laurentca7cc822012-11-19 14:55:58 -08002723
Andy Hungbded9c82017-11-30 18:47:35 -08002724 const std::string inBufferStr = dumpInOutBuffer(true /* isInput */, mInBuffer);
2725 const std::string outBufferStr = dumpInOutBuffer(false /* isInput */, mOutBuffer);
2726 result.appendFormat("\t%-*s%-*s Active tracks:\n",
2727 (int)inBufferStr.size(), "In buffer ",
2728 (int)outBufferStr.size(), "Out buffer ");
2729 result.appendFormat("\t%s %s %d\n",
2730 inBufferStr.c_str(), outBufferStr.c_str(), mActiveTrackCnt);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002731 write(fd, result.c_str(), result.size());
Marco Nelissenb2208842014-02-07 14:00:50 -08002732
2733 for (size_t i = 0; i < numEffects; ++i) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07002734 sp<IAfEffectModule> effect = mEffects[i];
Marco Nelissenb2208842014-02-07 14:00:50 -08002735 if (effect != 0) {
2736 effect->dump(fd, args);
2737 }
2738 }
2739
2740 if (locked) {
Andy Hungf65f5a72023-08-29 12:19:17 -07002741 mutex().unlock();
Marco Nelissenb2208842014-02-07 14:00:50 -08002742 }
Mikhail Naganov19740ca2019-03-28 12:25:01 -07002743 } else {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002744 write(fd, result.c_str(), result.size());
Eric Laurentca7cc822012-11-19 14:55:58 -08002745 }
2746}
2747
Andy Hung87c693c2023-07-06 20:56:16 -07002748// must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002749void EffectChain::setEffectSuspended_l(
Eric Laurentca7cc822012-11-19 14:55:58 -08002750 const effect_uuid_t *type, bool suspend)
2751{
2752 sp<SuspendedEffectDesc> desc;
2753 // use effect type UUID timelow as key as there is no real risk of identical
2754 // timeLow fields among effect type UUIDs.
2755 ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow);
2756 if (suspend) {
2757 if (index >= 0) {
2758 desc = mSuspendedEffects.valueAt(index);
2759 } else {
2760 desc = new SuspendedEffectDesc();
2761 desc->mType = *type;
2762 mSuspendedEffects.add(type->timeLow, desc);
2763 ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
2764 }
Eric Laurentd8365c52017-07-16 15:27:05 -07002765
Eric Laurentca7cc822012-11-19 14:55:58 -08002766 if (desc->mRefCount++ == 0) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002767 sp<IAfEffectModule> effect = getEffectIfEnabled_l(type);
Eric Laurentca7cc822012-11-19 14:55:58 -08002768 if (effect != 0) {
2769 desc->mEffect = effect;
2770 effect->setSuspended(true);
Eric Laurent6b446ce2019-12-13 10:56:31 -08002771 effect->setEnabled(false, false /*fromHandle*/);
Eric Laurentca7cc822012-11-19 14:55:58 -08002772 }
2773 }
2774 } else {
2775 if (index < 0) {
2776 return;
2777 }
2778 desc = mSuspendedEffects.valueAt(index);
2779 if (desc->mRefCount <= 0) {
2780 ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
Eric Laurentd8365c52017-07-16 15:27:05 -07002781 desc->mRefCount = 0;
2782 return;
Eric Laurentca7cc822012-11-19 14:55:58 -08002783 }
2784 if (--desc->mRefCount == 0) {
2785 ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
2786 if (desc->mEffect != 0) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07002787 sp<IAfEffectModule> effect = desc->mEffect.promote();
Eric Laurentca7cc822012-11-19 14:55:58 -08002788 if (effect != 0) {
2789 effect->setSuspended(false);
Andy Hungf65f5a72023-08-29 12:19:17 -07002790 effect->mutex().lock();
Andy Hung6ac17eb2023-06-20 18:56:17 -07002791 IAfEffectHandle *handle = effect->controlHandle_l();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002792 if (handle != NULL && !handle->disconnected()) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002793 effect->setEnabled_l(handle->enabled());
2794 }
Andy Hungf65f5a72023-08-29 12:19:17 -07002795 effect->mutex().unlock();
Eric Laurentca7cc822012-11-19 14:55:58 -08002796 }
2797 desc->mEffect.clear();
2798 }
2799 mSuspendedEffects.removeItemsAt(index);
2800 }
2801 }
2802}
2803
Andy Hung87c693c2023-07-06 20:56:16 -07002804// must be called with IAfThreadBase::mutex() held
Andy Hung6ac17eb2023-06-20 18:56:17 -07002805void EffectChain::setEffectSuspendedAll_l(bool suspend)
Eric Laurentca7cc822012-11-19 14:55:58 -08002806{
2807 sp<SuspendedEffectDesc> desc;
2808
2809 ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2810 if (suspend) {
2811 if (index >= 0) {
2812 desc = mSuspendedEffects.valueAt(index);
2813 } else {
2814 desc = new SuspendedEffectDesc();
2815 mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
2816 ALOGV("setEffectSuspendedAll_l() add entry for 0");
2817 }
2818 if (desc->mRefCount++ == 0) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07002819 Vector< sp<IAfEffectModule> > effects;
François Gaffie541fd402023-11-29 17:16:38 +01002820 getSuspendEligibleEffects(effects);
Eric Laurentca7cc822012-11-19 14:55:58 -08002821 for (size_t i = 0; i < effects.size(); i++) {
2822 setEffectSuspended_l(&effects[i]->desc().type, true);
2823 }
2824 }
2825 } else {
2826 if (index < 0) {
2827 return;
2828 }
2829 desc = mSuspendedEffects.valueAt(index);
2830 if (desc->mRefCount <= 0) {
2831 ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
2832 desc->mRefCount = 1;
2833 }
2834 if (--desc->mRefCount == 0) {
2835 Vector<const effect_uuid_t *> types;
2836 for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
2837 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
2838 continue;
2839 }
2840 types.add(&mSuspendedEffects.valueAt(i)->mType);
2841 }
2842 for (size_t i = 0; i < types.size(); i++) {
2843 setEffectSuspended_l(types[i], false);
2844 }
2845 ALOGV("setEffectSuspendedAll_l() remove entry for %08x",
2846 mSuspendedEffects.keyAt(index));
2847 mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
2848 }
2849 }
2850}
2851
2852
2853// The volume effect is used for automated tests only
2854#ifndef OPENSL_ES_H_
2855static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
2856 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
2857const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
2858#endif //OPENSL_ES_H_
2859
Eric Laurentd8365c52017-07-16 15:27:05 -07002860/* static */
Shunkai Yaod125e402024-01-20 03:19:06 +00002861bool EffectChain::isEffectEligibleForBtNrecSuspend_l(const effect_uuid_t* type) {
Eric Laurentd8365c52017-07-16 15:27:05 -07002862 // Only NS and AEC are suspended when BtNRec is off
2863 if ((memcmp(type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) ||
2864 (memcmp(type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
2865 return true;
2866 }
2867 return false;
2868}
2869
François Gaffie541fd402023-11-29 17:16:38 +01002870bool EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
Eric Laurentca7cc822012-11-19 14:55:58 -08002871{
2872 // auxiliary effects and visualizer are never suspended on output mix
2873 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
2874 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
2875 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
Ricardo Garciac2a3a822019-07-17 14:29:12 -07002876 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0) ||
2877 (memcmp(&desc.type, SL_IID_DYNAMICSPROCESSING, sizeof(effect_uuid_t)) == 0))) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002878 return false;
2879 }
2880 return true;
2881}
2882
François Gaffie541fd402023-11-29 17:16:38 +01002883void EffectChain::getSuspendEligibleEffects(
Andy Hung6ac17eb2023-06-20 18:56:17 -07002884 Vector< sp<IAfEffectModule> > &effects)
Eric Laurentca7cc822012-11-19 14:55:58 -08002885{
2886 effects.clear();
François Gaffie541fd402023-11-29 17:16:38 +01002887 audio_utils::lock_guard _l(mutex());
Eric Laurentca7cc822012-11-19 14:55:58 -08002888 for (size_t i = 0; i < mEffects.size(); i++) {
François Gaffie541fd402023-11-29 17:16:38 +01002889 if (isEffectEligibleForSuspend(mEffects[i]->desc())) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002890 effects.add(mEffects[i]);
2891 }
2892 }
2893}
2894
Shunkai Yaod125e402024-01-20 03:19:06 +00002895sp<IAfEffectModule> EffectChain::getEffectIfEnabled_l(const effect_uuid_t *type)
Eric Laurentca7cc822012-11-19 14:55:58 -08002896{
Andy Hung6ac17eb2023-06-20 18:56:17 -07002897 sp<IAfEffectModule> effect = getEffectFromType_l(type);
Eric Laurentca7cc822012-11-19 14:55:58 -08002898 return effect != 0 && effect->isEnabled() ? effect : 0;
2899}
2900
Shunkai Yaod125e402024-01-20 03:19:06 +00002901void EffectChain::checkSuspendOnEffectEnabled_l(const sp<IAfEffectModule>& effect, bool enabled) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002902 ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
2903 if (enabled) {
2904 if (index < 0) {
2905 // if the effect is not suspend check if all effects are suspended
2906 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2907 if (index < 0) {
2908 return;
2909 }
François Gaffie541fd402023-11-29 17:16:38 +01002910 if (!isEffectEligibleForSuspend(effect->desc())) {
Eric Laurentca7cc822012-11-19 14:55:58 -08002911 return;
2912 }
2913 setEffectSuspended_l(&effect->desc().type, enabled);
2914 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
2915 if (index < 0) {
Shunkai Yaod125e402024-01-20 03:19:06 +00002916 ALOGW("%s Fx should be suspended here!", __func__);
Eric Laurentca7cc822012-11-19 14:55:58 -08002917 return;
2918 }
2919 }
Shunkai Yaod125e402024-01-20 03:19:06 +00002920 ALOGV("%s enable suspending fx %08x", __func__, effect->desc().type.timeLow);
Eric Laurentca7cc822012-11-19 14:55:58 -08002921 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
Eric Laurentd8365c52017-07-16 15:27:05 -07002922 // if effect is requested to suspended but was not yet enabled, suspend it now.
Eric Laurentca7cc822012-11-19 14:55:58 -08002923 if (desc->mEffect == 0) {
2924 desc->mEffect = effect;
Eric Laurent6b446ce2019-12-13 10:56:31 -08002925 effect->setEnabled(false, false /*fromHandle*/);
Eric Laurentca7cc822012-11-19 14:55:58 -08002926 effect->setSuspended(true);
2927 }
2928 } else {
2929 if (index < 0) {
2930 return;
2931 }
Shunkai Yaod125e402024-01-20 03:19:06 +00002932 ALOGV("%s disable restoring fx %08x", __func__, effect->desc().type.timeLow);
Eric Laurentca7cc822012-11-19 14:55:58 -08002933 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
2934 desc->mEffect.clear();
2935 effect->setSuspended(false);
2936 }
2937}
2938
Andy Hung6ac17eb2023-06-20 18:56:17 -07002939bool EffectChain::isNonOffloadableEnabled() const
Eric Laurent813e2a72013-08-31 12:59:48 -07002940{
Andy Hungf65f5a72023-08-29 12:19:17 -07002941 audio_utils::lock_guard _l(mutex());
Shingo Kitajima1f8df9a2018-05-29 11:35:06 +09002942 return isNonOffloadableEnabled_l();
2943}
2944
Andy Hung6ac17eb2023-06-20 18:56:17 -07002945bool EffectChain::isNonOffloadableEnabled_l() const
Shingo Kitajima1f8df9a2018-05-29 11:35:06 +09002946{
Eric Laurent813e2a72013-08-31 12:59:48 -07002947 size_t size = mEffects.size();
2948 for (size_t i = 0; i < size; i++) {
Eric Laurent5baf2af2013-09-12 17:37:00 -07002949 if (mEffects[i]->isEnabled() && !mEffects[i]->isOffloadable()) {
Eric Laurent813e2a72013-08-31 12:59:48 -07002950 return true;
2951 }
2952 }
2953 return false;
2954}
2955
Andy Hung87c693c2023-07-06 20:56:16 -07002956void EffectChain::setThread(const sp<IAfThreadBase>& thread)
Eric Laurentaaa44472014-09-12 17:41:50 -07002957{
François Gaffie541fd402023-11-29 17:16:38 +01002958 if (thread != nullptr) {
2959 mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
2960 mMaxTailBuffers =
2961 ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
2962 thread->frameCount();
2963 }
Andy Hungf65f5a72023-08-29 12:19:17 -07002964 audio_utils::lock_guard _l(mutex());
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -08002965 mEffectCallback->setThread(thread);
Eric Laurentaaa44472014-09-12 17:41:50 -07002966}
2967
Andy Hung6ac17eb2023-06-20 18:56:17 -07002968void EffectChain::checkOutputFlagCompatibility(audio_output_flags_t *flags) const
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002969{
2970 if ((*flags & AUDIO_OUTPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
2971 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_RAW);
2972 }
2973 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
2974 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
2975 }
jiabinc658e452022-10-21 20:52:21 +00002976 if ((*flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) != 0 && !isBitPerfectCompatible()) {
2977 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_BIT_PERFECT);
2978 }
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002979}
2980
Andy Hung6ac17eb2023-06-20 18:56:17 -07002981void EffectChain::checkInputFlagCompatibility(audio_input_flags_t *flags) const
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002982{
2983 if ((*flags & AUDIO_INPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
2984 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_RAW);
2985 }
2986 if ((*flags & AUDIO_INPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
2987 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
2988 }
2989}
2990
Andy Hung6ac17eb2023-06-20 18:56:17 -07002991bool EffectChain::isRawCompatible() const
Eric Laurent4c415062016-06-17 16:14:16 -07002992{
Andy Hungf65f5a72023-08-29 12:19:17 -07002993 audio_utils::lock_guard _l(mutex());
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002994 for (const auto &effect : mEffects) {
2995 if (effect->isProcessImplemented()) {
2996 return false;
Eric Laurent4c415062016-06-17 16:14:16 -07002997 }
2998 }
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002999 // Allow effects without processing.
3000 return true;
3001}
3002
Andy Hung6ac17eb2023-06-20 18:56:17 -07003003bool EffectChain::isFastCompatible() const
Andy Hungd3bb0ad2016-10-11 17:16:43 -07003004{
Andy Hungf65f5a72023-08-29 12:19:17 -07003005 audio_utils::lock_guard _l(mutex());
Andy Hungd3bb0ad2016-10-11 17:16:43 -07003006 for (const auto &effect : mEffects) {
3007 if (effect->isProcessImplemented()
3008 && effect->isImplementationSoftware()) {
3009 return false;
3010 }
3011 }
3012 // Allow effects without processing or hw accelerated effects.
3013 return true;
Eric Laurent4c415062016-06-17 16:14:16 -07003014}
3015
Andy Hung6ac17eb2023-06-20 18:56:17 -07003016bool EffectChain::isBitPerfectCompatible() const {
Andy Hungf65f5a72023-08-29 12:19:17 -07003017 audio_utils::lock_guard _l(mutex());
jiabinc658e452022-10-21 20:52:21 +00003018 for (const auto &effect : mEffects) {
3019 if (effect->isProcessImplemented()
3020 && effect->isImplementationSoftware()) {
3021 return false;
3022 }
3023 }
3024 // Allow effects without processing or hw accelerated effects.
3025 return true;
3026}
3027
Andy Hungf65f5a72023-08-29 12:19:17 -07003028// isCompatibleWithThread_l() must be called with thread->mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003029bool EffectChain::isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const
Eric Laurent4c415062016-06-17 16:14:16 -07003030{
Andy Hungf65f5a72023-08-29 12:19:17 -07003031 audio_utils::lock_guard _l(mutex());
Eric Laurent4c415062016-06-17 16:14:16 -07003032 for (size_t i = 0; i < mEffects.size(); i++) {
3033 if (thread->checkEffectCompatibility_l(&(mEffects[i]->desc()), mSessionId) != NO_ERROR) {
3034 return false;
3035 }
3036 }
3037 return true;
3038}
3039
Eric Laurent4eb45d02023-12-20 12:07:17 +01003040// sendMetadata_l() must be called with thread->mutex() held
3041void EffectChain::sendMetadata_l(const std::vector<playback_track_metadata_v7_t>& allMetadata,
3042 const std::optional<const std::vector<playback_track_metadata_v7_t>> spatializedMetadata) {
3043 audio_utils::lock_guard _l(mutex());
3044 for (const auto& effect : mEffects) {
3045 if (spatializedMetadata.has_value()
3046 && IAfEffectModule::isSpatializer(&effect->desc().type)) {
Shunkai Yaod125e402024-01-20 03:19:06 +00003047 effect->sendMetadata_ll(spatializedMetadata.value());
Eric Laurent4eb45d02023-12-20 12:07:17 +01003048 } else {
Shunkai Yaod125e402024-01-20 03:19:06 +00003049 effect->sendMetadata_ll(allMetadata);
Eric Laurent4eb45d02023-12-20 12:07:17 +01003050 }
3051 }
3052}
3053
Eric Laurent6b446ce2019-12-13 10:56:31 -08003054// EffectCallbackInterface implementation
Andy Hung6ac17eb2023-06-20 18:56:17 -07003055status_t EffectChain::EffectCallback::createEffectHal(
Eric Laurent6b446ce2019-12-13 10:56:31 -08003056 const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
3057 sp<EffectHalInterface> *effect) {
3058 status_t status = NO_INIT;
Andy Hungba8e52b2023-05-11 14:33:03 -07003059 const sp<EffectsFactoryHalInterface> effectsFactory =
3060 EffectConfiguration::getEffectsFactoryHal();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003061 if (effectsFactory != 0) {
3062 status = effectsFactory->createEffect(pEffectUuid, sessionId, io(), deviceId, effect);
3063 }
3064 return status;
3065}
3066
Andy Hung6ac17eb2023-06-20 18:56:17 -07003067bool EffectChain::EffectCallback::updateOrphanEffectChains(
3068 const sp<IAfEffectBase>& effect) {
Eric Laurent41709552019-12-16 19:34:05 -08003069 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
Andy Hung583043b2023-07-17 17:05:00 -07003070 return mAfThreadCallback->updateOrphanEffectChains(effect->asEffectModule());
Eric Laurent6b446ce2019-12-13 10:56:31 -08003071}
3072
Andy Hung6ac17eb2023-06-20 18:56:17 -07003073status_t EffectChain::EffectCallback::allocateHalBuffer(
Eric Laurent6b446ce2019-12-13 10:56:31 -08003074 size_t size, sp<EffectBufferHalInterface>* buffer) {
Andy Hung583043b2023-07-17 17:05:00 -07003075 return mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(size, buffer);
Eric Laurent6b446ce2019-12-13 10:56:31 -08003076}
3077
Andy Hung6ac17eb2023-06-20 18:56:17 -07003078status_t EffectChain::EffectCallback::addEffectToHal(
Andy Hung920f6572022-10-06 12:09:49 -07003079 const sp<EffectHalInterface>& effect) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003080 status_t result = NO_INIT;
Andy Hung87c693c2023-07-06 20:56:16 -07003081 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003082 if (t == nullptr) {
3083 return result;
3084 }
3085 sp <StreamHalInterface> st = t->stream();
3086 if (st == nullptr) {
3087 return result;
3088 }
3089 result = st->addEffect(effect);
3090 ALOGE_IF(result != OK, "Error when adding effect: %d", result);
3091 return result;
3092}
3093
Andy Hung6ac17eb2023-06-20 18:56:17 -07003094status_t EffectChain::EffectCallback::removeEffectFromHal(
Andy Hung920f6572022-10-06 12:09:49 -07003095 const sp<EffectHalInterface>& effect) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003096 status_t result = NO_INIT;
Andy Hung87c693c2023-07-06 20:56:16 -07003097 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003098 if (t == nullptr) {
3099 return result;
3100 }
3101 sp <StreamHalInterface> st = t->stream();
3102 if (st == nullptr) {
3103 return result;
3104 }
3105 result = st->removeEffect(effect);
3106 ALOGE_IF(result != OK, "Error when removing effect: %d", result);
3107 return result;
3108}
3109
Andy Hung6ac17eb2023-06-20 18:56:17 -07003110audio_io_handle_t EffectChain::EffectCallback::io() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003111 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003112 if (t == nullptr) {
3113 return AUDIO_IO_HANDLE_NONE;
3114 }
3115 return t->id();
3116}
3117
Andy Hung6ac17eb2023-06-20 18:56:17 -07003118bool EffectChain::EffectCallback::isOutput() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003119 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003120 if (t == nullptr) {
3121 return true;
3122 }
3123 return t->isOutput();
3124}
3125
Andy Hung6ac17eb2023-06-20 18:56:17 -07003126bool EffectChain::EffectCallback::isOffload() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003127 return mThreadType == IAfThreadBase::OFFLOAD;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003128}
3129
Andy Hung6ac17eb2023-06-20 18:56:17 -07003130bool EffectChain::EffectCallback::isOffloadOrDirect() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003131 return mThreadType == IAfThreadBase::OFFLOAD
3132 || mThreadType == IAfThreadBase::DIRECT;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003133}
3134
Andy Hung6ac17eb2023-06-20 18:56:17 -07003135bool EffectChain::EffectCallback::isOffloadOrMmap() const {
Eric Laurentb62d0362021-10-26 17:40:18 +02003136 switch (mThreadType) {
Andy Hung87c693c2023-07-06 20:56:16 -07003137 case IAfThreadBase::OFFLOAD:
3138 case IAfThreadBase::MMAP_PLAYBACK:
3139 case IAfThreadBase::MMAP_CAPTURE:
Eric Laurentb62d0362021-10-26 17:40:18 +02003140 return true;
3141 default:
Eric Laurent6b446ce2019-12-13 10:56:31 -08003142 return false;
3143 }
Eric Laurentb62d0362021-10-26 17:40:18 +02003144}
3145
Andy Hung6ac17eb2023-06-20 18:56:17 -07003146bool EffectChain::EffectCallback::isSpatializer() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003147 return mThreadType == IAfThreadBase::SPATIALIZER;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003148}
3149
Andy Hung6ac17eb2023-06-20 18:56:17 -07003150uint32_t EffectChain::EffectCallback::sampleRate() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003151 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003152 if (t == nullptr) {
François Gaffie541fd402023-11-29 17:16:38 +01003153 return DEFAULT_OUTPUT_SAMPLE_RATE;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003154 }
3155 return t->sampleRate();
3156}
3157
Andy Hungab65b182023-09-06 19:41:47 -07003158audio_channel_mask_t EffectChain::EffectCallback::inChannelMask(int id) const
3159NO_THREAD_SAFETY_ANALYSIS
3160// calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
François Gaffie541fd402023-11-29 17:16:38 +01003161// calling function 'isFirstEffect_l' requires holding mutex 'EffectChain_Mutex' exclusively
Andy Hungab65b182023-09-06 19:41:47 -07003162{
Andy Hung87c693c2023-07-06 20:56:16 -07003163 const sp<IAfThreadBase> t = thread().promote();
Eric Laurentf1f22e72021-07-13 14:04:14 +02003164 if (t == nullptr) {
Shunkai Yao1f9da012024-03-19 04:27:31 +00003165 return AUDIO_CHANNEL_OUT_STEREO;
Eric Laurentf1f22e72021-07-13 14:04:14 +02003166 }
Andy Hung6ac17eb2023-06-20 18:56:17 -07003167 sp<IAfEffectChain> c = chain().promote();
Eric Laurentf1f22e72021-07-13 14:04:14 +02003168 if (c == nullptr) {
Shunkai Yao1f9da012024-03-19 04:27:31 +00003169 return AUDIO_CHANNEL_OUT_STEREO;
Eric Laurentf1f22e72021-07-13 14:04:14 +02003170 }
3171
Andy Hung87c693c2023-07-06 20:56:16 -07003172 if (mThreadType == IAfThreadBase::SPATIALIZER) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003173 if (c->sessionId() == AUDIO_SESSION_OUTPUT_STAGE) {
François Gaffie541fd402023-11-29 17:16:38 +01003174 if (c->isFirstEffect_l(id)) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003175 return t->mixerChannelMask();
3176 } else {
3177 return t->channelMask();
3178 }
3179 } else if (!audio_is_global_session(c->sessionId())) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003180 if ((t->hasAudioSession_l(c->sessionId())
Andy Hung87c693c2023-07-06 20:56:16 -07003181 & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003182 return t->mixerChannelMask();
3183 } else {
3184 return t->channelMask();
3185 }
3186 } else {
3187 return t->channelMask();
3188 }
Eric Laurentf1f22e72021-07-13 14:04:14 +02003189 } else {
3190 return t->channelMask();
3191 }
3192}
3193
Andy Hung6ac17eb2023-06-20 18:56:17 -07003194uint32_t EffectChain::EffectCallback::inChannelCount(int id) const {
Eric Laurentb62d0362021-10-26 17:40:18 +02003195 return audio_channel_count_from_out_mask(inChannelMask(id));
Eric Laurentf1f22e72021-07-13 14:04:14 +02003196}
3197
Andy Hungab65b182023-09-06 19:41:47 -07003198audio_channel_mask_t EffectChain::EffectCallback::outChannelMask() const
3199NO_THREAD_SAFETY_ANALYSIS
3200// calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
3201{
Andy Hung87c693c2023-07-06 20:56:16 -07003202 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003203 if (t == nullptr) {
Shunkai Yao1f9da012024-03-19 04:27:31 +00003204 return AUDIO_CHANNEL_OUT_STEREO;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003205 }
Andy Hung6ac17eb2023-06-20 18:56:17 -07003206 sp<IAfEffectChain> c = chain().promote();
Eric Laurentb62d0362021-10-26 17:40:18 +02003207 if (c == nullptr) {
Shunkai Yao1f9da012024-03-19 04:27:31 +00003208 return AUDIO_CHANNEL_OUT_STEREO;
Eric Laurentb62d0362021-10-26 17:40:18 +02003209 }
3210
Andy Hung87c693c2023-07-06 20:56:16 -07003211 if (mThreadType == IAfThreadBase::SPATIALIZER) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003212 if (!audio_is_global_session(c->sessionId())) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003213 if ((t->hasAudioSession_l(c->sessionId())
Andy Hung87c693c2023-07-06 20:56:16 -07003214 & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003215 return t->mixerChannelMask();
3216 } else {
3217 return t->channelMask();
3218 }
3219 } else {
3220 return t->channelMask();
3221 }
3222 } else {
3223 return t->channelMask();
3224 }
Eric Laurent6b446ce2019-12-13 10:56:31 -08003225}
3226
Andy Hung6ac17eb2023-06-20 18:56:17 -07003227uint32_t EffectChain::EffectCallback::outChannelCount() const {
Eric Laurentb62d0362021-10-26 17:40:18 +02003228 return audio_channel_count_from_out_mask(outChannelMask());
Eric Laurent6b446ce2019-12-13 10:56:31 -08003229}
3230
Andy Hung6ac17eb2023-06-20 18:56:17 -07003231audio_channel_mask_t EffectChain::EffectCallback::hapticChannelMask() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003232 const sp<IAfThreadBase> t = thread().promote();
jiabineb3bda02020-06-30 14:07:03 -07003233 if (t == nullptr) {
3234 return AUDIO_CHANNEL_NONE;
3235 }
3236 return t->hapticChannelMask();
3237}
3238
Andy Hung6ac17eb2023-06-20 18:56:17 -07003239size_t EffectChain::EffectCallback::frameCount() const {
Andy Hung87c693c2023-07-06 20:56:16 -07003240 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003241 if (t == nullptr) {
François Gaffie541fd402023-11-29 17:16:38 +01003242 // frameCount cannot be zero.
3243 return 1;
Eric Laurent6b446ce2019-12-13 10:56:31 -08003244 }
3245 return t->frameCount();
3246}
3247
Andy Hung6ac17eb2023-06-20 18:56:17 -07003248uint32_t EffectChain::EffectCallback::latency() const
Andy Hung920f6572022-10-06 12:09:49 -07003249NO_THREAD_SAFETY_ANALYSIS // latency_l() access
3250{
Andy Hung87c693c2023-07-06 20:56:16 -07003251 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003252 if (t == nullptr) {
3253 return 0;
3254 }
Andy Hung920f6572022-10-06 12:09:49 -07003255 // TODO(b/275956781) - this requires the thread lock.
Eric Laurent6b446ce2019-12-13 10:56:31 -08003256 return t->latency_l();
3257}
3258
Andy Hung6ac17eb2023-06-20 18:56:17 -07003259void EffectChain::EffectCallback::setVolumeForOutput(float left, float right) const
Andy Hung920f6572022-10-06 12:09:49 -07003260NO_THREAD_SAFETY_ANALYSIS // setVolumeForOutput_l() access
3261{
Andy Hung87c693c2023-07-06 20:56:16 -07003262 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003263 if (t == nullptr) {
3264 return;
3265 }
3266 t->setVolumeForOutput_l(left, right);
3267}
3268
Shunkai Yaod125e402024-01-20 03:19:06 +00003269void EffectChain::EffectCallback::checkSuspendOnEffectEnabled(const sp<IAfEffectBase>& effect,
3270 bool enabled, bool threadLocked)
3271 NO_THREAD_SAFETY_ANALYSIS {
Andy Hung87c693c2023-07-06 20:56:16 -07003272 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003273 if (t == nullptr) {
3274 return;
3275 }
3276 t->checkSuspendOnEffectEnabled(enabled, effect->sessionId(), threadLocked);
3277
Andy Hung6ac17eb2023-06-20 18:56:17 -07003278 sp<IAfEffectChain> c = chain().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003279 if (c == nullptr) {
3280 return;
3281 }
Eric Laurent41709552019-12-16 19:34:05 -08003282 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
Shunkai Yaod125e402024-01-20 03:19:06 +00003283 c->checkSuspendOnEffectEnabled_l(effect->asEffectModule(), enabled);
Eric Laurent6b446ce2019-12-13 10:56:31 -08003284}
3285
Andy Hung6ac17eb2023-06-20 18:56:17 -07003286void EffectChain::EffectCallback::onEffectEnable(const sp<IAfEffectBase>& effect) {
Andy Hung87c693c2023-07-06 20:56:16 -07003287 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003288 if (t == nullptr) {
3289 return;
3290 }
Eric Laurent41709552019-12-16 19:34:05 -08003291 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
3292 t->onEffectEnable(effect->asEffectModule());
Eric Laurent6b446ce2019-12-13 10:56:31 -08003293}
3294
Andy Hung6ac17eb2023-06-20 18:56:17 -07003295void EffectChain::EffectCallback::onEffectDisable(const sp<IAfEffectBase>& effect) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003296 checkSuspendOnEffectEnabled(effect, false, false /*threadLocked*/);
3297
Andy Hung87c693c2023-07-06 20:56:16 -07003298 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003299 if (t == nullptr) {
3300 return;
3301 }
3302 t->onEffectDisable();
3303}
3304
Andy Hung6ac17eb2023-06-20 18:56:17 -07003305bool EffectChain::EffectCallback::disconnectEffectHandle(IAfEffectHandle *handle,
Eric Laurent6b446ce2019-12-13 10:56:31 -08003306 bool unpinIfLast) {
Andy Hung87c693c2023-07-06 20:56:16 -07003307 const sp<IAfThreadBase> t = thread().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003308 if (t == nullptr) {
3309 return false;
3310 }
3311 t->disconnectEffectHandle(handle, unpinIfLast);
3312 return true;
3313}
3314
Shunkai Yaod125e402024-01-20 03:19:06 +00003315void EffectChain::EffectCallback::resetVolume_l() {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003316 sp<IAfEffectChain> c = chain().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003317 if (c == nullptr) {
3318 return;
3319 }
3320 c->resetVolume_l();
3321
3322}
3323
Andy Hung6ac17eb2023-06-20 18:56:17 -07003324product_strategy_t EffectChain::EffectCallback::strategy() const {
3325 sp<IAfEffectChain> c = chain().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003326 if (c == nullptr) {
3327 return PRODUCT_STRATEGY_NONE;
3328 }
3329 return c->strategy();
3330}
3331
Andy Hung6ac17eb2023-06-20 18:56:17 -07003332int32_t EffectChain::EffectCallback::activeTrackCnt() const {
3333 sp<IAfEffectChain> c = chain().promote();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003334 if (c == nullptr) {
3335 return 0;
3336 }
3337 return c->activeTrackCnt();
3338}
3339
Eric Laurentb82e6b72019-11-22 17:25:04 -08003340
3341#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -07003342#define LOG_TAG "DeviceEffectProxy"
Eric Laurentb82e6b72019-11-22 17:25:04 -08003343
Andy Hung6ac17eb2023-06-20 18:56:17 -07003344/* static */
3345sp<IAfDeviceEffectProxy> IAfDeviceEffectProxy::create(
3346 const AudioDeviceTypeAddr& device,
Andy Hung55a74fd2023-07-13 19:54:47 -07003347 const sp<DeviceEffectManagerCallback>& callback,
Andy Hung6ac17eb2023-06-20 18:56:17 -07003348 effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
3349{
3350 return sp<DeviceEffectProxy>::make(device,
Andy Hung55a74fd2023-07-13 19:54:47 -07003351 callback,
Andy Hung6ac17eb2023-06-20 18:56:17 -07003352 desc, id, notifyFramesProcessed);
3353}
3354
3355status_t DeviceEffectProxy::setEnabled(bool enabled, bool fromHandle)
Eric Laurentb82e6b72019-11-22 17:25:04 -08003356{
3357 status_t status = EffectBase::setEnabled(enabled, fromHandle);
Andy Hungf65f5a72023-08-29 12:19:17 -07003358 audio_utils::lock_guard _l(proxyMutex());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003359 if (status == NO_ERROR) {
3360 for (auto& handle : mEffectHandles) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07003361 Status bs;
Eric Laurentb82e6b72019-11-22 17:25:04 -08003362 if (enabled) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003363 bs = handle.second->asIEffect()->enable(&status);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003364 } else {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003365 bs = handle.second->asIEffect()->disable(&status);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07003366 }
3367 if (!bs.isOk()) {
Andy Hung1131b6e2020-12-08 20:47:45 -08003368 status = statusTFromBinderStatus(bs);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003369 }
3370 }
3371 }
3372 ALOGV("%s enable %d status %d", __func__, enabled, status);
3373 return status;
3374}
3375
Shunkai Yaod125e402024-01-20 03:19:06 +00003376status_t DeviceEffectProxy::init_l(
Andy Hung8e6b62a2023-07-13 18:11:33 -07003377 const std::map <audio_patch_handle_t, IAfPatchPanel::Patch>& patches) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003378//For all audio patches
3379//If src or sink device match
3380//If the effect is HW accelerated
3381// if no corresponding effect module
3382// Create EffectModule: mHalEffect
3383//Create and attach EffectHandle
3384//If the effect is not HW accelerated and the patch sink or src is a mixer port
3385// Create Effect on patch input or output thread on session -1
3386//Add EffectHandle to EffectHandle map of Effect Proxy:
3387 ALOGV("%s device type %d address %s", __func__, mDevice.mType, mDevice.getAddress());
3388 status_t status = NO_ERROR;
3389 for (auto &patch : patches) {
3390 status = onCreatePatch(patch.first, patch.second);
3391 ALOGV("%s onCreatePatch status %d", __func__, status);
3392 if (status == BAD_VALUE) {
3393 return status;
3394 }
3395 }
3396 return status;
3397}
3398
François Gaffie58e73af2023-02-15 11:47:24 +01003399status_t DeviceEffectProxy::onUpdatePatch(audio_patch_handle_t oldPatchHandle,
3400 audio_patch_handle_t newPatchHandle,
Andy Hung8e6b62a2023-07-13 18:11:33 -07003401 const IAfPatchPanel::Patch& /* patch */) {
François Gaffie58e73af2023-02-15 11:47:24 +01003402 status_t status = NAME_NOT_FOUND;
3403 ALOGV("%s", __func__);
Andy Hungf65f5a72023-08-29 12:19:17 -07003404 audio_utils::lock_guard _l(proxyMutex());
François Gaffie58e73af2023-02-15 11:47:24 +01003405 if (mEffectHandles.find(oldPatchHandle) != mEffectHandles.end()) {
3406 ALOGV("%s replacing effect from handle %d to handle %d", __func__, oldPatchHandle,
3407 newPatchHandle);
3408 sp<IAfEffectHandle> effect = mEffectHandles.at(oldPatchHandle);
3409 mEffectHandles.erase(oldPatchHandle);
3410 mEffectHandles.emplace(newPatchHandle, effect);
3411 status = NO_ERROR;
3412 }
3413 return status;
3414}
3415
Andy Hung6ac17eb2023-06-20 18:56:17 -07003416status_t DeviceEffectProxy::onCreatePatch(
Andy Hung8e6b62a2023-07-13 18:11:33 -07003417 audio_patch_handle_t patchHandle, const IAfPatchPanel::Patch& patch) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003418 status_t status = NAME_NOT_FOUND;
Andy Hung6ac17eb2023-06-20 18:56:17 -07003419 sp<IAfEffectHandle> handle;
Eric Laurentb82e6b72019-11-22 17:25:04 -08003420 // only consider source[0] as this is the only "true" source of a patch
3421 status = checkPort(patch, &patch.mAudioPatch.sources[0], &handle);
3422 ALOGV("%s source checkPort status %d", __func__, status);
3423 for (uint32_t i = 0; i < patch.mAudioPatch.num_sinks && status == NAME_NOT_FOUND; i++) {
3424 status = checkPort(patch, &patch.mAudioPatch.sinks[i], &handle);
3425 ALOGV("%s sink %d checkPort status %d", __func__, i, status);
3426 }
3427 if (status == NO_ERROR || status == ALREADY_EXISTS) {
Andy Hungf65f5a72023-08-29 12:19:17 -07003428 audio_utils::lock_guard _l(proxyMutex());
François Gaffie70c6c722023-06-22 12:23:32 +02003429 size_t erasedHandle = mEffectHandles.erase(patchHandle);
3430 ALOGV("%s %s effecthandle %p for patch %d",
3431 __func__, (erasedHandle == 0 ? "adding" : "replacing"), handle.get(), patchHandle);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003432 mEffectHandles.emplace(patchHandle, handle);
3433 }
3434 ALOGW_IF(status == BAD_VALUE,
3435 "%s cannot attach effect %s on patch %d", __func__, mDescriptor.name, patchHandle);
3436
3437 return status;
3438}
3439
Andy Hung8e6b62a2023-07-13 18:11:33 -07003440status_t DeviceEffectProxy::checkPort(const IAfPatchPanel::Patch& patch,
Andy Hung972bec12023-08-31 16:13:39 -07003441 const struct audio_port_config *port, sp<IAfEffectHandle> *handle)
3442NO_THREAD_SAFETY_ANALYSIS
3443// calling function 'createEffect_l' requires holding mutex 'AudioFlinger_Mutex' exclusively
3444{
Eric Laurentb82e6b72019-11-22 17:25:04 -08003445
3446 ALOGV("%s type %d device type %d address %s device ID %d patch.isSoftware() %d",
3447 __func__, port->type, port->ext.device.type,
3448 port->ext.device.address, port->id, patch.isSoftware());
Shunkai Yaob009ad52023-05-05 22:43:24 +00003449 if (port->type != AUDIO_PORT_TYPE_DEVICE || port->ext.device.type != mDevice.mType ||
3450 port->ext.device.address != mDevice.address()) {
3451 return NAME_NOT_FOUND;
3452 }
3453 if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) &&
3454 (audio_port_config_has_input_direction(port))) {
3455 ALOGI("%s don't create postprocessing effect on record port", __func__);
3456 return NAME_NOT_FOUND;
3457 }
3458 if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) &&
3459 (!audio_port_config_has_input_direction(port))) {
3460 ALOGI("%s don't create preprocessing effect on playback port", __func__);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003461 return NAME_NOT_FOUND;
3462 }
3463 status_t status = NAME_NOT_FOUND;
3464
3465 if (mDescriptor.flags & EFFECT_FLAG_HW_ACC_TUNNEL) {
Andy Hungf65f5a72023-08-29 12:19:17 -07003466 audio_utils::lock_guard _l(proxyMutex());
François Gaffie70c6c722023-06-22 12:23:32 +02003467 if (mHalEffect != nullptr && mDevicePort.id == port->id) {
3468 ALOGV("%s reusing HAL effect", __func__);
3469 } else {
3470 mDevicePort = *port;
3471 mHalEffect = new EffectModule(mMyCallback,
Eric Laurentb82e6b72019-11-22 17:25:04 -08003472 const_cast<effect_descriptor_t *>(&mDescriptor),
3473 mMyCallback->newEffectId(), AUDIO_SESSION_DEVICE,
3474 false /* pinned */, port->id);
François Gaffie70c6c722023-06-22 12:23:32 +02003475 if (audio_is_input_device(mDevice.mType)) {
3476 mHalEffect->setInputDevice(mDevice);
3477 } else {
3478 mHalEffect->setDevices({mDevice});
3479 }
Shunkai Yaod125e402024-01-20 03:19:06 +00003480 mHalEffect->configure_l();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003481 }
Eric Laurentde8caf42021-08-11 17:19:25 +02003482 *handle = new EffectHandle(mHalEffect, nullptr, nullptr, 0 /*priority*/,
3483 mNotifyFramesProcessed);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003484 status = (*handle)->initCheck();
3485 if (status == OK) {
3486 status = mHalEffect->addHandle((*handle).get());
3487 } else {
3488 mHalEffect.clear();
3489 mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
3490 }
3491 } else if (patch.isSoftware() || patch.thread().promote() != nullptr) {
Andy Hung87c693c2023-07-06 20:56:16 -07003492 sp<IAfThreadBase> thread;
Eric Laurentb82e6b72019-11-22 17:25:04 -08003493 if (audio_port_config_has_input_direction(port)) {
3494 if (patch.isSoftware()) {
3495 thread = patch.mRecord.thread();
3496 } else {
3497 thread = patch.thread().promote();
3498 }
3499 } else {
3500 if (patch.isSoftware()) {
3501 thread = patch.mPlayback.thread();
3502 } else {
3503 thread = patch.thread().promote();
3504 }
3505 }
3506 int enabled;
3507 *handle = thread->createEffect_l(nullptr, nullptr, 0, AUDIO_SESSION_DEVICE,
3508 const_cast<effect_descriptor_t *>(&mDescriptor),
Eric Laurentde8caf42021-08-11 17:19:25 +02003509 &enabled, &status, false, false /*probe*/,
3510 mNotifyFramesProcessed);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003511 ALOGV("%s thread->createEffect_l status %d", __func__, status);
3512 } else {
3513 status = BAD_VALUE;
3514 }
Shunkai Yaob009ad52023-05-05 22:43:24 +00003515
Eric Laurentb82e6b72019-11-22 17:25:04 -08003516 if (status == NO_ERROR || status == ALREADY_EXISTS) {
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07003517 Status bs;
Eric Laurentb82e6b72019-11-22 17:25:04 -08003518 if (isEnabled()) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003519 bs = (*handle)->asIEffect()->enable(&status);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003520 } else {
Andy Hung6ac17eb2023-06-20 18:56:17 -07003521 bs = (*handle)->asIEffect()->disable(&status);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -07003522 }
3523 if (!bs.isOk()) {
Andy Hung1131b6e2020-12-08 20:47:45 -08003524 status = statusTFromBinderStatus(bs);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003525 }
3526 }
3527 return status;
3528}
3529
Andy Hung6ac17eb2023-06-20 18:56:17 -07003530void DeviceEffectProxy::onReleasePatch(audio_patch_handle_t patchHandle) {
3531 sp<IAfEffectHandle> effect;
Eric Laurent76c89f32021-12-03 17:13:23 +01003532 {
Andy Hungf65f5a72023-08-29 12:19:17 -07003533 audio_utils::lock_guard _l(proxyMutex());
Eric Laurent76c89f32021-12-03 17:13:23 +01003534 if (mEffectHandles.find(patchHandle) != mEffectHandles.end()) {
3535 effect = mEffectHandles.at(patchHandle);
3536 mEffectHandles.erase(patchHandle);
3537 }
3538 }
Eric Laurentb82e6b72019-11-22 17:25:04 -08003539}
3540
3541
Andy Hung6ac17eb2023-06-20 18:56:17 -07003542size_t DeviceEffectProxy::removeEffect(const sp<IAfEffectModule>& effect)
Eric Laurentb82e6b72019-11-22 17:25:04 -08003543{
Andy Hungf65f5a72023-08-29 12:19:17 -07003544 audio_utils::lock_guard _l(proxyMutex());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003545 if (effect == mHalEffect) {
Eric Laurent76c89f32021-12-03 17:13:23 +01003546 mHalEffect->release_l();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003547 mHalEffect.clear();
3548 mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
3549 }
3550 return mHalEffect == nullptr ? 0 : 1;
3551}
3552
Andy Hung6ac17eb2023-06-20 18:56:17 -07003553status_t DeviceEffectProxy::addEffectToHal(
Andy Hung920f6572022-10-06 12:09:49 -07003554 const sp<EffectHalInterface>& effect) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003555 if (mHalEffect == nullptr) {
3556 return NO_INIT;
3557 }
Mikhail Naganovd2c7f852023-06-14 18:00:13 -07003558 return mManagerCallback->addEffectToHal(&mDevicePort, effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003559}
3560
Andy Hung6ac17eb2023-06-20 18:56:17 -07003561status_t DeviceEffectProxy::removeEffectFromHal(
Andy Hung920f6572022-10-06 12:09:49 -07003562 const sp<EffectHalInterface>& effect) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003563 if (mHalEffect == nullptr) {
3564 return NO_INIT;
3565 }
Mikhail Naganovd2c7f852023-06-14 18:00:13 -07003566 return mManagerCallback->removeEffectFromHal(&mDevicePort, effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003567}
3568
François Gaffiea2e985b2023-06-09 14:37:56 +02003569status_t DeviceEffectProxy::command(
3570 int32_t cmdCode, const std::vector<uint8_t>& cmdData, int32_t maxReplySize,
3571 std::vector<uint8_t>* reply) {
Andy Hungf65f5a72023-08-29 12:19:17 -07003572 audio_utils::lock_guard _l(proxyMutex());
François Gaffiea2e985b2023-06-09 14:37:56 +02003573 status_t status = EffectBase::command(cmdCode, cmdData, maxReplySize, reply);
3574 if (status == NO_ERROR) {
3575 for (auto& handle : mEffectHandles) {
3576 sp<IAfEffectBase> effect = handle.second->effect().promote();
3577 if (effect != nullptr) {
3578 status = effect->command(cmdCode, cmdData, maxReplySize, reply);
3579 }
3580 }
3581 }
3582 ALOGV("%s status %d", __func__, status);
3583 return status;
3584}
3585
Andy Hung6ac17eb2023-06-20 18:56:17 -07003586bool DeviceEffectProxy::isOutput() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003587 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE) {
3588 return mDevicePort.role == AUDIO_PORT_ROLE_SINK;
3589 }
3590 return true;
3591}
3592
Andy Hung6ac17eb2023-06-20 18:56:17 -07003593uint32_t DeviceEffectProxy::sampleRate() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003594 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
3595 (mDevicePort.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) != 0) {
3596 return mDevicePort.sample_rate;
3597 }
3598 return DEFAULT_OUTPUT_SAMPLE_RATE;
3599}
3600
Andy Hung6ac17eb2023-06-20 18:56:17 -07003601audio_channel_mask_t DeviceEffectProxy::channelMask() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003602 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
3603 (mDevicePort.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) != 0) {
3604 return mDevicePort.channel_mask;
3605 }
3606 return AUDIO_CHANNEL_OUT_STEREO;
3607}
3608
Andy Hung6ac17eb2023-06-20 18:56:17 -07003609uint32_t DeviceEffectProxy::channelCount() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003610 if (isOutput()) {
3611 return audio_channel_count_from_out_mask(channelMask());
3612 }
3613 return audio_channel_count_from_in_mask(channelMask());
3614}
3615
Andy Hung6ac17eb2023-06-20 18:56:17 -07003616void DeviceEffectProxy::dump2(int fd, int spaces) const
Andy Hung920f6572022-10-06 12:09:49 -07003617NO_THREAD_SAFETY_ANALYSIS // conditional try lock
3618{
Eric Laurentb82e6b72019-11-22 17:25:04 -08003619 const Vector<String16> args;
3620 EffectBase::dump(fd, args);
3621
Andy Hungf65f5a72023-08-29 12:19:17 -07003622 const bool locked = afutils::dumpTryLock(proxyMutex());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003623 if (!locked) {
3624 String8 result("DeviceEffectProxy may be deadlocked\n");
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00003625 write(fd, result.c_str(), result.size());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003626 }
3627
3628 String8 outStr;
3629 if (mHalEffect != nullptr) {
3630 outStr.appendFormat("%*sHAL Effect Id: %d\n", spaces, "", mHalEffect->id());
3631 } else {
3632 outStr.appendFormat("%*sNO HAL Effect\n", spaces, "");
3633 }
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00003634 write(fd, outStr.c_str(), outStr.size());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003635 outStr.clear();
3636
3637 outStr.appendFormat("%*sSub Effects:\n", spaces, "");
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00003638 write(fd, outStr.c_str(), outStr.size());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003639 outStr.clear();
3640
3641 for (const auto& iter : mEffectHandles) {
3642 outStr.appendFormat("%*sEffect for patch handle %d:\n", spaces + 2, "", iter.first);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00003643 write(fd, outStr.c_str(), outStr.size());
Eric Laurentb82e6b72019-11-22 17:25:04 -08003644 outStr.clear();
Andy Hung6ac17eb2023-06-20 18:56:17 -07003645 sp<IAfEffectBase> effect = iter.second->effect().promote();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003646 if (effect != nullptr) {
3647 effect->dump(fd, args);
3648 }
3649 }
3650
3651 if (locked) {
Andy Hungf65f5a72023-08-29 12:19:17 -07003652 proxyMutex().unlock();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003653 }
3654}
3655
3656#undef LOG_TAG
Andy Hung6ac17eb2023-06-20 18:56:17 -07003657#define LOG_TAG "DeviceEffectProxy::ProxyCallback"
Eric Laurentb82e6b72019-11-22 17:25:04 -08003658
Andy Hung6ac17eb2023-06-20 18:56:17 -07003659int DeviceEffectProxy::ProxyCallback::newEffectId() {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003660 return mManagerCallback->newEffectId();
3661}
3662
3663
Andy Hung6ac17eb2023-06-20 18:56:17 -07003664bool DeviceEffectProxy::ProxyCallback::disconnectEffectHandle(
3665 IAfEffectHandle *handle, bool unpinIfLast) {
3666 sp<IAfEffectBase> effectBase = handle->effect().promote();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003667 if (effectBase == nullptr) {
3668 return false;
3669 }
3670
Andy Hung6ac17eb2023-06-20 18:56:17 -07003671 sp<IAfEffectModule> effect = effectBase->asEffectModule();
Eric Laurentb82e6b72019-11-22 17:25:04 -08003672 if (effect == nullptr) {
3673 return false;
3674 }
3675
3676 // restore suspended effects if the disconnected handle was enabled and the last one.
3677 bool remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
3678 if (remove) {
3679 sp<DeviceEffectProxy> proxy = mProxy.promote();
3680 if (proxy != nullptr) {
3681 proxy->removeEffect(effect);
3682 }
3683 if (handle->enabled()) {
3684 effectBase->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
3685 }
3686 }
3687 return true;
3688}
3689
Andy Hung6ac17eb2023-06-20 18:56:17 -07003690status_t DeviceEffectProxy::ProxyCallback::createEffectHal(
Eric Laurentb82e6b72019-11-22 17:25:04 -08003691 const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
3692 sp<EffectHalInterface> *effect) {
3693 return mManagerCallback->createEffectHal(pEffectUuid, sessionId, deviceId, effect);
3694}
3695
Andy Hung6ac17eb2023-06-20 18:56:17 -07003696status_t DeviceEffectProxy::ProxyCallback::addEffectToHal(
Andy Hung920f6572022-10-06 12:09:49 -07003697 const sp<EffectHalInterface>& effect) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003698 sp<DeviceEffectProxy> proxy = mProxy.promote();
3699 if (proxy == nullptr) {
3700 return NO_INIT;
3701 }
3702 return proxy->addEffectToHal(effect);
3703}
3704
Andy Hung6ac17eb2023-06-20 18:56:17 -07003705status_t DeviceEffectProxy::ProxyCallback::removeEffectFromHal(
Andy Hung920f6572022-10-06 12:09:49 -07003706 const sp<EffectHalInterface>& effect) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003707 sp<DeviceEffectProxy> proxy = mProxy.promote();
3708 if (proxy == nullptr) {
3709 return NO_INIT;
3710 }
Eric Laurent76c89f32021-12-03 17:13:23 +01003711 return proxy->removeEffectFromHal(effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -08003712}
3713
Andy Hung6ac17eb2023-06-20 18:56:17 -07003714bool DeviceEffectProxy::ProxyCallback::isOutput() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003715 sp<DeviceEffectProxy> proxy = mProxy.promote();
3716 if (proxy == nullptr) {
3717 return true;
3718 }
3719 return proxy->isOutput();
3720}
3721
Andy Hung6ac17eb2023-06-20 18:56:17 -07003722uint32_t DeviceEffectProxy::ProxyCallback::sampleRate() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003723 sp<DeviceEffectProxy> proxy = mProxy.promote();
3724 if (proxy == nullptr) {
3725 return DEFAULT_OUTPUT_SAMPLE_RATE;
3726 }
3727 return proxy->sampleRate();
3728}
3729
Andy Hung6ac17eb2023-06-20 18:56:17 -07003730audio_channel_mask_t DeviceEffectProxy::ProxyCallback::inChannelMask(
Eric Laurentf1f22e72021-07-13 14:04:14 +02003731 int id __unused) const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003732 sp<DeviceEffectProxy> proxy = mProxy.promote();
3733 if (proxy == nullptr) {
3734 return AUDIO_CHANNEL_OUT_STEREO;
3735 }
3736 return proxy->channelMask();
3737}
3738
Andy Hung6ac17eb2023-06-20 18:56:17 -07003739uint32_t DeviceEffectProxy::ProxyCallback::inChannelCount(int id __unused) const {
Eric Laurentf1f22e72021-07-13 14:04:14 +02003740 sp<DeviceEffectProxy> proxy = mProxy.promote();
3741 if (proxy == nullptr) {
3742 return 2;
3743 }
3744 return proxy->channelCount();
3745}
3746
Andy Hung6ac17eb2023-06-20 18:56:17 -07003747audio_channel_mask_t DeviceEffectProxy::ProxyCallback::outChannelMask() const {
Eric Laurentf1f22e72021-07-13 14:04:14 +02003748 sp<DeviceEffectProxy> proxy = mProxy.promote();
3749 if (proxy == nullptr) {
3750 return AUDIO_CHANNEL_OUT_STEREO;
3751 }
3752 return proxy->channelMask();
3753}
3754
Andy Hung6ac17eb2023-06-20 18:56:17 -07003755uint32_t DeviceEffectProxy::ProxyCallback::outChannelCount() const {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003756 sp<DeviceEffectProxy> proxy = mProxy.promote();
3757 if (proxy == nullptr) {
3758 return 2;
3759 }
3760 return proxy->channelCount();
3761}
3762
Andy Hung6ac17eb2023-06-20 18:56:17 -07003763void DeviceEffectProxy::ProxyCallback::onEffectEnable(
3764 const sp<IAfEffectBase>& effectBase) {
3765 sp<IAfEffectModule> effect = effectBase->asEffectModule();
Eric Laurent76c89f32021-12-03 17:13:23 +01003766 if (effect == nullptr) {
3767 return;
3768 }
Shunkai Yaod125e402024-01-20 03:19:06 +00003769 effect->start_l();
Eric Laurent76c89f32021-12-03 17:13:23 +01003770}
3771
Andy Hung6ac17eb2023-06-20 18:56:17 -07003772void DeviceEffectProxy::ProxyCallback::onEffectDisable(
3773 const sp<IAfEffectBase>& effectBase) {
3774 sp<IAfEffectModule> effect = effectBase->asEffectModule();
Eric Laurent76c89f32021-12-03 17:13:23 +01003775 if (effect == nullptr) {
3776 return;
3777 }
Shunkai Yaod125e402024-01-20 03:19:06 +00003778 effect->stop_l();
Eric Laurent76c89f32021-12-03 17:13:23 +01003779}
3780
Glenn Kasten63238ef2015-03-02 15:50:29 -08003781} // namespace android