1 /*
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
22 #include "Effects.h"
23
24 #include "Client.h"
25 #include "EffectConfiguration.h"
26
27 #include <afutils/FallibleLockGuard.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/EffectClientAsyncProxy.h>
35 #include <media/ShmemCompat.h>
36 #include <media/TypeConverter.h>
37 #include <media/audiohal/EffectHalInterface.h>
38 #include <media/audiohal/EffectsFactoryHalInterface.h>
39 #include <mediautils/MethodStatistics.h>
40 #include <mediautils/ServiceUtilities.h>
41 #include <mediautils/TimeCheck.h>
42 #include <system/audio_effects/audio_effects_utils.h>
43 #include <system/audio_effects/effect_aec.h>
44 #include <system/audio_effects/effect_downmix.h>
45 #include <system/audio_effects/effect_dynamicsprocessing.h>
46 #include <system/audio_effects/effect_hapticgenerator.h>
47 #include <system/audio_effects/effect_ns.h>
48 #include <system/audio_effects/effect_spatializer.h>
49 #include <system/audio_effects/effect_visualizer.h>
50 #include <utils/Log.h>
51
52 #include <algorithm>
53
54 // ----------------------------------------------------------------------------
55
56 // Note: the following macro is used for extremely verbose logging message. In
57 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
58 // 0; but one side effect of this is to turn all LOGV's as well. Some messages
59 // are so verbose that we want to suppress them even when we have ALOG_ASSERT
60 // turned on. Do not uncomment the #def below unless you really know what you
61 // are doing and want to see all of the extremely verbose messages.
62 //#define VERY_VERY_VERBOSE_LOGGING
63 #ifdef VERY_VERY_VERBOSE_LOGGING
64 #define ALOGVV ALOGV
65 #else
66 #define ALOGVV(a...) do { } while(0)
67 #endif
68
69 #define DEFAULT_OUTPUT_SAMPLE_RATE 48000
70
71 namespace android {
72
73 using aidl_utils::statusTFromBinderStatus;
74 using android::effect::utils::EffectParamWriter;
75 using audioflinger::EffectConfiguration;
76 using binder::Status;
77
78 namespace {
79
80 // Append a POD value into a vector of bytes.
81 template<typename T>
appendToBuffer(const T & value,std::vector<uint8_t> * buffer)82 void appendToBuffer(const T& value, std::vector<uint8_t>* buffer) {
83 const uint8_t* ar(reinterpret_cast<const uint8_t*>(&value));
84 buffer->insert(buffer->end(), ar, ar + sizeof(T));
85 }
86
87 // Write a POD value into a vector of bytes (clears the previous buffer
88 // content).
89 template<typename T>
writeToBuffer(const T & value,std::vector<uint8_t> * buffer)90 void writeToBuffer(const T& value, std::vector<uint8_t>* buffer) {
91 buffer->clear();
92 appendToBuffer(value, buffer);
93 }
94
95 } // namespace
96
97 // ----------------------------------------------------------------------------
98 // EffectBase implementation
99 // ----------------------------------------------------------------------------
100
101 #undef LOG_TAG
102 #define LOG_TAG "EffectBase"
103
EffectBase(const sp<EffectCallbackInterface> & callback,effect_descriptor_t * desc,int id,audio_session_t sessionId,bool pinned)104 EffectBase::EffectBase(const sp<EffectCallbackInterface>& callback,
105 effect_descriptor_t *desc,
106 int id,
107 audio_session_t sessionId,
108 bool pinned)
109 : mPinned(pinned),
110 mCallback(callback), mId(id), mSessionId(sessionId),
111 mDescriptor(*desc)
112 {
113 }
114
115 // must be called with EffectModule::mutex() held
setEnabled_l(bool enabled)116 status_t EffectBase::setEnabled_l(bool enabled)
117 {
118
119 ALOGV("setEnabled %p enabled %d", this, enabled);
120
121 if (enabled != isEnabled()) {
122 switch (mState) {
123 // going from disabled to enabled
124 case IDLE:
125 mState = STARTING;
126 break;
127 case STOPPED:
128 mState = RESTART;
129 break;
130 case STOPPING:
131 mState = ACTIVE;
132 break;
133
134 // going from enabled to disabled
135 case RESTART:
136 mState = STOPPED;
137 break;
138 case STARTING:
139 mState = IDLE;
140 break;
141 case ACTIVE:
142 mState = STOPPING;
143 break;
144 case DESTROYED:
145 return NO_ERROR; // simply ignore as we are being destroyed
146 }
147 for (size_t i = 1; i < mHandles.size(); i++) {
148 IAfEffectHandle *h = mHandles[i];
149 if (h != NULL && !h->disconnected()) {
150 h->setEnabled(enabled);
151 }
152 }
153 }
154 return NO_ERROR;
155 }
156
setEnabled(bool enabled,bool fromHandle)157 status_t EffectBase::setEnabled(bool enabled, bool fromHandle)
158 {
159 status_t status;
160 {
161 audio_utils::lock_guard _l(mutex());
162 status = setEnabled_l(enabled);
163 }
164 if (fromHandle) {
165 if (enabled) {
166 if (status != NO_ERROR) {
167 getCallback()->checkSuspendOnEffectEnabled(this, false, false /*threadLocked*/);
168 } else {
169 getCallback()->onEffectEnable(this);
170 }
171 } else {
172 getCallback()->onEffectDisable(this);
173 }
174 }
175 return status;
176 }
177
isEnabled() const178 bool EffectBase::isEnabled() const
179 {
180 switch (mState) {
181 case RESTART:
182 case STARTING:
183 case ACTIVE:
184 return true;
185 case IDLE:
186 case STOPPING:
187 case STOPPED:
188 case DESTROYED:
189 default:
190 return false;
191 }
192 }
193
setSuspended(bool suspended)194 void EffectBase::setSuspended(bool suspended)
195 {
196 audio_utils::lock_guard _l(mutex());
197 mSuspended = suspended;
198 }
199
suspended() const200 bool EffectBase::suspended() const
201 {
202 audio_utils::lock_guard _l(mutex());
203 return mSuspended;
204 }
205
addHandle(IAfEffectHandle * handle)206 status_t EffectBase::addHandle(IAfEffectHandle *handle)
207 {
208 status_t status;
209
210 audio_utils::lock_guard _l(mutex());
211 int priority = handle->priority();
212 size_t size = mHandles.size();
213 IAfEffectHandle *controlHandle = nullptr;
214 size_t i;
215 for (i = 0; i < size; i++) {
216 IAfEffectHandle *h = mHandles[i];
217 if (h == NULL || h->disconnected()) {
218 continue;
219 }
220 // first non destroyed handle is considered in control
221 if (controlHandle == NULL) {
222 controlHandle = h;
223 }
224 if (h->priority() <= priority) {
225 break;
226 }
227 }
228 // if inserted in first place, move effect control from previous owner to this handle
229 if (i == 0) {
230 bool enabled = false;
231 if (controlHandle != NULL) {
232 enabled = controlHandle->enabled();
233 controlHandle->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
234 }
235 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
236 status = NO_ERROR;
237 } else {
238 status = ALREADY_EXISTS;
239 }
240 ALOGV("addHandle() %p added handle %p in position %zu", this, handle, i);
241 mHandles.insertAt(handle, i);
242 return status;
243 }
244
updatePolicyState()245 status_t EffectBase::updatePolicyState()
246 {
247 status_t status = NO_ERROR;
248 bool doRegister = false;
249 bool registered = false;
250 bool doEnable = false;
251 bool enabled = false;
252 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
253 product_strategy_t strategy = PRODUCT_STRATEGY_NONE;
254
255 {
256 audio_utils::lock_guard _l(mutex());
257
258 if ((isInternal_l() && !mPolicyRegistered)
259 || !getCallback()->isAudioPolicyReady()) {
260 return NO_ERROR;
261 }
262
263 // register effect when first handle is attached and unregister when last handle is removed
264 if (mPolicyRegistered != mHandles.size() > 0) {
265 doRegister = true;
266 mPolicyRegistered = mHandles.size() > 0;
267 if (mPolicyRegistered) {
268 const auto callback = getCallback();
269 io = callback->io();
270 strategy = callback->strategy();
271 }
272 }
273 // enable effect when registered according to enable state requested by controlling handle
274 if (mHandles.size() > 0) {
275 IAfEffectHandle *handle = controlHandle_l();
276 if (handle != nullptr && mPolicyEnabled != handle->enabled()) {
277 doEnable = true;
278 mPolicyEnabled = handle->enabled();
279 }
280 }
281 registered = mPolicyRegistered;
282 enabled = mPolicyEnabled;
283 // The simultaneous release of two EffectHandles with the same EffectModule
284 // may cause us to call this method at the same time.
285 // This may deadlock under some circumstances (b/180941720). Avoid this.
286 if (!doRegister && !(registered && doEnable)) {
287 return NO_ERROR;
288 }
289 }
290 policyMutex().lock();
291 ALOGV("%s name %s id %d session %d doRegister %d registered %d doEnable %d enabled %d",
292 __func__, mDescriptor.name, mId, mSessionId, doRegister, registered, doEnable, enabled);
293 if (doRegister) {
294 if (registered) {
295 status = AudioSystem::registerEffect(
296 &mDescriptor,
297 io,
298 strategy,
299 mSessionId,
300 mId);
301 } else {
302 status = AudioSystem::unregisterEffect(mId);
303 }
304 }
305 if (registered && doEnable) {
306 status = AudioSystem::setEffectEnabled(mId, enabled);
307 }
308 policyMutex().unlock();
309
310 return status;
311 }
312
313
removeHandle(IAfEffectHandle * handle)314 ssize_t EffectBase::removeHandle(IAfEffectHandle *handle)
315 {
316 audio_utils::lock_guard _l(mutex());
317 return removeHandle_l(handle);
318 }
319
removeHandle_l(IAfEffectHandle * handle)320 ssize_t EffectBase::removeHandle_l(IAfEffectHandle *handle)
321 {
322 size_t size = mHandles.size();
323 size_t i;
324 for (i = 0; i < size; i++) {
325 if (mHandles[i] == handle) {
326 break;
327 }
328 }
329 if (i == size) {
330 ALOGW("%s %p handle not found %p", __FUNCTION__, this, handle);
331 return BAD_VALUE;
332 }
333 ALOGV("removeHandle_l() %p removed handle %p in position %zu", this, handle, i);
334
335 mHandles.removeAt(i);
336 // if removed from first place, move effect control from this handle to next in line
337 if (i == 0) {
338 IAfEffectHandle *h = controlHandle_l();
339 if (h != NULL) {
340 h->setControl(true /*hasControl*/, true /*signal*/ , handle->enabled() /*enabled*/);
341 }
342 }
343
344 // Prevent calls to process() and other functions on effect interface from now on.
345 // The effect engine will be released by the destructor when the last strong reference on
346 // this object is released which can happen after next process is called.
347 if (mHandles.size() == 0 && !mPinned) {
348 mState = DESTROYED;
349 }
350
351 return mHandles.size();
352 }
353
354 // must be called with EffectModule::mutex() held
controlHandle_l()355 IAfEffectHandle *EffectBase::controlHandle_l()
356 {
357 // the first valid handle in the list has control over the module
358 for (size_t i = 0; i < mHandles.size(); i++) {
359 IAfEffectHandle *h = mHandles[i];
360 if (h != NULL && !h->disconnected()) {
361 return h;
362 }
363 }
364
365 return NULL;
366 }
367
368 // unsafe method called when the effect parent thread has been destroyed
disconnectHandle(IAfEffectHandle * handle,bool unpinIfLast)369 ssize_t EffectBase::disconnectHandle(IAfEffectHandle *handle, bool unpinIfLast)
370 {
371 const auto callback = getCallback();
372 ALOGV("disconnect() %p handle %p", this, handle);
373 if (callback->disconnectEffectHandle(handle, unpinIfLast)) {
374 return mHandles.size();
375 }
376
377 audio_utils::lock_guard _l(mutex());
378 ssize_t numHandles = removeHandle_l(handle);
379 if ((numHandles == 0) && (!mPinned || unpinIfLast)) {
380 mutex().unlock();
381 callback->updateOrphanEffectChains(this);
382 mutex().lock();
383 }
384 return numHandles;
385 }
386
purgeHandles()387 bool EffectBase::purgeHandles()
388 {
389 bool enabled = false;
390 audio_utils::lock_guard _l(mutex());
391 IAfEffectHandle *handle = controlHandle_l();
392 if (handle != NULL) {
393 enabled = handle->enabled();
394 }
395 mHandles.clear();
396 return enabled;
397 }
398
checkSuspendOnEffectEnabled(bool enabled,bool threadLocked)399 void EffectBase::checkSuspendOnEffectEnabled(bool enabled, bool threadLocked) {
400 getCallback()->checkSuspendOnEffectEnabled(this, enabled, threadLocked);
401 }
402
effectFlagsToString(uint32_t flags)403 static String8 effectFlagsToString(uint32_t flags) {
404 String8 s;
405
406 s.append("conn. mode: ");
407 switch (flags & EFFECT_FLAG_TYPE_MASK) {
408 case EFFECT_FLAG_TYPE_INSERT: s.append("insert"); break;
409 case EFFECT_FLAG_TYPE_AUXILIARY: s.append("auxiliary"); break;
410 case EFFECT_FLAG_TYPE_REPLACE: s.append("replace"); break;
411 case EFFECT_FLAG_TYPE_PRE_PROC: s.append("preproc"); break;
412 case EFFECT_FLAG_TYPE_POST_PROC: s.append("postproc"); break;
413 default: s.append("unknown/reserved"); break;
414 }
415 s.append(", ");
416
417 s.append("insert pref: ");
418 switch (flags & EFFECT_FLAG_INSERT_MASK) {
419 case EFFECT_FLAG_INSERT_ANY: s.append("any"); break;
420 case EFFECT_FLAG_INSERT_FIRST: s.append("first"); break;
421 case EFFECT_FLAG_INSERT_LAST: s.append("last"); break;
422 case EFFECT_FLAG_INSERT_EXCLUSIVE: s.append("exclusive"); break;
423 default: s.append("unknown/reserved"); break;
424 }
425 s.append(", ");
426
427 s.append("volume mgmt: ");
428 switch (flags & EFFECT_FLAG_VOLUME_MASK) {
429 case EFFECT_FLAG_VOLUME_NONE: s.append("none"); break;
430 case EFFECT_FLAG_VOLUME_CTRL: s.append("implements control"); break;
431 case EFFECT_FLAG_VOLUME_IND: s.append("requires indication"); break;
432 case EFFECT_FLAG_VOLUME_MONITOR: s.append("monitors volume"); break;
433 default: s.append("unknown/reserved"); break;
434 }
435 s.append(", ");
436
437 uint32_t devind = flags & EFFECT_FLAG_DEVICE_MASK;
438 if (devind) {
439 s.append("device indication: ");
440 switch (devind) {
441 case EFFECT_FLAG_DEVICE_IND: s.append("requires updates"); break;
442 default: s.append("unknown/reserved"); break;
443 }
444 s.append(", ");
445 }
446
447 s.append("input mode: ");
448 switch (flags & EFFECT_FLAG_INPUT_MASK) {
449 case EFFECT_FLAG_INPUT_DIRECT: s.append("direct"); break;
450 case EFFECT_FLAG_INPUT_PROVIDER: s.append("provider"); break;
451 case EFFECT_FLAG_INPUT_BOTH: s.append("direct+provider"); break;
452 default: s.append("not set"); break;
453 }
454 s.append(", ");
455
456 s.append("output mode: ");
457 switch (flags & EFFECT_FLAG_OUTPUT_MASK) {
458 case EFFECT_FLAG_OUTPUT_DIRECT: s.append("direct"); break;
459 case EFFECT_FLAG_OUTPUT_PROVIDER: s.append("provider"); break;
460 case EFFECT_FLAG_OUTPUT_BOTH: s.append("direct+provider"); break;
461 default: s.append("not set"); break;
462 }
463 s.append(", ");
464
465 uint32_t accel = flags & EFFECT_FLAG_HW_ACC_MASK;
466 if (accel) {
467 s.append("hardware acceleration: ");
468 switch (accel) {
469 case EFFECT_FLAG_HW_ACC_SIMPLE: s.append("non-tunneled"); break;
470 case EFFECT_FLAG_HW_ACC_TUNNEL: s.append("tunneled"); break;
471 default: s.append("unknown/reserved"); break;
472 }
473 s.append(", ");
474 }
475
476 uint32_t modeind = flags & EFFECT_FLAG_AUDIO_MODE_MASK;
477 if (modeind) {
478 s.append("mode indication: ");
479 switch (modeind) {
480 case EFFECT_FLAG_AUDIO_MODE_IND: s.append("required"); break;
481 default: s.append("unknown/reserved"); break;
482 }
483 s.append(", ");
484 }
485
486 uint32_t srcind = flags & EFFECT_FLAG_AUDIO_SOURCE_MASK;
487 if (srcind) {
488 s.append("source indication: ");
489 switch (srcind) {
490 case EFFECT_FLAG_AUDIO_SOURCE_IND: s.append("required"); break;
491 default: s.append("unknown/reserved"); break;
492 }
493 s.append(", ");
494 }
495
496 if (flags & EFFECT_FLAG_OFFLOAD_MASK) {
497 s.append("offloadable, ");
498 }
499
500 int len = s.length();
501 if (s.length() > 2) {
502 (void) s.lockBuffer(len);
503 s.unlockBuffer(len - 2);
504 }
505 return s;
506 }
507
dump(int fd,const Vector<String16> & args __unused) const508 void EffectBase::dump(int fd, const Vector<String16>& args __unused) const
509 {
510 String8 result;
511
512 result.appendFormat("\tEffect ID %d:\n", mId);
513
514 {
515 afutils::FallibleLockGuard l{mutex()};
516 // failed to lock - AudioFlinger is probably deadlocked
517 if (!l) {
518 result.append("\t\tCould not lock Fx mutex:\n");
519 }
520 bool isInternal = isInternal_l();
521 result.append("\t\tSession State Registered Internal Enabled Suspended:\n");
522 result.appendFormat("\t\t%05d %03d %s %s %s %s\n",
523 mSessionId, mState, mPolicyRegistered ? "y" : "n", isInternal ? "y" : "n",
524 ((isInternal && isEnabled()) || (!isInternal && mPolicyEnabled)) ? "y" : "n",
525 mSuspended ? "y" : "n");
526
527 result.append("\t\tDescriptor:\n");
528 char uuidStr[64];
529 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
530 result.appendFormat("\t\t- UUID: %s\n", uuidStr);
531 AudioEffect::guidToString(&mDescriptor.type, uuidStr, sizeof(uuidStr));
532 result.appendFormat("\t\t- TYPE: %s\n", uuidStr);
533 result.appendFormat("\t\t- apiVersion: %08X\n\t\t- flags: %08X (%s)\n",
534 mDescriptor.apiVersion,
535 mDescriptor.flags,
536 effectFlagsToString(mDescriptor.flags).c_str());
537 result.appendFormat("\t\t- name: %s\n",
538 mDescriptor.name);
539
540 result.appendFormat("\t\t- implementor: %s\n",
541 mDescriptor.implementor);
542
543 result.appendFormat("\t\t%zu Clients:\n", mHandles.size());
544 result.append("\t\t\t Pid Priority Ctrl Locked client server\n");
545 char buffer[256];
546 for (size_t i = 0; i < mHandles.size(); ++i) {
547 IAfEffectHandle *handle = mHandles[i];
548 if (handle != NULL && !handle->disconnected()) {
549 handle->dumpToBuffer(buffer, sizeof(buffer));
550 result.append(buffer);
551 }
552 }
553 }
554
555 write(fd, result.c_str(), result.length());
556 }
557
558 // ----------------------------------------------------------------------------
559 // EffectModule implementation
560 // ----------------------------------------------------------------------------
561
562 #undef LOG_TAG
563 #define LOG_TAG "EffectModule"
564
EffectModule(const sp<EffectCallbackInterface> & callback,effect_descriptor_t * desc,int id,audio_session_t sessionId,bool pinned,audio_port_handle_t deviceId)565 EffectModule::EffectModule(const sp<EffectCallbackInterface>& callback, effect_descriptor_t* desc,
566 int id, audio_session_t sessionId, bool pinned,
567 audio_port_handle_t deviceId)
568 : EffectBase(callback, desc, id, sessionId, pinned),
569 // clear mConfig to ensure consistent initial value of buffer framecount
570 // in case buffers are associated by setInBuffer() or setOutBuffer()
571 // prior to configure_l().
572 mConfig{{}, {}},
573 mStatus(NO_INIT),
574 mMaxDisableWaitCnt(1), // set by configure_l(), should be >= 1
575 mDisableWaitCnt(0), // set by process() and updateState()
576 mOffloaded(false),
577 mIsOutput(false),
578 mSupportsFloat(false),
579 mEffectInterfaceDebug(desc->name) {
580 ALOGV("Constructor %p pinned %d", this, pinned);
581 int lStatus;
582
583 // create effect engine from effect factory
584 mStatus = callback->createEffectHal(
585 &desc->uuid, sessionId, deviceId, &mEffectInterface);
586 if (mStatus != NO_ERROR) {
587 ALOGE("%s createEffectHal failed: %d", __func__, mStatus);
588 return;
589 }
590 lStatus = init_l();
591 if (lStatus < 0) {
592 mStatus = lStatus;
593 goto Error;
594 }
595
596 setOffloaded_l(callback->isOffload(), callback->io());
597 ALOGV("%s Constructor success name %s, Interface %p", __func__, mDescriptor.name,
598 mEffectInterface.get());
599
600 return;
601 Error:
602 mEffectInterface.clear();
603 mEffectInterfaceDebug += " init failed:" + std::to_string(lStatus);
604 ALOGE("%s Constructor Error %d", __func__, mStatus);
605 }
606
~EffectModule()607 EffectModule::~EffectModule()
608 {
609 ALOGV("Destructor %p", this);
610 if (mEffectInterface != 0) {
611 char uuidStr[64];
612 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
613 ALOGW("EffectModule %p destructor called with unreleased interface, effect %s",
614 this, uuidStr);
615 release_l("~EffectModule");
616 }
617
618 }
619
620 // return true if any effect started or stopped
updateState_l()621 bool EffectModule::updateState_l() {
622 audio_utils::lock_guard _l(mutex());
623
624 bool startedOrStopped = false;
625 switch (mState) {
626 case RESTART:
627 reset_l();
628 FALLTHROUGH_INTENDED;
629
630 case STARTING:
631 // clear auxiliary effect input buffer for next accumulation
632 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
633 memset(mConfig.inputCfg.buffer.raw,
634 0,
635 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
636 }
637 if (start_ll() == NO_ERROR) {
638 mState = ACTIVE;
639 startedOrStopped = true;
640 } else {
641 mState = IDLE;
642 }
643 break;
644 case STOPPING:
645 // volume control for offload and direct threads must take effect immediately.
646 if (stop_ll() == NO_ERROR
647 && !(isVolumeControl() && isOffloadedOrDirect_l())) {
648 mDisableWaitCnt = mMaxDisableWaitCnt;
649 } else {
650 mDisableWaitCnt = 1; // will cause immediate transition to IDLE
651 }
652 mState = STOPPED;
653 break;
654 case STOPPED:
655 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
656 // turn off sequence.
657 if (--mDisableWaitCnt == 0) {
658 reset_l();
659 startedOrStopped = true;
660 mState = IDLE;
661 }
662 break;
663 case ACTIVE:
664 for (size_t i = 0; i < mHandles.size(); i++) {
665 if (!mHandles[i]->disconnected()) {
666 mHandles[i]->framesProcessed(mConfig.inputCfg.buffer.frameCount);
667 }
668 }
669 break;
670 default: //IDLE , ACTIVE, DESTROYED
671 break;
672 }
673
674 return startedOrStopped;
675 }
676
process()677 void EffectModule::process()
678 {
679 audio_utils::lock_guard _l(mutex());
680
681 if (mState == DESTROYED || mEffectInterface == 0 || mInBuffer == 0 || mOutBuffer == 0) {
682 return;
683 }
684
685 const uint32_t inChannelCount =
686 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
687 const uint32_t outChannelCount =
688 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
689 const bool auxType =
690 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
691
692 // safeInputOutputSampleCount is 0 if the channel count between input and output
693 // buffers do not match. This prevents automatic accumulation or copying between the
694 // input and output effect buffers without an intermediary effect process.
695 // TODO: consider implementing channel conversion.
696 const size_t safeInputOutputSampleCount =
697 mInChannelCountRequested != mOutChannelCountRequested ? 0
698 : mOutChannelCountRequested * std::min(
699 mConfig.inputCfg.buffer.frameCount,
700 mConfig.outputCfg.buffer.frameCount);
701 const auto accumulateInputToOutput = [this, safeInputOutputSampleCount]() {
702 accumulate_float(
703 mConfig.outputCfg.buffer.f32,
704 mConfig.inputCfg.buffer.f32,
705 safeInputOutputSampleCount);
706 };
707 const auto copyInputToOutput = [this, safeInputOutputSampleCount]() {
708 memcpy(
709 mConfig.outputCfg.buffer.f32,
710 mConfig.inputCfg.buffer.f32,
711 safeInputOutputSampleCount * sizeof(*mConfig.outputCfg.buffer.f32));
712 };
713
714 if (isProcessEnabled()) {
715 int ret;
716 if (isProcessImplemented()) {
717 if (auxType) {
718 // We overwrite the aux input buffer here and clear after processing.
719 // aux input is always mono.
720
721 if (!mSupportsFloat) {
722 memcpy_to_i16_from_float(
723 mConfig.inputCfg.buffer.s16,
724 mConfig.inputCfg.buffer.f32,
725 mConfig.inputCfg.buffer.frameCount);
726 }
727 }
728 sp<EffectBufferHalInterface> inBuffer = mInBuffer;
729 sp<EffectBufferHalInterface> outBuffer = mOutBuffer;
730
731 if (!auxType && mInChannelCountRequested != inChannelCount) {
732 adjust_channels(
733 inBuffer->audioBuffer()->f32, mInChannelCountRequested,
734 mInConversionBuffer->audioBuffer()->f32, inChannelCount,
735 sizeof(float),
736 sizeof(float)
737 * mInChannelCountRequested * mConfig.inputCfg.buffer.frameCount);
738 inBuffer = mInConversionBuffer;
739 }
740 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE
741 && mOutChannelCountRequested != outChannelCount) {
742 adjust_selected_channels(
743 outBuffer->audioBuffer()->f32, mOutChannelCountRequested,
744 mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
745 sizeof(float),
746 sizeof(float)
747 * mOutChannelCountRequested * mConfig.outputCfg.buffer.frameCount);
748 outBuffer = mOutConversionBuffer;
749 }
750 if (!mSupportsFloat) { // convert input to int16_t as effect doesn't support float.
751 if (!auxType) {
752 if (mInConversionBuffer == nullptr) {
753 ALOGW("%s: mInConversionBuffer is null, bypassing", __func__);
754 goto data_bypass;
755 }
756 memcpy_to_i16_from_float(
757 mInConversionBuffer->audioBuffer()->s16,
758 inBuffer->audioBuffer()->f32,
759 inChannelCount * mConfig.inputCfg.buffer.frameCount);
760 inBuffer = mInConversionBuffer;
761 }
762 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
763 if (mOutConversionBuffer == nullptr) {
764 ALOGW("%s: mOutConversionBuffer is null, bypassing", __func__);
765 goto data_bypass;
766 }
767 memcpy_to_i16_from_float(
768 mOutConversionBuffer->audioBuffer()->s16,
769 outBuffer->audioBuffer()->f32,
770 outChannelCount * mConfig.outputCfg.buffer.frameCount);
771 outBuffer = mOutConversionBuffer;
772 }
773 }
774 ret = mEffectInterface->process();
775 if (!mSupportsFloat) { // convert output int16_t back to float.
776 sp<EffectBufferHalInterface> target =
777 mOutChannelCountRequested != outChannelCount
778 ? mOutConversionBuffer : mOutBuffer;
779
780 memcpy_to_float_from_i16(
781 target->audioBuffer()->f32,
782 mOutConversionBuffer->audioBuffer()->s16,
783 outChannelCount * mConfig.outputCfg.buffer.frameCount);
784 }
785 if (mOutChannelCountRequested != outChannelCount) {
786 adjust_selected_channels(mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
787 mOutBuffer->audioBuffer()->f32, mOutChannelCountRequested,
788 sizeof(float),
789 sizeof(float) * outChannelCount * mConfig.outputCfg.buffer.frameCount);
790 }
791 } else {
792 data_bypass:
793 if (!auxType /* aux effects do not require data bypass */
794 && mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
795 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
796 accumulateInputToOutput();
797 } else {
798 copyInputToOutput();
799 }
800 }
801 ret = -ENODATA;
802 }
803
804 // force transition to IDLE state when engine is ready
805 if (mState == STOPPED && ret == -ENODATA) {
806 mDisableWaitCnt = 1;
807 }
808
809 // clear auxiliary effect input buffer for next accumulation
810 if (auxType) {
811 const size_t size =
812 mConfig.inputCfg.buffer.frameCount * inChannelCount * sizeof(float);
813 memset(mConfig.inputCfg.buffer.raw, 0, size);
814 }
815 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
816 // mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw
817 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
818 // If an insert effect is idle and input buffer is different from output buffer,
819 // accumulate input onto output
820 if (getCallback()->activeTrackCnt() != 0) {
821 // similar handling with data_bypass above.
822 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
823 accumulateInputToOutput();
824 } else { // EFFECT_BUFFER_ACCESS_WRITE
825 copyInputToOutput();
826 }
827 }
828 }
829 }
830
reset_l()831 void EffectModule::reset_l()
832 {
833 if (mStatus != NO_ERROR || mEffectInterface == 0) {
834 return;
835 }
836
837 int reply = 0;
838 uint32_t replySize = sizeof(reply);
839 mEffectInterface->command(EFFECT_CMD_RESET, 0, NULL, &replySize, &reply);
840 }
841
configure_l()842 status_t EffectModule::configure_l()
843 {
844 ALOGVV("%s started", __func__);
845 status_t status;
846 uint32_t size;
847 audio_channel_mask_t channelMask;
848 sp<EffectCallbackInterface> callback;
849
850 if (mEffectInterface == 0) {
851 status = NO_INIT;
852 goto exit;
853 }
854
855 // TODO: handle configuration of effects replacing track process
856 // TODO: handle configuration of input (record) SW effects above the HAL,
857 // similar to output EFFECT_FLAG_TYPE_INSERT/REPLACE,
858 // in which case input channel masks should be used here.
859 callback = getCallback();
860 channelMask = callback->inChannelMask(mId);
861 mConfig.inputCfg.channels = channelMask;
862 mConfig.outputCfg.channels = callback->outChannelMask();
863
864 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
865 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_MONO) {
866 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
867 ALOGV("Overriding auxiliary effect input channels %#x as MONO",
868 mConfig.inputCfg.channels);
869 }
870 }
871 if (isHapticGenerator()) {
872 audio_channel_mask_t hapticChannelMask = callback->hapticChannelMask();
873 mConfig.inputCfg.channels |= hapticChannelMask;
874 mConfig.outputCfg.channels |= hapticChannelMask;
875 }
876 mInChannelCountRequested =
877 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
878 mOutChannelCountRequested =
879 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
880
881 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
882 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
883
884 // Don't use sample rate for thread if effect isn't offloadable.
885 if (callback->isOffloadOrDirect() && !isOffloaded_l()) {
886 mConfig.inputCfg.samplingRate = DEFAULT_OUTPUT_SAMPLE_RATE;
887 ALOGV("Overriding effect input as 48kHz");
888 } else {
889 mConfig.inputCfg.samplingRate = callback->sampleRate();
890 }
891 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
892 mConfig.inputCfg.bufferProvider.cookie = NULL;
893 mConfig.inputCfg.bufferProvider.getBuffer = NULL;
894 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
895 mConfig.outputCfg.bufferProvider.cookie = NULL;
896 mConfig.outputCfg.bufferProvider.getBuffer = NULL;
897 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
898 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
899 // Insert effect:
900 // - in global sessions (e.g AUDIO_SESSION_OUTPUT_MIX),
901 // always overwrites output buffer: input buffer == output buffer
902 // - in other sessions:
903 // last effect in the chain accumulates in output buffer: input buffer != output buffer
904 // other effect: overwrites output buffer: input buffer == output buffer
905 // Auxiliary effect:
906 // accumulates in output buffer: input buffer != output buffer
907 // Therefore: accumulate <=> input buffer != output buffer
908 mConfig.outputCfg.accessMode = requiredEffectBufferAccessMode();
909 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
910 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
911 mConfig.inputCfg.buffer.frameCount = callback->frameCount();
912 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
913 mIsOutput = callback->isOutput();
914
915 ALOGV("%s %p chain %p buffer %p framecount %zu", __func__, this,
916 callback->chain().promote().get(), mConfig.inputCfg.buffer.raw,
917 mConfig.inputCfg.buffer.frameCount);
918
919 status_t cmdStatus;
920 size = sizeof(int);
921 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
922 sizeof(mConfig),
923 &mConfig,
924 &size,
925 &cmdStatus);
926 if (status == NO_ERROR) {
927 status = cmdStatus;
928 }
929
930 if (status != NO_ERROR &&
931 EffectConfiguration::isHidl() && // only HIDL effects support channel conversion
932 mIsOutput &&
933 (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
934 || mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO)) {
935 // Older effects may require exact STEREO position mask.
936 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
937 && (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
938 ALOGV("Overriding effect input channels %#x as STEREO", mConfig.inputCfg.channels);
939 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
940 }
941 if (mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
942 ALOGV("Overriding effect output channels %#x as STEREO", mConfig.outputCfg.channels);
943 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
944 }
945 size = sizeof(int);
946 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
947 sizeof(mConfig),
948 &mConfig,
949 &size,
950 &cmdStatus);
951 if (status == NO_ERROR) {
952 status = cmdStatus;
953 }
954 }
955
956 if (status == NO_ERROR) {
957 mSupportsFloat = true;
958 }
959
960 // only HIDL effects support integer conversion.
961 if (status != NO_ERROR && EffectConfiguration::isHidl()) {
962 ALOGV("EFFECT_CMD_SET_CONFIG failed with float format, retry with int16_t.");
963 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
964 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
965 size = sizeof(int);
966 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
967 sizeof(mConfig),
968 &mConfig,
969 &size,
970 &cmdStatus);
971 if (status == NO_ERROR) {
972 status = cmdStatus;
973 }
974 if (status == NO_ERROR) {
975 mSupportsFloat = false;
976 ALOGVV("config worked with 16 bit");
977 } else {
978 ALOGE("%s failed %d with int16_t (as well as float)", __func__, status);
979 }
980 }
981
982 if (status == NO_ERROR) {
983 // Establish Buffer strategy
984 setInBuffer(mInBuffer);
985 setOutBuffer(mOutBuffer);
986
987 // Update visualizer latency
988 if (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) {
989 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
990 effect_param_t *p = (effect_param_t *)buf32;
991
992 p->psize = sizeof(uint32_t);
993 p->vsize = sizeof(uint32_t);
994 size = sizeof(int);
995 *(int32_t *)p->data = VISUALIZER_PARAM_LATENCY;
996
997 uint32_t latency = callback->latency();
998
999 *((int32_t *)p->data + 1)= latency;
1000 mEffectInterface->command(EFFECT_CMD_SET_PARAM,
1001 sizeof(effect_param_t) + 8,
1002 &buf32,
1003 &size,
1004 &cmdStatus);
1005 }
1006 }
1007
1008 // mConfig.outputCfg.buffer.frameCount cannot be zero.
1009 mMaxDisableWaitCnt = (uint32_t)std::max(
1010 (uint64_t)1, // mMaxDisableWaitCnt must be greater than zero.
1011 (uint64_t)mConfig.outputCfg.buffer.frameCount == 0 ? 1
1012 : (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate
1013 / ((uint64_t)1000 * mConfig.outputCfg.buffer.frameCount)));
1014
1015 exit:
1016 // TODO: consider clearing mConfig on error.
1017 mStatus = status;
1018 ALOGVV("%s ended", __func__);
1019 return status;
1020 }
1021
init_l()1022 status_t EffectModule::init_l()
1023 {
1024 audio_utils::lock_guard _l(mutex());
1025 if (mEffectInterface == 0) {
1026 return NO_INIT;
1027 }
1028 status_t cmdStatus;
1029 uint32_t size = sizeof(status_t);
1030 status_t status = mEffectInterface->command(EFFECT_CMD_INIT,
1031 0,
1032 NULL,
1033 &size,
1034 &cmdStatus);
1035 if (status == 0) {
1036 status = cmdStatus;
1037 }
1038 return status;
1039 }
1040
addEffectToHal_l()1041 void EffectModule::addEffectToHal_l()
1042 {
1043 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
1044 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
1045 if (mCurrentHalStream == getCallback()->io()) {
1046 return;
1047 }
1048
1049 status_t status = getCallback()->addEffectToHal(mEffectInterface);
1050 if (status == NO_ERROR) {
1051 mCurrentHalStream = getCallback()->io();
1052 }
1053 }
1054 }
1055
addEffectToHal_l()1056 void HwAccDeviceEffectModule::addEffectToHal_l()
1057 {
1058 if (mAddedToHal) {
1059 return;
1060 }
1061 status_t status = getCallback()->addEffectToHal(mEffectInterface);
1062 if (status == NO_ERROR) {
1063 mAddedToHal = true;
1064 }
1065 }
1066
1067 // start_l() must be called with EffectChain::mutex() held
start_l()1068 status_t EffectModule::start_l()
1069 {
1070 status_t status;
1071 {
1072 audio_utils::lock_guard _l(mutex());
1073 status = start_ll();
1074 }
1075 if (status == NO_ERROR) {
1076 getCallback()->resetVolume_l();
1077 }
1078 return status;
1079 }
1080
start_ll()1081 status_t EffectModule::start_ll()
1082 {
1083 if (mEffectInterface == 0) {
1084 return NO_INIT;
1085 }
1086 if (mStatus != NO_ERROR) {
1087 return mStatus;
1088 }
1089 status_t cmdStatus;
1090 uint32_t size = sizeof(status_t);
1091 status_t status = mEffectInterface->command(EFFECT_CMD_ENABLE,
1092 0,
1093 NULL,
1094 &size,
1095 &cmdStatus);
1096 if (status == 0) {
1097 status = cmdStatus;
1098 }
1099 if (status == 0) {
1100 addEffectToHal_l();
1101 }
1102 return status;
1103 }
1104
stop_l()1105 status_t EffectModule::stop_l()
1106 {
1107 audio_utils::lock_guard _l(mutex());
1108 return stop_ll();
1109 }
1110
stop_ll()1111 status_t EffectModule::stop_ll()
1112 {
1113 if (mEffectInterface == 0) {
1114 return NO_INIT;
1115 }
1116 if (mStatus != NO_ERROR) {
1117 return mStatus;
1118 }
1119 status_t cmdStatus = NO_ERROR;
1120 uint32_t size = sizeof(status_t);
1121
1122 if (isVolumeControl() && isOffloadedOrDirect_l()) {
1123 // We have the EffectChain and EffectModule lock, permit a reentrant call to setVolume:
1124 // resetVolume_l --> setVolume_l --> EffectModule::setVolume
1125 mSetVolumeReentrantTid = gettid();
1126 getCallback()->resetVolume_l();
1127 mSetVolumeReentrantTid = INVALID_PID;
1128 }
1129
1130 status_t status = mEffectInterface->command(EFFECT_CMD_DISABLE,
1131 0,
1132 NULL,
1133 &size,
1134 &cmdStatus);
1135 if (status == NO_ERROR) {
1136 status = cmdStatus;
1137 }
1138 if (status == NO_ERROR) {
1139 status = removeEffectFromHal_l();
1140 }
1141 return status;
1142 }
1143
1144 // must be called with EffectChain::mutex() held
release_l(const std::string & from)1145 void EffectModule::release_l(const std::string& from)
1146 {
1147 if (mEffectInterface != 0) {
1148 removeEffectFromHal_l();
1149 // release effect engine
1150 mEffectInterface->close();
1151 mEffectInterface.clear();
1152 mEffectInterfaceDebug += " released by: " + from;
1153 }
1154 }
1155
removeEffectFromHal_l()1156 status_t EffectModule::removeEffectFromHal_l()
1157 {
1158 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
1159 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
1160 if (mCurrentHalStream != getCallback()->io()) {
1161 return (mCurrentHalStream == AUDIO_IO_HANDLE_NONE) ? NO_ERROR : INVALID_OPERATION;
1162 }
1163 getCallback()->removeEffectFromHal(mEffectInterface);
1164 mCurrentHalStream = AUDIO_IO_HANDLE_NONE;
1165 }
1166 return NO_ERROR;
1167 }
1168
removeEffectFromHal_l()1169 status_t HwAccDeviceEffectModule::removeEffectFromHal_l()
1170 {
1171 if (!mAddedToHal) {
1172 return NO_ERROR;
1173 }
1174 getCallback()->removeEffectFromHal(mEffectInterface);
1175 mAddedToHal = false;
1176 return NO_ERROR;
1177 }
1178
1179 // round up delta valid if value and divisor are positive.
1180 template <typename T>
roundUpDelta(const T & value,const T & divisor)1181 static T roundUpDelta(const T &value, const T &divisor) {
1182 T remainder = value % divisor;
1183 return remainder == 0 ? 0 : divisor - remainder;
1184 }
1185
command(int32_t cmdCode,const std::vector<uint8_t> & cmdData,int32_t maxReplySize,std::vector<uint8_t> * reply)1186 status_t EffectModule::command(int32_t cmdCode,
1187 const std::vector<uint8_t>& cmdData,
1188 int32_t maxReplySize,
1189 std::vector<uint8_t>* reply)
1190 {
1191 audio_utils::lock_guard _l(mutex());
1192 ALOGVV("%s, cmdCode: %d, mEffectInterface: %p", __func__, cmdCode, mEffectInterface.get());
1193
1194 if (mState == DESTROYED || mEffectInterface == 0) {
1195 return NO_INIT;
1196 }
1197 if (mStatus != NO_ERROR) {
1198 return mStatus;
1199 }
1200 if (maxReplySize < 0 || maxReplySize > EFFECT_PARAM_SIZE_MAX) {
1201 return -EINVAL;
1202 }
1203 size_t cmdSize = cmdData.size();
1204 const effect_param_t* param = cmdSize >= sizeof(effect_param_t)
1205 ? reinterpret_cast<const effect_param_t*>(cmdData.data())
1206 : nullptr;
1207 if (cmdCode == EFFECT_CMD_GET_PARAM &&
1208 (param == nullptr || param->psize > cmdSize - sizeof(effect_param_t))) {
1209 android_errorWriteLog(0x534e4554, "32438594");
1210 android_errorWriteLog(0x534e4554, "33003822");
1211 return -EINVAL;
1212 }
1213 if (cmdCode == EFFECT_CMD_GET_PARAM &&
1214 (maxReplySize < static_cast<signed>(sizeof(effect_param_t)) ||
1215 param->psize > maxReplySize - sizeof(effect_param_t))) {
1216 android_errorWriteLog(0x534e4554, "29251553");
1217 return -EINVAL;
1218 }
1219 if (cmdCode == EFFECT_CMD_GET_PARAM &&
1220 (static_cast<signed>(sizeof(effect_param_t)) > maxReplySize
1221 || param->psize > maxReplySize - sizeof(effect_param_t)
1222 || param->vsize > maxReplySize - sizeof(effect_param_t)
1223 - param->psize
1224 || roundUpDelta(param->psize, (uint32_t) sizeof(int)) >
1225 maxReplySize
1226 - sizeof(effect_param_t)
1227 - param->psize
1228 - param->vsize)) {
1229 ALOGV("\tLVM_ERROR : EFFECT_CMD_GET_PARAM: reply size inconsistent");
1230 android_errorWriteLog(0x534e4554, "32705438");
1231 return -EINVAL;
1232 }
1233 if ((cmdCode == EFFECT_CMD_SET_PARAM
1234 || cmdCode == EFFECT_CMD_SET_PARAM_DEFERRED)
1235 && // DEFERRED not generally used
1236 (param == nullptr
1237 || param->psize > cmdSize - sizeof(effect_param_t)
1238 || param->vsize > cmdSize - sizeof(effect_param_t)
1239 - param->psize
1240 || roundUpDelta(param->psize,
1241 (uint32_t) sizeof(int)) >
1242 cmdSize
1243 - sizeof(effect_param_t)
1244 - param->psize
1245 - param->vsize)) {
1246 android_errorWriteLog(0x534e4554, "30204301");
1247 return -EINVAL;
1248 }
1249 uint32_t replySize = maxReplySize;
1250 reply->resize(replySize);
1251 status_t status = mEffectInterface->command(cmdCode,
1252 cmdSize,
1253 const_cast<uint8_t*>(cmdData.data()),
1254 &replySize,
1255 reply->data());
1256 reply->resize(status == NO_ERROR ? replySize : 0);
1257 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
1258 for (size_t i = 1; i < mHandles.size(); i++) {
1259 IAfEffectHandle *h = mHandles[i];
1260 if (h != NULL && !h->disconnected()) {
1261 h->commandExecuted(cmdCode, cmdData, *reply);
1262 }
1263 }
1264 }
1265 return status;
1266 }
1267
isProcessEnabled() const1268 bool EffectModule::isProcessEnabled() const
1269 {
1270 if (mStatus != NO_ERROR) {
1271 return false;
1272 }
1273
1274 switch (mState) {
1275 case RESTART:
1276 case ACTIVE:
1277 case STOPPING:
1278 case STOPPED:
1279 return true;
1280 case IDLE:
1281 case STARTING:
1282 case DESTROYED:
1283 default:
1284 return false;
1285 }
1286 }
1287
isOffloadedOrDirect_l() const1288 bool EffectModule::isOffloadedOrDirect_l() const
1289 {
1290 return getCallback()->isOffloadOrDirect();
1291 }
1292
isVolumeControlEnabled_l() const1293 bool EffectModule::isVolumeControlEnabled_l() const
1294 {
1295 return (isVolumeControl() && (isOffloadedOrDirect_l() ? isEnabled() : isProcessEnabled()));
1296 }
1297
setInBuffer(const sp<EffectBufferHalInterface> & buffer)1298 void EffectModule::setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
1299 ALOGVV("setInBuffer %p",(&buffer));
1300
1301 // mConfig.inputCfg.buffer.frameCount may be zero if configure_l() is not called yet.
1302 if (buffer != 0) {
1303 mConfig.inputCfg.buffer.raw = buffer->audioBuffer()->raw;
1304 buffer->setFrameCount(mConfig.inputCfg.buffer.frameCount);
1305 } else {
1306 mConfig.inputCfg.buffer.raw = NULL;
1307 }
1308 mInBuffer = buffer;
1309 mEffectInterface->setInBuffer(buffer);
1310
1311 // aux effects do in place conversion to float - we don't allocate mInConversionBuffer.
1312 // Theoretically insert effects can also do in-place conversions (destroying
1313 // the original buffer) when the output buffer is identical to the input buffer,
1314 // but we don't optimize for it here.
1315 const bool auxType = (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
1316 const uint32_t inChannelCount =
1317 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
1318 const bool formatMismatch = !mSupportsFloat || mInChannelCountRequested != inChannelCount;
1319 if (!auxType && formatMismatch && mInBuffer != nullptr) {
1320 // we need to translate - create hidl shared buffer and intercept
1321 const size_t inFrameCount = mConfig.inputCfg.buffer.frameCount;
1322 // Use FCC_2 in case mInChannelCountRequested is mono and the effect is stereo.
1323 const uint32_t inChannels = std::max((uint32_t)FCC_2, mInChannelCountRequested);
1324 const size_t size = inChannels * inFrameCount * std::max(sizeof(int16_t), sizeof(float));
1325
1326 ALOGV("%s: setInBuffer updating for inChannels:%d inFrameCount:%zu total size:%zu",
1327 __func__, inChannels, inFrameCount, size);
1328
1329 if (size > 0 && (mInConversionBuffer == nullptr
1330 || size > mInConversionBuffer->getSize())) {
1331 mInConversionBuffer.clear();
1332 ALOGV("%s: allocating mInConversionBuffer %zu", __func__, size);
1333 (void)getCallback()->allocateHalBuffer(size, &mInConversionBuffer);
1334 }
1335 if (mInConversionBuffer != nullptr) {
1336 mInConversionBuffer->setFrameCount(inFrameCount);
1337 mEffectInterface->setInBuffer(mInConversionBuffer);
1338 } else if (size > 0) {
1339 ALOGE("%s cannot create mInConversionBuffer", __func__);
1340 }
1341 }
1342 }
1343
setOutBuffer(const sp<EffectBufferHalInterface> & buffer)1344 void EffectModule::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
1345 ALOGVV("setOutBuffer %p",(&buffer));
1346
1347 // mConfig.outputCfg.buffer.frameCount may be zero if configure_l() is not called yet.
1348 if (buffer != 0) {
1349 mConfig.outputCfg.buffer.raw = buffer->audioBuffer()->raw;
1350 buffer->setFrameCount(mConfig.outputCfg.buffer.frameCount);
1351 } else {
1352 mConfig.outputCfg.buffer.raw = NULL;
1353 }
1354 mOutBuffer = buffer;
1355 mEffectInterface->setOutBuffer(buffer);
1356
1357 // Note: Any effect that does not accumulate does not need mOutConversionBuffer and
1358 // can do in-place conversion from int16_t to float. We don't optimize here.
1359 const uint32_t outChannelCount =
1360 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
1361 const bool formatMismatch = !mSupportsFloat || mOutChannelCountRequested != outChannelCount;
1362 if (formatMismatch && mOutBuffer != nullptr) {
1363 const size_t outFrameCount = mConfig.outputCfg.buffer.frameCount;
1364 // Use FCC_2 in case mOutChannelCountRequested is mono and the effect is stereo.
1365 const uint32_t outChannels = std::max((uint32_t)FCC_2, mOutChannelCountRequested);
1366 const size_t size = outChannels * outFrameCount * std::max(sizeof(int16_t), sizeof(float));
1367
1368 ALOGV("%s: setOutBuffer updating for outChannels:%d outFrameCount:%zu total size:%zu",
1369 __func__, outChannels, outFrameCount, size);
1370
1371 if (size > 0 && (mOutConversionBuffer == nullptr
1372 || size > mOutConversionBuffer->getSize())) {
1373 mOutConversionBuffer.clear();
1374 ALOGV("%s: allocating mOutConversionBuffer %zu", __func__, size);
1375 (void)getCallback()->allocateHalBuffer(size, &mOutConversionBuffer);
1376 }
1377 if (mOutConversionBuffer != nullptr) {
1378 mOutConversionBuffer->setFrameCount(outFrameCount);
1379 mEffectInterface->setOutBuffer(mOutConversionBuffer);
1380 } else if (size > 0) {
1381 ALOGE("%s cannot create mOutConversionBuffer", __func__);
1382 }
1383 }
1384 }
1385
setVolume_l(uint32_t * left,uint32_t * right,bool controller,bool force)1386 status_t EffectModule::setVolume_l(uint32_t* left, uint32_t* right, bool controller, bool force) {
1387 AutoLockReentrant _l(mutex(), mSetVolumeReentrantTid);
1388 if (mStatus != NO_ERROR) {
1389 return mStatus;
1390 }
1391 status_t status = NO_ERROR;
1392 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
1393 // if controller flag is set (Note that controller == TRUE => the volume controller effect in
1394 // the effect chain)
1395 if (((isOffloadedOrDirect_l() ? isEnabled() : isProcessEnabled()) || force) &&
1396 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
1397 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND ||
1398 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_MONITOR)) {
1399 status = setVolumeInternal_ll(left, right, controller);
1400 }
1401 return status;
1402 }
1403
setVolumeInternal_ll(uint32_t * left,uint32_t * right,bool controller)1404 status_t EffectModule::setVolumeInternal_ll(
1405 uint32_t *left, uint32_t *right, bool controller) {
1406 if (mVolume.has_value() && *left == mVolume.value()[0] && *right == mVolume.value()[1] &&
1407 !controller) {
1408 LOG_ALWAYS_FATAL_IF(
1409 !mReturnedVolume.has_value(),
1410 "The cached returned volume must not be null when the cached volume has value");
1411 *left = mReturnedVolume.value()[0];
1412 *right = mReturnedVolume.value()[1];
1413 return NO_ERROR;
1414 }
1415 LOG_ALWAYS_FATAL_IF(mEffectInterface == nullptr, "%s", mEffectInterfaceDebug.c_str());
1416 uint32_t volume[2] = {*left, *right};
1417 uint32_t* pVolume = isVolumeControl() ? volume : nullptr;
1418 uint32_t size = sizeof(volume);
1419 status_t status = mEffectInterface->command(EFFECT_CMD_SET_VOLUME,
1420 size,
1421 volume,
1422 &size,
1423 pVolume);
1424 if (pVolume && status == NO_ERROR && size == sizeof(volume)) {
1425 mVolume = {*left, *right}; // Cache the value that has been set
1426 *left = volume[0];
1427 *right = volume[1];
1428 mReturnedVolume = {*left, *right};
1429 }
1430 return status;
1431 }
1432
setVolumeForOutput_l(uint32_t left,uint32_t right)1433 void EffectChain::setVolumeForOutput_l(uint32_t left, uint32_t right)
1434 {
1435 // for offload or direct thread, if the effect chain has non-offloadable
1436 // effect and any effect module within the chain has volume control, then
1437 // volume control is delegated to effect, otherwise, set volume to hal.
1438 if (mEffectCallback->isOffloadOrDirect() &&
1439 !(isNonOffloadableEnabled_l() && hasVolumeControlEnabled_l())) {
1440 float vol_l = (float)left / (1 << 24);
1441 float vol_r = (float)right / (1 << 24);
1442 mEffectCallback->setVolumeForOutput(vol_l, vol_r);
1443 }
1444 }
1445
sendSetAudioDevicesCommand(const AudioDeviceTypeAddrVector & devices,uint32_t cmdCode)1446 status_t EffectModule::sendSetAudioDevicesCommand(
1447 const AudioDeviceTypeAddrVector &devices, uint32_t cmdCode)
1448 {
1449 audio_devices_t deviceType = deviceTypesToBitMask(getAudioDeviceTypes(devices));
1450 if (deviceType == AUDIO_DEVICE_NONE) {
1451 return NO_ERROR;
1452 }
1453
1454 audio_utils::lock_guard _l(mutex());
1455 if (mStatus != NO_ERROR) {
1456 return mStatus;
1457 }
1458 status_t status = NO_ERROR;
1459 if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
1460 // for AIDL, use setDevices to pass the AudioDeviceTypeAddrVector
1461 if (!EffectConfiguration::isHidl()) {
1462 return mEffectInterface->setDevices(devices);
1463 }
1464
1465 status_t cmdStatus;
1466 uint32_t size = sizeof(status_t);
1467 // FIXME: use audio device types and addresses when the hal interface is ready.
1468 status = mEffectInterface->command(cmdCode,
1469 sizeof(uint32_t),
1470 &deviceType,
1471 &size,
1472 &cmdStatus);
1473 }
1474 return status;
1475 }
1476
setDevices(const AudioDeviceTypeAddrVector & devices)1477 status_t EffectModule::setDevices(const AudioDeviceTypeAddrVector &devices)
1478 {
1479 return sendSetAudioDevicesCommand(devices, EFFECT_CMD_SET_DEVICE);
1480 }
1481
setInputDevice(const AudioDeviceTypeAddr & device)1482 status_t EffectModule::setInputDevice(const AudioDeviceTypeAddr &device)
1483 {
1484 return sendSetAudioDevicesCommand({device}, EFFECT_CMD_SET_INPUT_DEVICE);
1485 }
1486
setMode(audio_mode_t mode)1487 status_t EffectModule::setMode(audio_mode_t mode)
1488 {
1489 audio_utils::lock_guard _l(mutex());
1490 if (mStatus != NO_ERROR) {
1491 return mStatus;
1492 }
1493 status_t status = NO_ERROR;
1494 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
1495 status_t cmdStatus;
1496 uint32_t size = sizeof(status_t);
1497 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_MODE,
1498 sizeof(audio_mode_t),
1499 &mode,
1500 &size,
1501 &cmdStatus);
1502 if (status == NO_ERROR) {
1503 status = cmdStatus;
1504 }
1505 }
1506 return status;
1507 }
1508
setAudioSource(audio_source_t source)1509 status_t EffectModule::setAudioSource(audio_source_t source)
1510 {
1511 audio_utils::lock_guard _l(mutex());
1512 if (mStatus != NO_ERROR) {
1513 return mStatus;
1514 }
1515 status_t status = NO_ERROR;
1516 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_SOURCE_MASK) == EFFECT_FLAG_AUDIO_SOURCE_IND) {
1517 uint32_t size = 0;
1518 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_SOURCE,
1519 sizeof(audio_source_t),
1520 &source,
1521 &size,
1522 NULL);
1523 }
1524 return status;
1525 }
1526
setOffloaded_l(bool offloaded,audio_io_handle_t io)1527 status_t EffectModule::setOffloaded_l(bool offloaded, audio_io_handle_t io)
1528 {
1529 audio_utils::lock_guard _l(mutex());
1530 if (mStatus != NO_ERROR) {
1531 return mStatus;
1532 }
1533 status_t status = NO_ERROR;
1534 if ((mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0) {
1535 status_t cmdStatus;
1536 uint32_t size = sizeof(status_t);
1537 effect_offload_param_t cmd;
1538
1539 cmd.isOffload = offloaded;
1540 cmd.ioHandle = io;
1541 status = mEffectInterface->command(EFFECT_CMD_OFFLOAD,
1542 sizeof(effect_offload_param_t),
1543 &cmd,
1544 &size,
1545 &cmdStatus);
1546 if (status == NO_ERROR) {
1547 status = cmdStatus;
1548 }
1549 mOffloaded = (status == NO_ERROR) ? offloaded : false;
1550 } else {
1551 if (offloaded) {
1552 status = INVALID_OPERATION;
1553 }
1554 mOffloaded = false;
1555 }
1556 ALOGV("%s offloaded %d io %d status %d", __func__, offloaded, io, status);
1557 return status;
1558 }
1559
isOffloaded_l() const1560 bool EffectModule::isOffloaded_l() const
1561 {
1562 audio_utils::lock_guard _l(mutex());
1563 return mOffloaded;
1564 }
1565
1566 /*static*/
isHapticGenerator(const effect_uuid_t * type)1567 bool IAfEffectModule::isHapticGenerator(const effect_uuid_t *type) {
1568 return memcmp(type, FX_IID_HAPTICGENERATOR, sizeof(effect_uuid_t)) == 0;
1569 }
1570
isHapticGenerator() const1571 bool EffectModule::isHapticGenerator() const {
1572 return IAfEffectModule::isHapticGenerator(&mDescriptor.type);
1573 }
1574
1575 /*static*/
isSpatializer(const effect_uuid_t * type)1576 bool IAfEffectModule::isSpatializer(const effect_uuid_t *type) {
1577 return memcmp(type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0;
1578 }
1579
isSpatializer() const1580 bool EffectModule::isSpatializer() const {
1581 return IAfEffectModule::isSpatializer(&mDescriptor.type);
1582 }
1583
isEffect(const effect_uuid_t & uuid) const1584 bool EffectModule::isEffect(const effect_uuid_t &uuid) const {
1585 using android::effect::utils::operator==;
1586 return mDescriptor.uuid == uuid;
1587 }
1588
setHapticScale_l(int id,os::HapticScale hapticScale)1589 status_t EffectModule::setHapticScale_l(int id, os::HapticScale hapticScale) {
1590 if (mStatus != NO_ERROR) {
1591 return mStatus;
1592 }
1593 if (!isHapticGenerator()) {
1594 ALOGW("Should not set haptic intensity for effects that are not HapticGenerator");
1595 return INVALID_OPERATION;
1596 }
1597
1598 // Scale param fields
1599 int32_t intensityParam = static_cast<int32_t>(HG_PARAM_HAPTIC_INTENSITY);
1600 int32_t scaleLevel = static_cast<int32_t>(hapticScale.getLevel());
1601 float scaleFactor = hapticScale.getScaleFactor();
1602 float adaptiveScaleFactor = hapticScale.getAdaptiveScaleFactor();
1603
1604 size_t psize = sizeof(int32_t); // HG_PARAM_HAPTIC_INTENSITY
1605 size_t vsize = 2 * sizeof(int32_t) + 2 * sizeof(float); // id + scale fields
1606 std::vector<uint8_t> request(sizeof(effect_param_t) + psize + vsize);
1607 effect_param_t *effectParam = (effect_param_t*) request.data();
1608 effectParam->psize = psize;
1609 effectParam->vsize = vsize;
1610
1611 EffectParamWriter writer(*effectParam);
1612 writer.writeToParameter(&intensityParam);
1613 writer.writeToValue(&id);
1614 writer.writeToValue(&scaleLevel);
1615 writer.writeToValue(&scaleFactor);
1616 writer.writeToValue(&adaptiveScaleFactor);
1617 writer.finishValueWrite();
1618
1619 std::vector<uint8_t> response;
1620 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
1621 if (status == NO_ERROR) {
1622 LOG_ALWAYS_FATAL_IF(response.size() != 4);
1623 status = *reinterpret_cast<const status_t*>(response.data());
1624 }
1625 return status;
1626 }
1627
setVibratorInfo_l(const media::AudioVibratorInfo & vibratorInfo)1628 status_t EffectModule::setVibratorInfo_l(const media::AudioVibratorInfo& vibratorInfo) {
1629 if (mStatus != NO_ERROR) {
1630 return mStatus;
1631 }
1632 if (!isHapticGenerator()) {
1633 ALOGW("Should not set vibrator info for effects that are not HapticGenerator");
1634 return INVALID_OPERATION;
1635 }
1636
1637 size_t psize = sizeof(int32_t); // HG_PARAM_VIBRATOR_INFO
1638 size_t vsize = 3 * sizeof(float); // resonantFrequency + qFactor + maxAmplitude
1639 std::vector<uint8_t> request(sizeof(effect_param_t) + psize + vsize);
1640 effect_param_t *effectParam = (effect_param_t*) request.data();
1641 effectParam->psize = psize;
1642 effectParam->vsize = vsize;
1643
1644 int32_t infoParam = static_cast<int32_t>(HG_PARAM_VIBRATOR_INFO);
1645 EffectParamWriter writer(*effectParam);
1646 writer.writeToParameter(&infoParam);
1647 writer.writeToValue(&vibratorInfo.resonantFrequency);
1648 writer.writeToValue(&vibratorInfo.qFactor);
1649 writer.writeToValue(&vibratorInfo.maxAmplitude);
1650 writer.finishValueWrite();
1651
1652 std::vector<uint8_t> response;
1653 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
1654 if (status == NO_ERROR) {
1655 LOG_ALWAYS_FATAL_IF(response.size() != sizeof(status_t));
1656 status = *reinterpret_cast<const status_t*>(response.data());
1657 }
1658 return status;
1659 }
1660
getConfigs_l(audio_config_base_t * inputCfg,audio_config_base_t * outputCfg,bool * isOutput) const1661 status_t EffectModule::getConfigs_l(audio_config_base_t* inputCfg, audio_config_base_t* outputCfg,
1662 bool* isOutput) const {
1663 audio_utils::lock_guard _l(mutex());
1664 if (mConfig.inputCfg.mask == 0 || mConfig.outputCfg.mask == 0) {
1665 return NO_INIT;
1666 }
1667 inputCfg->sample_rate = mConfig.inputCfg.samplingRate;
1668 inputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.inputCfg.channels);
1669 inputCfg->format = static_cast<audio_format_t>(mConfig.inputCfg.format);
1670 outputCfg->sample_rate = mConfig.outputCfg.samplingRate;
1671 outputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.outputCfg.channels);
1672 outputCfg->format = static_cast<audio_format_t>(mConfig.outputCfg.format);
1673 *isOutput = mIsOutput;
1674 return NO_ERROR;
1675 }
1676
sendMetadata_ll(const std::vector<playback_track_metadata_v7_t> & metadata)1677 status_t EffectModule::sendMetadata_ll(const std::vector<playback_track_metadata_v7_t>& metadata) {
1678 if (mStatus != NO_ERROR) {
1679 return mStatus;
1680 }
1681 // TODO b/307368176: send all metadata to effects if requested by the implementation.
1682 // For now only send channel mask to Spatializer.
1683 if (!isSpatializer()) {
1684 return INVALID_OPERATION;
1685 }
1686
1687 std::vector<uint8_t> request(
1688 sizeof(effect_param_t) + sizeof(int32_t) + metadata.size() * sizeof(uint32_t));
1689 effect_param_t *param = (effect_param_t*) request.data();
1690 param->psize = sizeof(int32_t);
1691 param->vsize = metadata.size() * sizeof(uint32_t);
1692 *(int32_t*)param->data = SPATIALIZER_PARAM_INPUT_CHANNEL_MASK;
1693 uint32_t* channelMasks = reinterpret_cast<uint32_t*>(param->data + sizeof(int32_t));
1694 for (auto m : metadata) {
1695 *channelMasks++ = m.channel_mask;
1696 }
1697 std::vector<uint8_t> response;
1698 status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
1699 if (status == NO_ERROR) {
1700 LOG_ALWAYS_FATAL_IF(response.size() != sizeof(status_t));
1701 status = *reinterpret_cast<const status_t*>(response.data());
1702 }
1703 return status;
1704 }
1705
dumpInOutBuffer(bool isInput,const sp<EffectBufferHalInterface> & buffer)1706 static std::string dumpInOutBuffer(bool isInput, const sp<EffectBufferHalInterface> &buffer) {
1707 std::stringstream ss;
1708
1709 if (buffer == nullptr) {
1710 return "nullptr"; // make different than below
1711 } else if (buffer->externalData() != nullptr) {
1712 ss << (isInput ? buffer->externalData() : buffer->audioBuffer()->raw)
1713 << " -> "
1714 << (isInput ? buffer->audioBuffer()->raw : buffer->externalData());
1715 } else {
1716 ss << buffer->audioBuffer()->raw;
1717 }
1718 return ss.str();
1719 }
1720
dump(int fd,const Vector<String16> & args) const1721 void EffectModule::dump(int fd, const Vector<String16>& args) const {
1722 EffectBase::dump(fd, args);
1723
1724 String8 result;
1725 afutils::FallibleLockGuard l{mutex()};
1726
1727 result.append("\t\tStatus Engine:\n");
1728 result.appendFormat("\t\t%03d %p\n",
1729 mStatus, mEffectInterface.get());
1730
1731 result.appendFormat("\t\t- data: %s\n", mSupportsFloat ? "float" : "int16");
1732
1733 result.append("\t\t- Input configuration:\n");
1734 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
1735 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
1736 mConfig.inputCfg.buffer.raw,
1737 mConfig.inputCfg.buffer.frameCount,
1738 mConfig.inputCfg.samplingRate,
1739 mConfig.inputCfg.channels,
1740 mConfig.inputCfg.format,
1741 toString(static_cast<audio_format_t>(mConfig.inputCfg.format)).c_str());
1742
1743 result.append("\t\t- Output configuration:\n");
1744 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
1745 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
1746 mConfig.outputCfg.buffer.raw,
1747 mConfig.outputCfg.buffer.frameCount,
1748 mConfig.outputCfg.samplingRate,
1749 mConfig.outputCfg.channels,
1750 mConfig.outputCfg.format,
1751 toString(static_cast<audio_format_t>(mConfig.outputCfg.format)).c_str());
1752
1753 result.appendFormat("\t\t- HAL buffers:\n"
1754 "\t\t\tIn(%s) InConversion(%s) Out(%s) OutConversion(%s)\n",
1755 dumpInOutBuffer(true /* isInput */, mInBuffer).c_str(),
1756 dumpInOutBuffer(true /* isInput */, mInConversionBuffer).c_str(),
1757 dumpInOutBuffer(false /* isInput */, mOutBuffer).c_str(),
1758 dumpInOutBuffer(false /* isInput */, mOutConversionBuffer).c_str());
1759
1760 write(fd, result.c_str(), result.length());
1761
1762 if (mEffectInterface != 0) {
1763 dprintf(fd, "\tEffect ID %d HAL dump:\n", mId);
1764 (void)mEffectInterface->dump(fd);
1765 }
1766
1767 }
1768
1769 // ----------------------------------------------------------------------------
1770 // EffectHandle implementation
1771 // ----------------------------------------------------------------------------
1772
1773 #undef LOG_TAG
1774 #define LOG_TAG "EffectHandle"
1775
1776 /* static */
create(const sp<IAfEffectBase> & effect,const sp<Client> & client,const sp<media::IEffectClient> & effectClient,int32_t priority,bool notifyFramesProcessed)1777 sp<IAfEffectHandle> IAfEffectHandle::create(
1778 const sp<IAfEffectBase>& effect,
1779 const sp<Client>& client,
1780 const sp<media::IEffectClient>& effectClient,
1781 int32_t priority, bool notifyFramesProcessed)
1782 {
1783 if (client == nullptr && effectClient == nullptr) {
1784 return sp<InternalEffectHandle>::make(effect, notifyFramesProcessed);
1785 }
1786 return sp<EffectHandle>::make(
1787 effect, client, effectClient, priority, notifyFramesProcessed);
1788 }
1789
EffectHandle(const sp<IAfEffectBase> & effect,const sp<Client> & client,const sp<media::IEffectClient> & effectClient,int32_t priority,bool notifyFramesProcessed,bool isInternal,audio_utils::MutexOrder mutexOrder)1790 EffectHandle::EffectHandle(const sp<IAfEffectBase>& effect,
1791 const sp<Client>& client,
1792 const sp<media::IEffectClient>& effectClient,
1793 int32_t priority, bool notifyFramesProcessed,
1794 bool isInternal,
1795 audio_utils::MutexOrder mutexOrder)
1796 : BnEffect(), mMutex(mutexOrder),
1797 mEffect(effect), mEffectClient(media::EffectClientAsyncProxy::makeIfNeeded(effectClient)),
1798 mClient(client), mCblk(nullptr),
1799 mPriority(priority), mHasControl(false), mEnabled(false), mDisconnected(false),
1800 mNotifyFramesProcessed(notifyFramesProcessed), mIsInternal(isInternal)
1801 {
1802 ALOGV("constructor %p client %p", this, client.get());
1803 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
1804 setInheritRt(true);
1805
1806 if (client == 0) {
1807 return;
1808 }
1809 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
1810 mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{
1811 {static_cast<size_t>(EFFECT_PARAM_BUFFER_SIZE + bufOffset)},
1812 std::string("Effect ID: ")
1813 .append(std::to_string(effect->id()))
1814 .append(" Session ID: ")
1815 .append(std::to_string(static_cast<int>(effect->sessionId())))
1816 .append(" \n")
1817 });
1818 if (mCblkMemory == 0 ||
1819 (mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
1820 ALOGE("not enough memory for Effect size=%zu", EFFECT_PARAM_BUFFER_SIZE +
1821 sizeof(effect_param_cblk_t));
1822 mCblkMemory.clear();
1823 return;
1824 }
1825 new(mCblk) effect_param_cblk_t();
1826 mBuffer = (uint8_t *)mCblk + bufOffset;
1827 }
1828
~EffectHandle()1829 EffectHandle::~EffectHandle()
1830 {
1831 ALOGV("Destructor %p", this);
1832 disconnect(false);
1833 }
1834
1835 // Creates an association between Binder code to name for IEffect.
1836 #define IEFFECT_BINDER_METHOD_MACRO_LIST \
1837 BINDER_METHOD_ENTRY(enable) \
1838 BINDER_METHOD_ENTRY(disable) \
1839 BINDER_METHOD_ENTRY(command) \
1840 BINDER_METHOD_ENTRY(disconnect) \
1841 BINDER_METHOD_ENTRY(getCblk) \
1842 BINDER_METHOD_ENTRY(getConfig) \
1843
1844 // singleton for Binder Method Statistics for IEffect
getIEffectStatistics()1845 mediautils::MethodStatistics<int>& getIEffectStatistics() {
1846 using Code = int;
1847
1848 #pragma push_macro("BINDER_METHOD_ENTRY")
1849 #undef BINDER_METHOD_ENTRY
1850 #define BINDER_METHOD_ENTRY(ENTRY) \
1851 {(Code)media::BnEffect::TRANSACTION_##ENTRY, #ENTRY},
1852
1853 static mediautils::MethodStatistics<Code> methodStatistics{
1854 IEFFECT_BINDER_METHOD_MACRO_LIST
1855 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
1856 };
1857 #pragma pop_macro("BINDER_METHOD_ENTRY")
1858
1859 return methodStatistics;
1860 }
1861
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)1862 status_t EffectHandle::onTransact(
1863 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
1864 const std::string methodName = getIEffectStatistics().getMethodForCode(code);
1865 mediautils::TimeCheck check(
1866 std::string("IEffect::").append(methodName),
1867 [code](bool timeout, float elapsedMs) {
1868 if (timeout) {
1869 ; // we don't timeout right now on the effect interface.
1870 } else {
1871 getIEffectStatistics().event(code, elapsedMs);
1872 }
1873 }, {} /* timeoutDuration */, {} /* secondChanceDuration */, false /* crashOnTimeout */);
1874 return BnEffect::onTransact(code, data, reply, flags);
1875 }
1876
initCheck() const1877 status_t EffectHandle::initCheck() const
1878 {
1879 return mClient == 0 || mCblkMemory != 0 ? OK : NO_MEMORY;
1880 }
1881
1882 #define RETURN(code) \
1883 *_aidl_return = (code); \
1884 return Status::ok();
1885
1886 #define VALUE_OR_RETURN_STATUS_AS_OUT(exp) \
1887 ({ \
1888 auto _tmp = (exp); \
1889 if (!_tmp.ok()) { RETURN(_tmp.error()); } \
1890 std::move(_tmp.value()); \
1891 })
1892
enable(int32_t * _aidl_return)1893 Status EffectHandle::enable(int32_t* _aidl_return)
1894 {
1895 audio_utils::lock_guard _l(mutex());
1896 ALOGV("enable %p", this);
1897 sp<IAfEffectBase> effect = mEffect.promote();
1898 if (effect == 0 || mDisconnected) {
1899 RETURN(DEAD_OBJECT);
1900 }
1901 if (!mHasControl) {
1902 RETURN(INVALID_OPERATION);
1903 }
1904
1905 if (mEnabled) {
1906 RETURN(NO_ERROR);
1907 }
1908
1909 mEnabled = true;
1910
1911 status_t status = effect->updatePolicyState();
1912 if (status != NO_ERROR) {
1913 mEnabled = false;
1914 RETURN(status);
1915 }
1916
1917 effect->checkSuspendOnEffectEnabled(true, false /*threadLocked*/);
1918
1919 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled
1920 if (effect->suspended()) {
1921 RETURN(NO_ERROR);
1922 }
1923
1924 status = effect->setEnabled(true, true /*fromHandle*/);
1925 if (status != NO_ERROR) {
1926 mEnabled = false;
1927 }
1928 RETURN(status);
1929 }
1930
disable(int32_t * _aidl_return)1931 Status EffectHandle::disable(int32_t* _aidl_return)
1932 {
1933 ALOGV("disable %p", this);
1934 audio_utils::lock_guard _l(mutex());
1935 sp<IAfEffectBase> effect = mEffect.promote();
1936 if (effect == 0 || mDisconnected) {
1937 RETURN(DEAD_OBJECT);
1938 }
1939 if (!mHasControl) {
1940 RETURN(INVALID_OPERATION);
1941 }
1942
1943 if (!mEnabled) {
1944 RETURN(NO_ERROR);
1945 }
1946 mEnabled = false;
1947
1948 effect->updatePolicyState();
1949
1950 if (effect->suspended()) {
1951 RETURN(NO_ERROR);
1952 }
1953
1954 status_t status = effect->setEnabled(false, true /*fromHandle*/);
1955 RETURN(status);
1956 }
1957
disconnect()1958 Status EffectHandle::disconnect()
1959 {
1960 ALOGV("%s %p", __FUNCTION__, this);
1961 disconnect(true);
1962 return Status::ok();
1963 }
1964
disconnect(bool unpinIfLast)1965 void EffectHandle::disconnect(bool unpinIfLast)
1966 {
1967 audio_utils::unique_lock _l(mutex());
1968 ALOGV("disconnect(%s) %p", unpinIfLast ? "true" : "false", this);
1969 if (mDisconnected) {
1970 if (unpinIfLast) {
1971 android_errorWriteLog(0x534e4554, "32707507");
1972 }
1973 return;
1974 }
1975 mDisconnected = true;
1976 {
1977 sp<IAfEffectBase> effect = mEffect.promote();
1978 if (effect != 0) {
1979 // Unlock e.g. for device effect: may need to acquire AudioFlinger lock
1980 // Also Internal Effect Handle would require Proxy lock (and vice versa).
1981 if (isInternal()) {
1982 _l.unlock();
1983 }
1984 if (effect->disconnectHandle(this, unpinIfLast) > 0) {
1985 ALOGW("%s Effect handle %p disconnected after thread destruction",
1986 __func__, this);
1987 }
1988 effect->updatePolicyState();
1989 if (isInternal()) {
1990 _l.lock();
1991 }
1992 }
1993 }
1994
1995 if (mClient != 0) {
1996 if (mCblk != NULL) {
1997 // unlike ~TrackBase(), mCblk is never a local new, so don't delete
1998 mCblk->~effect_param_cblk_t(); // destroy our shared-structure.
1999 }
2000 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
2001 // Client destructor must run with AudioFlinger client mutex locked
2002 audio_utils::lock_guard _l2(mClient->afClientCallback()->clientMutex());
2003 mClient.clear();
2004 }
2005 }
2006
getCblk(media::SharedFileRegion * _aidl_return)2007 Status EffectHandle::getCblk(media::SharedFileRegion* _aidl_return) {
2008 LOG_ALWAYS_FATAL_IF(!convertIMemoryToSharedFileRegion(mCblkMemory, _aidl_return));
2009 return Status::ok();
2010 }
2011
getConfig(media::EffectConfig * _config,int32_t * _aidl_return)2012 Status EffectHandle::getConfig(
2013 media::EffectConfig* _config, int32_t* _aidl_return) {
2014 audio_utils::lock_guard _l(mutex());
2015 sp<IAfEffectBase> effect = mEffect.promote();
2016 if (effect == nullptr || mDisconnected) {
2017 RETURN(DEAD_OBJECT);
2018 }
2019 sp<IAfEffectModule> effectModule = effect->asEffectModule();
2020 if (effectModule == nullptr) {
2021 RETURN(INVALID_OPERATION);
2022 }
2023 audio_config_base_t inputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
2024 audio_config_base_t outputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
2025 bool isOutput;
2026 status_t status = effectModule->getConfigs_l(&inputCfg, &outputCfg, &isOutput);
2027 if (status == NO_ERROR) {
2028 constexpr bool isInput = false; // effects always use 'OUT' channel masks.
2029 _config->inputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
2030 legacy2aidl_audio_config_base_t_AudioConfigBase(inputCfg, isInput));
2031 _config->outputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
2032 legacy2aidl_audio_config_base_t_AudioConfigBase(outputCfg, isInput));
2033 _config->isOnInputStream = !isOutput;
2034 }
2035 RETURN(status);
2036 }
2037
command(int32_t cmdCode,const std::vector<uint8_t> & cmdData,int32_t maxResponseSize,std::vector<uint8_t> * response,int32_t * _aidl_return)2038 Status EffectHandle::command(int32_t cmdCode,
2039 const std::vector<uint8_t>& cmdData,
2040 int32_t maxResponseSize,
2041 std::vector<uint8_t>* response,
2042 int32_t* _aidl_return)
2043 {
2044 ALOGVV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
2045 cmdCode, mHasControl, mEffect.unsafe_get());
2046
2047 // reject commands reserved for internal use by audio framework if coming from outside
2048 // of audioserver
2049 switch(cmdCode) {
2050 case EFFECT_CMD_ENABLE:
2051 case EFFECT_CMD_DISABLE:
2052 case EFFECT_CMD_SET_PARAM:
2053 case EFFECT_CMD_SET_PARAM_DEFERRED:
2054 case EFFECT_CMD_SET_PARAM_COMMIT:
2055 case EFFECT_CMD_GET_PARAM:
2056 break;
2057 default:
2058 if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY) {
2059 break;
2060 }
2061 android_errorWriteLog(0x534e4554, "62019992");
2062 RETURN(BAD_VALUE);
2063 }
2064
2065 if (cmdCode == EFFECT_CMD_ENABLE) {
2066 if (maxResponseSize < static_cast<signed>(sizeof(int))) {
2067 android_errorWriteLog(0x534e4554, "32095713");
2068 RETURN(BAD_VALUE);
2069 }
2070 writeToBuffer(NO_ERROR, response);
2071 return enable(_aidl_return);
2072 } else if (cmdCode == EFFECT_CMD_DISABLE) {
2073 if (maxResponseSize < static_cast<signed>(sizeof(int))) {
2074 android_errorWriteLog(0x534e4554, "32095713");
2075 RETURN(BAD_VALUE);
2076 }
2077 writeToBuffer(NO_ERROR, response);
2078 return disable(_aidl_return);
2079 }
2080
2081 audio_utils::lock_guard _l(mutex());
2082 sp<IAfEffectBase> effect = mEffect.promote();
2083 if (effect == 0 || mDisconnected) {
2084 RETURN(DEAD_OBJECT);
2085 }
2086 // only get parameter command is permitted for applications not controlling the effect
2087 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
2088 RETURN(INVALID_OPERATION);
2089 }
2090
2091 // handle commands that are not forwarded transparently to effect engine
2092 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
2093 if (mClient == 0) {
2094 RETURN(INVALID_OPERATION);
2095 }
2096
2097 if (maxResponseSize < (signed)sizeof(int)) {
2098 android_errorWriteLog(0x534e4554, "32095713");
2099 RETURN(BAD_VALUE);
2100 }
2101 writeToBuffer(NO_ERROR, response);
2102
2103 // No need to trylock() here as this function is executed in the binder thread serving a
2104 // particular client process: no risk to block the whole media server process or mixer
2105 // threads if we are stuck here
2106 Mutex::Autolock _l2(mCblk->lock);
2107 // keep local copy of index in case of client corruption b/32220769
2108 const uint32_t clientIndex = mCblk->clientIndex;
2109 const uint32_t serverIndex = mCblk->serverIndex;
2110 if (clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
2111 serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
2112 mCblk->serverIndex = 0;
2113 mCblk->clientIndex = 0;
2114 RETURN(BAD_VALUE);
2115 }
2116 status_t status = NO_ERROR;
2117 std::vector<uint8_t> param;
2118 for (uint32_t index = serverIndex; index < clientIndex;) {
2119 int *p = (int *)(mBuffer + index);
2120 const int size = *p++;
2121 if (size < 0
2122 || size > EFFECT_PARAM_BUFFER_SIZE
2123 || ((uint8_t *)p + size) > mBuffer + clientIndex) {
2124 ALOGW("command(): invalid parameter block size");
2125 status = BAD_VALUE;
2126 break;
2127 }
2128
2129 std::copy(reinterpret_cast<const uint8_t*>(p),
2130 reinterpret_cast<const uint8_t*>(p) + size,
2131 std::back_inserter(param));
2132
2133 std::vector<uint8_t> replyBuffer;
2134 status_t ret = effect->command(EFFECT_CMD_SET_PARAM,
2135 param,
2136 sizeof(int),
2137 &replyBuffer);
2138 int reply = *reinterpret_cast<const int*>(replyBuffer.data());
2139
2140 // verify shared memory: server index shouldn't change; client index can't go back.
2141 if (serverIndex != mCblk->serverIndex
2142 || clientIndex > mCblk->clientIndex) {
2143 android_errorWriteLog(0x534e4554, "32220769");
2144 status = BAD_VALUE;
2145 break;
2146 }
2147
2148 // stop at first error encountered
2149 if (ret != NO_ERROR) {
2150 status = ret;
2151 writeToBuffer(reply, response);
2152 break;
2153 } else if (reply != NO_ERROR) {
2154 writeToBuffer(reply, response);
2155 break;
2156 }
2157 index += size;
2158 }
2159 mCblk->serverIndex = 0;
2160 mCblk->clientIndex = 0;
2161 RETURN(status);
2162 }
2163
2164 status_t status = effect->command(cmdCode,
2165 cmdData,
2166 maxResponseSize,
2167 response);
2168 RETURN(status);
2169 }
2170
setControl(bool hasControl,bool signal,bool enabled)2171 void EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
2172 {
2173 ALOGV("setControl %p control %d", this, hasControl);
2174
2175 mHasControl = hasControl;
2176 mEnabled = enabled;
2177
2178 if (signal && mEffectClient != 0) {
2179 mEffectClient->controlStatusChanged(hasControl);
2180 }
2181 }
2182
commandExecuted(uint32_t cmdCode,const std::vector<uint8_t> & cmdData,const std::vector<uint8_t> & replyData)2183 void EffectHandle::commandExecuted(uint32_t cmdCode,
2184 const std::vector<uint8_t>& cmdData,
2185 const std::vector<uint8_t>& replyData)
2186 {
2187 if (mEffectClient != 0) {
2188 mEffectClient->commandExecuted(cmdCode, cmdData, replyData);
2189 }
2190 }
2191
2192
2193
setEnabled(bool enabled)2194 void EffectHandle::setEnabled(bool enabled)
2195 {
2196 if (mEffectClient != 0) {
2197 mEffectClient->enableStatusChanged(enabled);
2198 }
2199 }
2200
framesProcessed(int32_t frames) const2201 void EffectHandle::framesProcessed(int32_t frames) const
2202 {
2203 if (mEffectClient != 0 && mNotifyFramesProcessed) {
2204 mEffectClient->framesProcessed(frames);
2205 }
2206 }
2207
dumpToBuffer(char * buffer,size_t size) const2208 void EffectHandle::dumpToBuffer(char* buffer, size_t size) const
2209 {
2210 std::optional<afutils::FallibleLockGuard> guard;
2211 if (mCblk != nullptr) {
2212 guard.emplace(mCblk->lock);
2213 }
2214
2215 snprintf(buffer, size, "\t\t\t%5d %5d %3s %3s %5u %5u\n",
2216 (mClient == 0) ? getpid() : mClient->pid(),
2217 mPriority,
2218 mHasControl ? "yes" : "no",
2219 guard.has_value() && *guard ? "yes" : "no",
2220 mCblk ? mCblk->clientIndex : 0,
2221 mCblk ? mCblk->serverIndex : 0
2222 );
2223 }
2224
2225 #undef LOG_TAG
2226 #define LOG_TAG "EffectChain"
2227
2228 /* static */
create(const sp<IAfThreadBase> & thread,audio_session_t sessionId,const sp<IAfThreadCallback> & afThreadCallback)2229 sp<IAfEffectChain> IAfEffectChain::create(
2230 const sp<IAfThreadBase>& thread,
2231 audio_session_t sessionId,
2232 const sp<IAfThreadCallback>& afThreadCallback)
2233 {
2234 return sp<EffectChain>::make(thread, sessionId, afThreadCallback);
2235 }
2236
EffectChain(const sp<IAfThreadBase> & thread,audio_session_t sessionId,const sp<IAfThreadCallback> & afThreadCallback)2237 EffectChain::EffectChain(const sp<IAfThreadBase>& thread, audio_session_t sessionId,
2238 const sp<IAfThreadCallback>& afThreadCallback)
2239 : mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
2240 mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
2241 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),
2242 mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread, afThreadCallback))
2243 {
2244 if (thread != nullptr) {
2245 mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
2246 mMaxTailBuffers =
2247 ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
2248 thread->frameCount();
2249 }
2250 }
2251
getEffectFromDesc(effect_descriptor_t * descriptor) const2252 sp<IAfEffectModule> EffectChain::getEffectFromDesc(
2253 effect_descriptor_t *descriptor) const
2254 {
2255 audio_utils::lock_guard _l(mutex());
2256 size_t size = mEffects.size();
2257
2258 for (size_t i = 0; i < size; i++) {
2259 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
2260 return mEffects[i];
2261 }
2262 }
2263 return 0;
2264 }
2265
2266 // getEffectFromId_l() must be called with IAfThreadBase::mutex() held
getEffectFromId_l(int id) const2267 sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const
2268 {
2269 audio_utils::lock_guard _l(mutex());
2270 size_t size = mEffects.size();
2271
2272 for (size_t i = 0; i < size; i++) {
2273 // by convention, return first effect if id provided is 0 (0 is never a valid id)
2274 if (id == 0 || mEffects[i]->id() == id) {
2275 return mEffects[i];
2276 }
2277 }
2278 return 0;
2279 }
2280
2281 // getEffectFromType_l() must be called with IAfThreadBase::mutex() held
getEffectFromType_l(const effect_uuid_t * type) const2282 sp<IAfEffectModule> EffectChain::getEffectFromType_l(
2283 const effect_uuid_t *type) const
2284 {
2285 audio_utils::lock_guard _l(mutex());
2286 size_t size = mEffects.size();
2287
2288 for (size_t i = 0; i < size; i++) {
2289 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
2290 return mEffects[i];
2291 }
2292 }
2293 return 0;
2294 }
2295
getEffectIds_l() const2296 std::vector<int> EffectChain::getEffectIds_l() const
2297 {
2298 std::vector<int> ids;
2299 audio_utils::lock_guard _l(mutex());
2300 for (size_t i = 0; i < mEffects.size(); i++) {
2301 ids.push_back(mEffects[i]->id());
2302 }
2303 return ids;
2304 }
2305
clearInputBuffer()2306 void EffectChain::clearInputBuffer()
2307 {
2308 audio_utils::lock_guard _l(mutex());
2309 clearInputBuffer_l();
2310 }
2311
2312 // Must be called with EffectChain::mutex() locked
clearInputBuffer_l()2313 void EffectChain::clearInputBuffer_l()
2314 {
2315 if (mInBuffer == NULL) {
2316 return;
2317 }
2318 const size_t frameSize = audio_bytes_per_sample(AUDIO_FORMAT_PCM_FLOAT)
2319 * mEffectCallback->inChannelCount(mEffects[0]->id());
2320
2321 memset(mInBuffer->audioBuffer()->raw, 0, mEffectCallback->frameCount() * frameSize);
2322 mInBuffer->commit();
2323 }
2324
2325 // Must be called with EffectChain::mutex() locked
process_l()2326 void EffectChain::process_l() {
2327 // never process effects when:
2328 // - on an OFFLOAD thread
2329 // - no more tracks are on the session and the effect tail has been rendered
2330 bool doProcess = !mEffectCallback->isOffloadOrMmap();
2331 if (!audio_is_global_session(mSessionId)) {
2332 bool tracksOnSession = (trackCnt() != 0);
2333
2334 if (!tracksOnSession && mTailBufferCount == 0) {
2335 doProcess = false;
2336 }
2337
2338 if (activeTrackCnt() == 0) {
2339 // if no track is active and the effect tail has not been rendered,
2340 // the input buffer must be cleared here as the mixer process will not do it
2341 if (tracksOnSession || mTailBufferCount > 0) {
2342 clearInputBuffer_l();
2343 if (mTailBufferCount > 0) {
2344 mTailBufferCount--;
2345 }
2346 }
2347 }
2348 }
2349
2350 size_t size = mEffects.size();
2351 if (doProcess) {
2352 // Only the input and output buffers of the chain can be external,
2353 // and 'update' / 'commit' do nothing for allocated buffers, thus
2354 // it's not needed to consider any other buffers here.
2355 mInBuffer->update();
2356 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
2357 mOutBuffer->update();
2358 }
2359 for (size_t i = 0; i < size; i++) {
2360 mEffects[i]->process();
2361 }
2362 mInBuffer->commit();
2363 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
2364 mOutBuffer->commit();
2365 }
2366 }
2367 bool doResetVolume = false;
2368 for (size_t i = 0; i < size; i++) {
2369 // reset volume when any effect just started or stopped.
2370 // resetVolume_l will check if the volume controller effect in the chain needs update and
2371 // apply the correct volume
2372 doResetVolume = mEffects[i]->updateState_l() || doResetVolume;
2373 }
2374 if (doResetVolume) {
2375 resetVolume_l();
2376 }
2377 }
2378
createEffect(sp<IAfEffectModule> & effect,effect_descriptor_t * desc,int id,audio_session_t sessionId,bool pinned)2379 status_t EffectChain::createEffect(sp<IAfEffectModule>& effect,
2380 effect_descriptor_t *desc,
2381 int id,
2382 audio_session_t sessionId,
2383 bool pinned)
2384 {
2385 audio_utils::lock_guard _l(mutex());
2386 effect = new EffectModule(mEffectCallback, desc, id, sessionId, pinned, AUDIO_PORT_HANDLE_NONE);
2387 status_t lStatus = effect->status();
2388 if (lStatus == NO_ERROR) {
2389 lStatus = addEffect_l(effect);
2390 }
2391 if (lStatus != NO_ERROR) {
2392 effect.clear();
2393 }
2394 return lStatus;
2395 }
2396
addEffect(const sp<IAfEffectModule> & effect)2397 status_t EffectChain::addEffect(const sp<IAfEffectModule>& effect)
2398 {
2399 audio_utils::lock_guard _l(mutex());
2400 return addEffect_l(effect);
2401 }
2402 // addEffect_l() must be called with EffectChain::mutex() held
addEffect_l(const sp<IAfEffectModule> & effect)2403 status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)
2404 {
2405 effect->setCallback(mEffectCallback);
2406
2407 effect_descriptor_t desc = effect->desc();
2408 ssize_t idx_insert = 0;
2409 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2410 // Auxiliary effects are inserted at the beginning of mEffects vector as
2411 // they are processed first and accumulated in chain input buffer
2412 mEffects.insertAt(effect, idx_insert);
2413
2414 // the input buffer for auxiliary effect contains mono samples in
2415 // 32 bit format. This is to avoid saturation in AudoMixer
2416 // accumulation stage. Saturation is done in EffectModule::process() before
2417 // calling the process in effect engine
2418 size_t numSamples = mEffectCallback->frameCount();
2419 sp<EffectBufferHalInterface> halBuffer;
2420
2421 status_t result = mEffectCallback->allocateHalBuffer(
2422 numSamples * sizeof(float), &halBuffer);
2423 if (result != OK) return result;
2424
2425 effect->configure_l();
2426
2427 effect->setInBuffer(halBuffer);
2428 // auxiliary effects output samples to chain input buffer for further processing
2429 // by insert effects
2430 effect->setOutBuffer(mInBuffer);
2431 } else {
2432 idx_insert = getInsertIndex_l(desc);
2433 if (idx_insert < 0) {
2434 return INVALID_OPERATION;
2435 }
2436
2437 size_t previousSize = mEffects.size();
2438 mEffects.insertAt(effect, idx_insert);
2439
2440 effect->configure_l();
2441
2442 // - By default:
2443 // All effects read samples from chain input buffer.
2444 // The last effect in the chain, writes samples to chain output buffer,
2445 // otherwise to chain input buffer
2446 // - In the OUTPUT_STAGE chain of a spatializer mixer thread:
2447 // The spatializer effect (first effect) reads samples from the input buffer
2448 // and writes samples to the output buffer.
2449 // All other effects read and writes samples to the output buffer
2450 if (mEffectCallback->isSpatializer()
2451 && mSessionId == AUDIO_SESSION_OUTPUT_STAGE) {
2452 effect->setOutBuffer(mOutBuffer);
2453 if (idx_insert == 0) {
2454 if (previousSize != 0) {
2455 mEffects[1]->configure_l();
2456 mEffects[1]->setInBuffer(mOutBuffer);
2457 mEffects[1]->updateAccessMode_l(); // reconfig if needed.
2458 }
2459 effect->setInBuffer(mInBuffer);
2460 } else {
2461 effect->setInBuffer(mOutBuffer);
2462 }
2463 } else {
2464 effect->setInBuffer(mInBuffer);
2465 if (idx_insert == static_cast<ssize_t>(previousSize)) {
2466 if (idx_insert != 0) {
2467 mEffects[idx_insert-1]->configure_l();
2468 mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
2469 mEffects[idx_insert - 1]->updateAccessMode_l(); // reconfig if needed.
2470 }
2471 effect->setOutBuffer(mOutBuffer);
2472 } else {
2473 effect->setOutBuffer(mInBuffer);
2474 }
2475 }
2476 ALOGV("%s effect %p, added in chain %p at rank %zu",
2477 __func__, effect.get(), this, idx_insert);
2478 }
2479 effect->configure_l();
2480
2481 if (effect->isVolumeControl()) {
2482 const auto volumeControlIndex = findVolumeControl_l(0, mEffects.size());
2483 if (!volumeControlIndex.has_value() || (ssize_t)volumeControlIndex.value() < idx_insert) {
2484 // If this effect will be the new volume control effect when it is enabled, force
2485 // initializing the volume as 0 for volume control effect for safer ramping. The actual
2486 // volume will be set from setVolume_l.
2487 uint32_t left = 0;
2488 uint32_t right = 0;
2489 effect->setVolume_l(&left, &right, true /*controller*/, true /*force*/);
2490 }
2491 }
2492
2493 return NO_ERROR;
2494 }
2495
findVolumeControl_l(size_t from,size_t to) const2496 std::optional<size_t> EffectChain::findVolumeControl_l(size_t from, size_t to) const {
2497 for (size_t i = std::min(to, mEffects.size()); i > from; i--) {
2498 if (mEffects[i - 1]->isVolumeControlEnabled_l()) {
2499 return i - 1;
2500 }
2501 }
2502 return std::nullopt;
2503 }
2504
getInsertIndex_l(const effect_descriptor_t & desc)2505 ssize_t EffectChain::getInsertIndex_l(const effect_descriptor_t& desc) {
2506 // Insert effects are inserted at the end of mEffects vector as they are processed
2507 // after track and auxiliary effects.
2508 // Insert effect order as a function of indicated preference:
2509 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
2510 // another effect is present
2511 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
2512 // last effect claiming first position
2513 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
2514 // first effect claiming last position
2515 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last
2516 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
2517 // already present
2518 // Spatializer or Downmixer effects are inserted in first position because
2519 // they adapt the channel count for all other effects in the chain
2520 if (IAfEffectModule::isSpatializer(&desc.type)
2521 || (memcmp(&desc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0)) {
2522 return 0;
2523 }
2524
2525 size_t size = mEffects.size();
2526 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
2527 ssize_t idx_insert;
2528 ssize_t idx_insert_first = -1;
2529 ssize_t idx_insert_last = -1;
2530
2531 idx_insert = size;
2532 for (size_t i = 0; i < size; i++) {
2533 effect_descriptor_t d = mEffects[i]->desc();
2534 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
2535 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
2536 if (iMode == EFFECT_FLAG_TYPE_INSERT) {
2537 // check invalid effect chaining combinations
2538 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
2539 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
2540 ALOGW("%s could not insert effect %s: exclusive conflict with %s",
2541 __func__, desc.name, d.name);
2542 return -1;
2543 }
2544 // remember position of first insert effect and by default
2545 // select this as insert position for new effect
2546 if (idx_insert == static_cast<ssize_t>(size)) {
2547 idx_insert = i;
2548 }
2549 // remember position of last insert effect claiming
2550 // first position
2551 if (iPref == EFFECT_FLAG_INSERT_FIRST) {
2552 idx_insert_first = i;
2553 }
2554 // remember position of first insert effect claiming
2555 // last position
2556 if (iPref == EFFECT_FLAG_INSERT_LAST &&
2557 idx_insert_last == -1) {
2558 idx_insert_last = i;
2559 }
2560 }
2561 }
2562
2563 // modify idx_insert from first position if needed
2564 if (insertPref == EFFECT_FLAG_INSERT_LAST) {
2565 if (idx_insert_last != -1) {
2566 idx_insert = idx_insert_last;
2567 } else {
2568 idx_insert = size;
2569 }
2570 } else {
2571 if (idx_insert_first != -1) {
2572 idx_insert = idx_insert_first + 1;
2573 }
2574 }
2575 return idx_insert;
2576 }
2577
removeEffect(const sp<IAfEffectModule> & effect,bool release)2578 size_t EffectChain::removeEffect(const sp<IAfEffectModule>& effect,
2579 bool release)
2580 {
2581 audio_utils::lock_guard _l(mutex());
2582 size_t size = mEffects.size();
2583 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
2584
2585 const bool hasThreadAttached = mEffectCallback->hasThreadAttached();
2586 for (size_t i = 0; i < size; i++) {
2587 if (effect == mEffects[i]) {
2588 // calling stop here will remove pre-processing effect from the audio HAL.
2589 // This is safe as we hold the EffectChain mutex which guarantees that we are not in
2590 // the middle of a read from audio HAL
2591 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2592 mEffects[i]->state() == EffectModule::STOPPING) {
2593 mEffects[i]->stop_l();
2594 }
2595 if (release) {
2596 mEffects[i]->release_l("EffectChain::removeEffect");
2597 }
2598 // Skip operation when no thread attached (could lead to sigfpe as framecount is 0...)
2599 if (hasThreadAttached && type != EFFECT_FLAG_TYPE_AUXILIARY) {
2600 if (i == size - 1 && i != 0) {
2601 mEffects[i - 1]->configure_l();
2602 mEffects[i - 1]->setOutBuffer(mOutBuffer);
2603 mEffects[i - 1]->updateAccessMode_l(); // reconfig if needed.
2604 }
2605 }
2606 mEffects.removeAt(i);
2607
2608 // make sure the input buffer configuration for the new first effect in the chain
2609 // is updated if needed (can switch from HAL channel mask to mixer channel mask)
2610 if (type != EFFECT_FLAG_TYPE_AUXILIARY // TODO(b/284522658) breaks for aux FX, why?
2611 && hasThreadAttached && i == 0 && size > 1) {
2612 mEffects[0]->configure_l();
2613 mEffects[0]->setInBuffer(mInBuffer);
2614 mEffects[0]->updateAccessMode_l(); // reconfig if needed.
2615 }
2616
2617 ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %zu", effect.get(),
2618 this, i);
2619 break;
2620 }
2621 }
2622
2623 return mEffects.size();
2624 }
2625
2626 // setDevices_l() must be called with IAfThreadBase::mutex() held
setDevices_l(const AudioDeviceTypeAddrVector & devices)2627 void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices)
2628 {
2629 audio_utils::lock_guard _l(mutex());
2630 size_t size = mEffects.size();
2631 for (size_t i = 0; i < size; i++) {
2632 mEffects[i]->setDevices(devices);
2633 }
2634 }
2635
2636 // setInputDevice_l() must be called with IAfThreadBase::mutex() held
setInputDevice_l(const AudioDeviceTypeAddr & device)2637 void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device)
2638 {
2639 audio_utils::lock_guard _l(mutex());
2640 size_t size = mEffects.size();
2641 for (size_t i = 0; i < size; i++) {
2642 mEffects[i]->setInputDevice(device);
2643 }
2644 }
2645
2646 // setMode_l() must be called with IAfThreadBase::mutex() held
setMode_l(audio_mode_t mode)2647 void EffectChain::setMode_l(audio_mode_t mode)
2648 {
2649 audio_utils::lock_guard _l(mutex());
2650 size_t size = mEffects.size();
2651 for (size_t i = 0; i < size; i++) {
2652 mEffects[i]->setMode(mode);
2653 }
2654 }
2655
2656 // setAudioSource_l() must be called with IAfThreadBase::mutex() held
setAudioSource_l(audio_source_t source)2657 void EffectChain::setAudioSource_l(audio_source_t source)
2658 {
2659 audio_utils::lock_guard _l(mutex());
2660 size_t size = mEffects.size();
2661 for (size_t i = 0; i < size; i++) {
2662 mEffects[i]->setAudioSource(source);
2663 }
2664 }
2665
hasVolumeControlEnabled_l() const2666 bool EffectChain::hasVolumeControlEnabled_l() const {
2667 for (const auto &effect : mEffects) {
2668 if (effect->isVolumeControlEnabled_l()) return true;
2669 }
2670 return false;
2671 }
2672
2673 // setVolume() must be called without EffectChain::mutex()
setVolume(uint32_t * left,uint32_t * right,bool force)2674 bool EffectChain::setVolume(uint32_t* left, uint32_t* right, bool force) {
2675 audio_utils::lock_guard _l(mutex());
2676 return setVolume_l(left, right, force);
2677 }
2678
2679 // setVolume_l() must be called with EffectChain::mutex() held
setVolume_l(uint32_t * left,uint32_t * right,bool force)2680 bool EffectChain::setVolume_l(uint32_t* left, uint32_t* right, bool force) {
2681 uint32_t newLeft = *left;
2682 uint32_t newRight = *right;
2683 const size_t size = mEffects.size();
2684
2685 // first update volume controller
2686 const auto volumeControlIndex = findVolumeControl_l(0, size);
2687 // index of the effect chain volume controller
2688 const int ctrlIdx = volumeControlIndex.value_or(-1);
2689 const sp<IAfEffectModule> volumeControlEffect =
2690 volumeControlIndex.has_value() ? mEffects[ctrlIdx] : nullptr;
2691 const sp<IAfEffectModule> cachedVolumeControlEffect = mVolumeControlEffect.promote();
2692
2693 if (!force && volumeControlEffect == cachedVolumeControlEffect &&
2694 *left == mLeftVolume && *right == mRightVolume) {
2695 if (volumeControlIndex.has_value()) {
2696 *left = mNewLeftVolume;
2697 *right = mNewRightVolume;
2698 }
2699 return volumeControlIndex.has_value();
2700 }
2701 mVolumeControlEffect = volumeControlEffect;
2702
2703 for (int i = 0; i < ctrlIdx; ++i) {
2704 // For all effects before the effect that controls volume, they are not controlling the
2705 // effect chain volume, if these effects has the volume control capability, set the volume
2706 // to maximum to avoid double attenuation.
2707 if (mEffects[i]->isVolumeControl()) {
2708 uint32_t leftMax = 1 << 24;
2709 uint32_t rightMax = 1 << 24;
2710 mEffects[i]->setVolume_l(&leftMax, &rightMax,
2711 false /* not an effect chain volume controller */,
2712 true /* force */);
2713 }
2714 }
2715
2716 mLeftVolume = newLeft;
2717 mRightVolume = newRight;
2718
2719 // second get volume update from volume controller
2720 if (ctrlIdx >= 0) {
2721 mEffects[ctrlIdx]->setVolume_l(&newLeft, &newRight,
2722 true /* effect chain volume controller */);
2723 mNewLeftVolume = newLeft;
2724 mNewRightVolume = newRight;
2725 ALOGD("%s sessionId %d volume controller effect %s set (%d, %d), ret (%d, %d)", __func__,
2726 mSessionId, mEffects[ctrlIdx]->desc().name, mLeftVolume, mRightVolume, newLeft,
2727 newRight);
2728 }
2729 // then indicate volume to all other effects in chain.
2730 // Pass altered volume to effects before volume controller
2731 // and requested volume to effects after controller or with volume monitor flag
2732 uint32_t lVol = newLeft;
2733 uint32_t rVol = newRight;
2734
2735 for (size_t i = 0; i < size; i++) {
2736 if ((int)i == ctrlIdx) {
2737 continue;
2738 }
2739 // this also works for ctrlIdx == -1 when there is no volume controller
2740 if ((int)i > ctrlIdx) {
2741 lVol = *left;
2742 rVol = *right;
2743 }
2744 // Pass requested volume directly if this is volume monitor module
2745 if (mEffects[i]->isVolumeMonitor()) {
2746 mEffects[i]->setVolume_l(left, right,
2747 false /* not an effect chain volume controller */);
2748 } else {
2749 mEffects[i]->setVolume_l(&lVol, &rVol,
2750 false /* not an effect chain volume controller */);
2751 }
2752 }
2753 *left = newLeft;
2754 *right = newRight;
2755
2756 setVolumeForOutput_l(*left, *right);
2757
2758 return volumeControlIndex.has_value();
2759 }
2760
2761 // resetVolume_l() must be called with EffectChain::mutex() held
resetVolume_l()2762 void EffectChain::resetVolume_l()
2763 {
2764 if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) {
2765 uint32_t left = mLeftVolume;
2766 uint32_t right = mRightVolume;
2767 (void)setVolume_l(&left, &right, true);
2768 }
2769 }
2770
containsHapticGeneratingEffect()2771 bool EffectChain::containsHapticGeneratingEffect()
2772 {
2773 audio_utils::lock_guard _l(mutex());
2774 return containsHapticGeneratingEffect_l();
2775 }
2776 // containsHapticGeneratingEffect_l must be called with EffectChain::mutex() held
containsHapticGeneratingEffect_l()2777 bool EffectChain::containsHapticGeneratingEffect_l()
2778 {
2779 for (size_t i = 0; i < mEffects.size(); ++i) {
2780 if (mEffects[i]->isHapticGenerator()) {
2781 return true;
2782 }
2783 }
2784 return false;
2785 }
2786
setHapticScale_l(int id,os::HapticScale hapticScale)2787 void EffectChain::setHapticScale_l(int id, os::HapticScale hapticScale)
2788 {
2789 audio_utils::lock_guard _l(mutex());
2790 for (size_t i = 0; i < mEffects.size(); ++i) {
2791 mEffects[i]->setHapticScale_l(id, hapticScale);
2792 }
2793 }
2794
syncHalEffectsState_l()2795 void EffectChain::syncHalEffectsState_l()
2796 {
2797 audio_utils::lock_guard _l(mutex());
2798 for (size_t i = 0; i < mEffects.size(); i++) {
2799 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2800 mEffects[i]->state() == EffectModule::STOPPING) {
2801 mEffects[i]->addEffectToHal_l();
2802 }
2803 }
2804 }
2805
dump(int fd,const Vector<String16> & args) const2806 void EffectChain::dump(int fd, const Vector<String16>& args) const
2807 {
2808 String8 result;
2809 afutils::FallibleLockGuard l{mutex()};
2810 const size_t numEffects = mEffects.size();
2811 result.appendFormat(" %zu effects for session %d\n", numEffects, mSessionId);
2812 if (numEffects == 0) {
2813 write(fd, result.c_str(), result.size());
2814 return;
2815 }
2816
2817
2818 // failed to lock - AudioFlinger is probably deadlocked
2819 if (!l) {
2820 result.append("\tCould not lock mutex:\n");
2821 }
2822
2823 const std::string inBufferStr = dumpInOutBuffer(true /* isInput */, mInBuffer);
2824 const std::string outBufferStr = dumpInOutBuffer(false /* isInput */, mOutBuffer);
2825 result.appendFormat("\t%-*s%-*s Active tracks:\n",
2826 (int)inBufferStr.size(), "In buffer ",
2827 (int)outBufferStr.size(), "Out buffer ");
2828 result.appendFormat("\t%s %s %d\n",
2829 inBufferStr.c_str(), outBufferStr.c_str(), mActiveTrackCnt);
2830 write(fd, result.c_str(), result.size());
2831
2832 for (size_t i = 0; i < numEffects; ++i) {
2833 sp<IAfEffectModule> effect = mEffects[i];
2834 if (effect != 0) {
2835 effect->dump(fd, args);
2836 }
2837 }
2838 }
2839
2840 // must be called with IAfThreadBase::mutex() held
setEffectSuspended_l(const effect_uuid_t * type,bool suspend)2841 void EffectChain::setEffectSuspended_l(
2842 const effect_uuid_t *type, bool suspend)
2843 {
2844 sp<SuspendedEffectDesc> desc;
2845 // use effect type UUID timelow as key as there is no real risk of identical
2846 // timeLow fields among effect type UUIDs.
2847 ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow);
2848 if (suspend) {
2849 if (index >= 0) {
2850 desc = mSuspendedEffects.valueAt(index);
2851 } else {
2852 desc = new SuspendedEffectDesc();
2853 desc->mType = *type;
2854 mSuspendedEffects.add(type->timeLow, desc);
2855 ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
2856 }
2857
2858 if (desc->mRefCount++ == 0) {
2859 sp<IAfEffectModule> effect = getEffectIfEnabled_l(type);
2860 if (effect != 0) {
2861 desc->mEffect = effect;
2862 effect->setSuspended(true);
2863 effect->setEnabled(false, false /*fromHandle*/);
2864 }
2865 }
2866 } else {
2867 if (index < 0) {
2868 return;
2869 }
2870 desc = mSuspendedEffects.valueAt(index);
2871 if (desc->mRefCount <= 0) {
2872 ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
2873 desc->mRefCount = 0;
2874 return;
2875 }
2876 if (--desc->mRefCount == 0) {
2877 ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
2878 if (desc->mEffect != 0) {
2879 sp<IAfEffectModule> effect = desc->mEffect.promote();
2880 if (effect != 0) {
2881 effect->setSuspended(false);
2882 effect->mutex().lock();
2883 IAfEffectHandle *handle = effect->controlHandle_l();
2884 if (handle != NULL && !handle->disconnected()) {
2885 effect->setEnabled_l(handle->enabled());
2886 }
2887 effect->mutex().unlock();
2888 }
2889 desc->mEffect.clear();
2890 }
2891 mSuspendedEffects.removeItemsAt(index);
2892 }
2893 }
2894 }
2895
2896 // must be called with IAfThreadBase::mutex() held
setEffectSuspendedAll_l(bool suspend)2897 void EffectChain::setEffectSuspendedAll_l(bool suspend)
2898 {
2899 sp<SuspendedEffectDesc> desc;
2900
2901 ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2902 if (suspend) {
2903 if (index >= 0) {
2904 desc = mSuspendedEffects.valueAt(index);
2905 } else {
2906 desc = new SuspendedEffectDesc();
2907 mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
2908 ALOGV("setEffectSuspendedAll_l() add entry for 0");
2909 }
2910 if (desc->mRefCount++ == 0) {
2911 Vector< sp<IAfEffectModule> > effects;
2912 getSuspendEligibleEffects(effects);
2913 for (size_t i = 0; i < effects.size(); i++) {
2914 setEffectSuspended_l(&effects[i]->desc().type, true);
2915 }
2916 }
2917 } else {
2918 if (index < 0) {
2919 return;
2920 }
2921 desc = mSuspendedEffects.valueAt(index);
2922 if (desc->mRefCount <= 0) {
2923 ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
2924 desc->mRefCount = 1;
2925 }
2926 if (--desc->mRefCount == 0) {
2927 Vector<const effect_uuid_t *> types;
2928 for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
2929 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
2930 continue;
2931 }
2932 types.add(&mSuspendedEffects.valueAt(i)->mType);
2933 }
2934 for (size_t i = 0; i < types.size(); i++) {
2935 setEffectSuspended_l(types[i], false);
2936 }
2937 ALOGV("setEffectSuspendedAll_l() remove entry for %08x",
2938 mSuspendedEffects.keyAt(index));
2939 mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
2940 }
2941 }
2942 }
2943
2944
2945 // The volume effect is used for automated tests only
2946 #ifndef OPENSL_ES_H_
2947 static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
2948 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
2949 const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
2950 #endif //OPENSL_ES_H_
2951
2952 /* static */
isEffectEligibleForBtNrecSuspend_l(const effect_uuid_t * type)2953 bool EffectChain::isEffectEligibleForBtNrecSuspend_l(const effect_uuid_t* type) {
2954 // Only NS and AEC are suspended when BtNRec is off
2955 if ((memcmp(type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) ||
2956 (memcmp(type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
2957 return true;
2958 }
2959 return false;
2960 }
2961
isEffectEligibleForSuspend(const effect_descriptor_t & desc)2962 bool EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
2963 {
2964 // auxiliary effects and visualizer are never suspended on output mix
2965 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
2966 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
2967 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
2968 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0) ||
2969 (memcmp(&desc.type, SL_IID_DYNAMICSPROCESSING, sizeof(effect_uuid_t)) == 0))) {
2970 return false;
2971 }
2972 return true;
2973 }
2974
getSuspendEligibleEffects(Vector<sp<IAfEffectModule>> & effects)2975 void EffectChain::getSuspendEligibleEffects(
2976 Vector< sp<IAfEffectModule> > &effects)
2977 {
2978 effects.clear();
2979 audio_utils::lock_guard _l(mutex());
2980 for (size_t i = 0; i < mEffects.size(); i++) {
2981 if (isEffectEligibleForSuspend(mEffects[i]->desc())) {
2982 effects.add(mEffects[i]);
2983 }
2984 }
2985 }
2986
getEffectIfEnabled_l(const effect_uuid_t * type)2987 sp<IAfEffectModule> EffectChain::getEffectIfEnabled_l(const effect_uuid_t *type)
2988 {
2989 sp<IAfEffectModule> effect = getEffectFromType_l(type);
2990 return effect != 0 && effect->isEnabled() ? effect : 0;
2991 }
2992
checkSuspendOnEffectEnabled_l(const sp<IAfEffectModule> & effect,bool enabled)2993 void EffectChain::checkSuspendOnEffectEnabled_l(const sp<IAfEffectModule>& effect, bool enabled) {
2994 ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
2995 if (enabled) {
2996 if (index < 0) {
2997 // if the effect is not suspend check if all effects are suspended
2998 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2999 if (index < 0) {
3000 return;
3001 }
3002 if (!isEffectEligibleForSuspend(effect->desc())) {
3003 return;
3004 }
3005 setEffectSuspended_l(&effect->desc().type, enabled);
3006 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
3007 if (index < 0) {
3008 ALOGW("%s Fx should be suspended here!", __func__);
3009 return;
3010 }
3011 }
3012 ALOGV("%s enable suspending fx %08x", __func__, effect->desc().type.timeLow);
3013 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
3014 // if effect is requested to suspended but was not yet enabled, suspend it now.
3015 if (desc->mEffect == 0) {
3016 desc->mEffect = effect;
3017 effect->setEnabled(false, false /*fromHandle*/);
3018 effect->setSuspended(true);
3019 }
3020 } else {
3021 if (index < 0) {
3022 return;
3023 }
3024 ALOGV("%s disable restoring fx %08x", __func__, effect->desc().type.timeLow);
3025 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
3026 desc->mEffect.clear();
3027 effect->setSuspended(false);
3028 }
3029 }
3030
isNonOffloadableEnabled() const3031 bool EffectChain::isNonOffloadableEnabled() const
3032 {
3033 audio_utils::lock_guard _l(mutex());
3034 return isNonOffloadableEnabled_l();
3035 }
3036
isNonOffloadableEnabled_l() const3037 bool EffectChain::isNonOffloadableEnabled_l() const
3038 {
3039 size_t size = mEffects.size();
3040 for (size_t i = 0; i < size; i++) {
3041 if (mEffects[i]->isEnabled() && !mEffects[i]->isOffloadable()) {
3042 return true;
3043 }
3044 }
3045 return false;
3046 }
3047
setThread(const sp<IAfThreadBase> & thread)3048 void EffectChain::setThread(const sp<IAfThreadBase>& thread)
3049 {
3050 if (thread != nullptr) {
3051 mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
3052 mMaxTailBuffers =
3053 ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
3054 thread->frameCount();
3055 }
3056 audio_utils::lock_guard _l(mutex());
3057 mEffectCallback->setThread(thread);
3058 }
3059
checkOutputFlagCompatibility(audio_output_flags_t * flags) const3060 void EffectChain::checkOutputFlagCompatibility(audio_output_flags_t *flags) const
3061 {
3062 if ((*flags & AUDIO_OUTPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
3063 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_RAW);
3064 }
3065 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
3066 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
3067 }
3068 if ((*flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) != 0 && !isBitPerfectCompatible()) {
3069 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_BIT_PERFECT);
3070 }
3071 }
3072
checkInputFlagCompatibility(audio_input_flags_t * flags) const3073 void EffectChain::checkInputFlagCompatibility(audio_input_flags_t *flags) const
3074 {
3075 if ((*flags & AUDIO_INPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
3076 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_RAW);
3077 }
3078 if ((*flags & AUDIO_INPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
3079 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
3080 }
3081 }
3082
isRawCompatible() const3083 bool EffectChain::isRawCompatible() const
3084 {
3085 audio_utils::lock_guard _l(mutex());
3086 for (const auto &effect : mEffects) {
3087 if (effect->isProcessImplemented()) {
3088 return false;
3089 }
3090 }
3091 // Allow effects without processing.
3092 return true;
3093 }
3094
isFastCompatible() const3095 bool EffectChain::isFastCompatible() const
3096 {
3097 audio_utils::lock_guard _l(mutex());
3098 for (const auto &effect : mEffects) {
3099 if (effect->isProcessImplemented()
3100 && effect->isImplementationSoftware()) {
3101 return false;
3102 }
3103 }
3104 // Allow effects without processing or hw accelerated effects.
3105 return true;
3106 }
3107
isBitPerfectCompatible() const3108 bool EffectChain::isBitPerfectCompatible() const {
3109 audio_utils::lock_guard _l(mutex());
3110 for (const auto &effect : mEffects) {
3111 if (effect->isProcessImplemented()
3112 && effect->isImplementationSoftware()) {
3113 return false;
3114 }
3115 }
3116 // Allow effects without processing or hw accelerated effects.
3117 return true;
3118 }
3119
3120 // isCompatibleWithThread_l() must be called with thread->mutex() held
isCompatibleWithThread_l(const sp<IAfThreadBase> & thread) const3121 bool EffectChain::isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const
3122 {
3123 audio_utils::lock_guard _l(mutex());
3124 for (size_t i = 0; i < mEffects.size(); i++) {
3125 if (thread->checkEffectCompatibility_l(&(mEffects[i]->desc()), mSessionId) != NO_ERROR) {
3126 return false;
3127 }
3128 }
3129 return true;
3130 }
3131
3132 // sendMetadata_l() must be called with thread->mutex() held
sendMetadata_l(const std::vector<playback_track_metadata_v7_t> & allMetadata,const std::optional<const std::vector<playback_track_metadata_v7_t>> spatializedMetadata)3133 void EffectChain::sendMetadata_l(const std::vector<playback_track_metadata_v7_t>& allMetadata,
3134 const std::optional<const std::vector<playback_track_metadata_v7_t>> spatializedMetadata) {
3135 audio_utils::lock_guard _l(mutex());
3136 for (const auto& effect : mEffects) {
3137 if (spatializedMetadata.has_value()
3138 && IAfEffectModule::isSpatializer(&effect->desc().type)) {
3139 effect->sendMetadata_ll(spatializedMetadata.value());
3140 } else {
3141 effect->sendMetadata_ll(allMetadata);
3142 }
3143 }
3144 }
3145
3146 // EffectCallbackInterface implementation
createEffectHal(const effect_uuid_t * pEffectUuid,int32_t sessionId,int32_t deviceId,sp<EffectHalInterface> * effect)3147 status_t EffectChain::EffectCallback::createEffectHal(
3148 const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
3149 sp<EffectHalInterface> *effect) {
3150 status_t status = NO_INIT;
3151 const sp<EffectsFactoryHalInterface> effectsFactory =
3152 EffectConfiguration::getEffectsFactoryHal();
3153 if (effectsFactory != 0) {
3154 status = effectsFactory->createEffect(pEffectUuid, sessionId, io(), deviceId, effect);
3155 }
3156 return status;
3157 }
3158
updateOrphanEffectChains(const sp<IAfEffectBase> & effect)3159 bool EffectChain::EffectCallback::updateOrphanEffectChains(
3160 const sp<IAfEffectBase>& effect) {
3161 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
3162 return mAfThreadCallback->updateOrphanEffectChains(effect->asEffectModule());
3163 }
3164
allocateHalBuffer(size_t size,sp<EffectBufferHalInterface> * buffer)3165 status_t EffectChain::EffectCallback::allocateHalBuffer(
3166 size_t size, sp<EffectBufferHalInterface>* buffer) {
3167 return mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(size, buffer);
3168 }
3169
addEffectToHal(const sp<EffectHalInterface> & effect)3170 status_t EffectChain::EffectCallback::addEffectToHal(
3171 const sp<EffectHalInterface>& effect) {
3172 status_t result = NO_INIT;
3173 const sp<IAfThreadBase> t = thread().promote();
3174 if (t == nullptr) {
3175 return result;
3176 }
3177 sp <StreamHalInterface> st = t->stream();
3178 if (st == nullptr) {
3179 return result;
3180 }
3181 result = st->addEffect(effect);
3182 ALOGE_IF(result != OK, "Error when adding effect: %d", result);
3183 return result;
3184 }
3185
removeEffectFromHal(const sp<EffectHalInterface> & effect)3186 status_t EffectChain::EffectCallback::removeEffectFromHal(
3187 const sp<EffectHalInterface>& effect) {
3188 status_t result = NO_INIT;
3189 const sp<IAfThreadBase> t = thread().promote();
3190 if (t == nullptr) {
3191 return result;
3192 }
3193 sp <StreamHalInterface> st = t->stream();
3194 if (st == nullptr) {
3195 return result;
3196 }
3197 result = st->removeEffect(effect);
3198 ALOGE_IF(result != OK, "Error when removing effect: %d", result);
3199 return result;
3200 }
3201
io() const3202 audio_io_handle_t EffectChain::EffectCallback::io() const {
3203 const sp<IAfThreadBase> t = thread().promote();
3204 if (t == nullptr) {
3205 return AUDIO_IO_HANDLE_NONE;
3206 }
3207 return t->id();
3208 }
3209
isOutput() const3210 bool EffectChain::EffectCallback::isOutput() const {
3211 const sp<IAfThreadBase> t = thread().promote();
3212 if (t == nullptr) {
3213 return true;
3214 }
3215 return t->isOutput();
3216 }
3217
isOffload() const3218 bool EffectChain::EffectCallback::isOffload() const {
3219 return mThreadType == IAfThreadBase::OFFLOAD;
3220 }
3221
isOffloadOrDirect() const3222 bool EffectChain::EffectCallback::isOffloadOrDirect() const {
3223 return mThreadType == IAfThreadBase::OFFLOAD
3224 || mThreadType == IAfThreadBase::DIRECT;
3225 }
3226
isOffloadOrMmap() const3227 bool EffectChain::EffectCallback::isOffloadOrMmap() const {
3228 switch (mThreadType) {
3229 case IAfThreadBase::OFFLOAD:
3230 case IAfThreadBase::MMAP_PLAYBACK:
3231 case IAfThreadBase::MMAP_CAPTURE:
3232 return true;
3233 default:
3234 return false;
3235 }
3236 }
3237
isSpatializer() const3238 bool EffectChain::EffectCallback::isSpatializer() const {
3239 return mThreadType == IAfThreadBase::SPATIALIZER;
3240 }
3241
sampleRate() const3242 uint32_t EffectChain::EffectCallback::sampleRate() const {
3243 const sp<IAfThreadBase> t = thread().promote();
3244 if (t == nullptr) {
3245 return DEFAULT_OUTPUT_SAMPLE_RATE;
3246 }
3247 return t->sampleRate();
3248 }
3249
inChannelMask(int id) const3250 audio_channel_mask_t EffectChain::EffectCallback::inChannelMask(int id) const
3251 NO_THREAD_SAFETY_ANALYSIS
3252 // calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
3253 // calling function 'isFirstEffect_l' requires holding mutex 'EffectChain_Mutex' exclusively
3254 {
3255 const sp<IAfThreadBase> t = thread().promote();
3256 if (t == nullptr) {
3257 return AUDIO_CHANNEL_OUT_STEREO;
3258 }
3259 sp<IAfEffectChain> c = chain().promote();
3260 if (c == nullptr) {
3261 return AUDIO_CHANNEL_OUT_STEREO;
3262 }
3263
3264 if (mThreadType == IAfThreadBase::SPATIALIZER) {
3265 if (c->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
3266 return t->mixerChannelMask();
3267 } else if (c->sessionId() == AUDIO_SESSION_OUTPUT_STAGE) {
3268 if (c->isFirstEffect_l(id)) {
3269 return t->mixerChannelMask();
3270 } else {
3271 return t->channelMask();
3272 }
3273 } else if (!audio_is_global_session(c->sessionId())) {
3274 if ((t->hasAudioSession_l(c->sessionId())
3275 & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
3276 return t->mixerChannelMask();
3277 } else {
3278 return t->channelMask();
3279 }
3280 } else {
3281 return t->channelMask();
3282 }
3283 } else {
3284 return t->channelMask();
3285 }
3286 }
3287
inChannelCount(int id) const3288 uint32_t EffectChain::EffectCallback::inChannelCount(int id) const {
3289 return audio_channel_count_from_out_mask(inChannelMask(id));
3290 }
3291
outChannelMask() const3292 audio_channel_mask_t EffectChain::EffectCallback::outChannelMask() const
3293 NO_THREAD_SAFETY_ANALYSIS
3294 // calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
3295 {
3296 const sp<IAfThreadBase> t = thread().promote();
3297 if (t == nullptr) {
3298 return AUDIO_CHANNEL_OUT_STEREO;
3299 }
3300 sp<IAfEffectChain> c = chain().promote();
3301 if (c == nullptr) {
3302 return AUDIO_CHANNEL_OUT_STEREO;
3303 }
3304
3305 if (mThreadType == IAfThreadBase::SPATIALIZER) {
3306 if (!audio_is_global_session(c->sessionId())) {
3307 if ((t->hasAudioSession_l(c->sessionId())
3308 & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
3309 return t->mixerChannelMask();
3310 } else {
3311 return t->channelMask();
3312 }
3313 } else {
3314 return (c->sessionId() == AUDIO_SESSION_OUTPUT_MIX) ? t->mixerChannelMask()
3315 : t->channelMask();
3316 }
3317 } else {
3318 return t->channelMask();
3319 }
3320 }
3321
outChannelCount() const3322 uint32_t EffectChain::EffectCallback::outChannelCount() const {
3323 return audio_channel_count_from_out_mask(outChannelMask());
3324 }
3325
hapticChannelMask() const3326 audio_channel_mask_t EffectChain::EffectCallback::hapticChannelMask() const {
3327 const sp<IAfThreadBase> t = thread().promote();
3328 if (t == nullptr) {
3329 return AUDIO_CHANNEL_NONE;
3330 }
3331 return t->hapticChannelMask();
3332 }
3333
frameCount() const3334 size_t EffectChain::EffectCallback::frameCount() const {
3335 const sp<IAfThreadBase> t = thread().promote();
3336 if (t == nullptr) {
3337 // frameCount cannot be zero.
3338 return 1;
3339 }
3340 return t->frameCount();
3341 }
3342
latency() const3343 uint32_t EffectChain::EffectCallback::latency() const
3344 NO_THREAD_SAFETY_ANALYSIS // latency_l() access
3345 {
3346 const sp<IAfThreadBase> t = thread().promote();
3347 if (t == nullptr) {
3348 return 0;
3349 }
3350 // TODO(b/275956781) - this requires the thread lock.
3351 return t->latency_l();
3352 }
3353
setVolumeForOutput(float left,float right) const3354 void EffectChain::EffectCallback::setVolumeForOutput(float left, float right) const
3355 NO_THREAD_SAFETY_ANALYSIS // setVolumeForOutput_l() access
3356 {
3357 const sp<IAfThreadBase> t = thread().promote();
3358 if (t == nullptr) {
3359 return;
3360 }
3361 t->setVolumeForOutput_l(left, right);
3362 }
3363
checkSuspendOnEffectEnabled(const sp<IAfEffectBase> & effect,bool enabled,bool threadLocked)3364 void EffectChain::EffectCallback::checkSuspendOnEffectEnabled(const sp<IAfEffectBase>& effect,
3365 bool enabled, bool threadLocked)
3366 NO_THREAD_SAFETY_ANALYSIS {
3367 const sp<IAfThreadBase> t = thread().promote();
3368 if (t == nullptr) {
3369 return;
3370 }
3371 t->checkSuspendOnEffectEnabled(enabled, effect->sessionId(), threadLocked);
3372
3373 sp<IAfEffectChain> c = chain().promote();
3374 if (c == nullptr) {
3375 return;
3376 }
3377 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
3378 c->checkSuspendOnEffectEnabled_l(effect->asEffectModule(), enabled);
3379 }
3380
onEffectEnable(const sp<IAfEffectBase> & effect)3381 void EffectChain::EffectCallback::onEffectEnable(const sp<IAfEffectBase>& effect) {
3382 const sp<IAfThreadBase> t = thread().promote();
3383 if (t == nullptr) {
3384 return;
3385 }
3386 // in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
3387 t->onEffectEnable(effect->asEffectModule());
3388 }
3389
onEffectDisable(const sp<IAfEffectBase> & effect)3390 void EffectChain::EffectCallback::onEffectDisable(const sp<IAfEffectBase>& effect) {
3391 checkSuspendOnEffectEnabled(effect, false, false /*threadLocked*/);
3392
3393 const sp<IAfThreadBase> t = thread().promote();
3394 if (t == nullptr) {
3395 return;
3396 }
3397 t->onEffectDisable();
3398 }
3399
disconnectEffectHandle(IAfEffectHandle * handle,bool unpinIfLast)3400 bool EffectChain::EffectCallback::disconnectEffectHandle(IAfEffectHandle *handle,
3401 bool unpinIfLast) {
3402 const sp<IAfThreadBase> t = thread().promote();
3403 if (t == nullptr) {
3404 return false;
3405 }
3406 t->disconnectEffectHandle(handle, unpinIfLast);
3407 return true;
3408 }
3409
resetVolume_l()3410 void EffectChain::EffectCallback::resetVolume_l() {
3411 sp<IAfEffectChain> c = chain().promote();
3412 if (c == nullptr) {
3413 return;
3414 }
3415 c->resetVolume_l();
3416
3417 }
3418
strategy() const3419 product_strategy_t EffectChain::EffectCallback::strategy() const {
3420 sp<IAfEffectChain> c = chain().promote();
3421 if (c == nullptr) {
3422 return PRODUCT_STRATEGY_NONE;
3423 }
3424 return c->strategy();
3425 }
3426
activeTrackCnt() const3427 int32_t EffectChain::EffectCallback::activeTrackCnt() const {
3428 sp<IAfEffectChain> c = chain().promote();
3429 if (c == nullptr) {
3430 return 0;
3431 }
3432 return c->activeTrackCnt();
3433 }
3434
3435
3436 #undef LOG_TAG
3437 #define LOG_TAG "DeviceEffectProxy"
3438
3439 /* static */
create(const AudioDeviceTypeAddr & device,const sp<DeviceEffectManagerCallback> & callback,effect_descriptor_t * desc,int id,bool notifyFramesProcessed)3440 sp<IAfDeviceEffectProxy> IAfDeviceEffectProxy::create(
3441 const AudioDeviceTypeAddr& device,
3442 const sp<DeviceEffectManagerCallback>& callback,
3443 effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
3444 {
3445 return sp<DeviceEffectProxy>::make(device,
3446 callback,
3447 desc, id, notifyFramesProcessed);
3448 }
3449
setEnabled(bool enabled,bool fromHandle)3450 status_t DeviceEffectProxy::setEnabled(bool enabled, bool fromHandle)
3451 {
3452 status_t status = EffectBase::setEnabled(enabled, fromHandle);
3453 audio_utils::lock_guard _l(proxyMutex());
3454 if (status == NO_ERROR) {
3455 for (auto& handle : mEffectHandles) {
3456 Status bs;
3457 if (enabled) {
3458 bs = handle.second->asIEffect()->enable(&status);
3459 } else {
3460 bs = handle.second->asIEffect()->disable(&status);
3461 }
3462 if (!bs.isOk()) {
3463 status = statusTFromBinderStatus(bs);
3464 }
3465 }
3466 }
3467 ALOGV("%s enable %d status %d", __func__, enabled, status);
3468 return status;
3469 }
3470
init_l(const std::map<audio_patch_handle_t,IAfPatchPanel::Patch> & patches)3471 status_t DeviceEffectProxy::init_l(
3472 const std::map <audio_patch_handle_t, IAfPatchPanel::Patch>& patches) {
3473 //For all audio patches
3474 //If src or sink device match
3475 //If the effect is HW accelerated
3476 // if no corresponding effect module
3477 // Create EffectModule: mHalEffect
3478 //Create and attach EffectHandle
3479 //If the effect is not HW accelerated and the patch sink or src is a mixer port
3480 // Create Effect on patch input or output thread on session -1
3481 //Add EffectHandle to EffectHandle map of Effect Proxy:
3482 ALOGV("%s device type %d address %s", __func__, mDevice.mType, mDevice.getAddress());
3483 status_t status = NO_ERROR;
3484 for (auto &patch : patches) {
3485 status = onCreatePatch(patch.first, patch.second);
3486 ALOGV("%s onCreatePatch status %d", __func__, status);
3487 if (status == BAD_VALUE) {
3488 return status;
3489 }
3490 }
3491 return status;
3492 }
3493
onUpdatePatch(audio_patch_handle_t oldPatchHandle,audio_patch_handle_t newPatchHandle,const IAfPatchPanel::Patch &)3494 status_t DeviceEffectProxy::onUpdatePatch(audio_patch_handle_t oldPatchHandle,
3495 audio_patch_handle_t newPatchHandle,
3496 const IAfPatchPanel::Patch& /* patch */) {
3497 status_t status = NAME_NOT_FOUND;
3498 ALOGV("%s", __func__);
3499 audio_utils::lock_guard _l(proxyMutex());
3500 if (mEffectHandles.find(oldPatchHandle) != mEffectHandles.end()) {
3501 ALOGV("%s replacing effect from handle %d to handle %d", __func__, oldPatchHandle,
3502 newPatchHandle);
3503 sp<IAfEffectHandle> effect = mEffectHandles.at(oldPatchHandle);
3504 mEffectHandles.erase(oldPatchHandle);
3505 mEffectHandles.emplace(newPatchHandle, effect);
3506 status = NO_ERROR;
3507 }
3508 return status;
3509 }
3510
onCreatePatch(audio_patch_handle_t patchHandle,const IAfPatchPanel::Patch & patch)3511 status_t DeviceEffectProxy::onCreatePatch(
3512 audio_patch_handle_t patchHandle, const IAfPatchPanel::Patch& patch) {
3513 status_t status = NAME_NOT_FOUND;
3514 sp<IAfEffectHandle> handle;
3515 // only consider source[0] as this is the only "true" source of a patch
3516 status = checkPort(patch, &patch.mAudioPatch.sources[0], &handle);
3517 ALOGV("%s source checkPort status %d", __func__, status);
3518 for (uint32_t i = 0; i < patch.mAudioPatch.num_sinks && status == NAME_NOT_FOUND; i++) {
3519 status = checkPort(patch, &patch.mAudioPatch.sinks[i], &handle);
3520 ALOGV("%s sink %d checkPort status %d", __func__, i, status);
3521 }
3522 if (status == NO_ERROR || status == ALREADY_EXISTS) {
3523 audio_utils::lock_guard _l(proxyMutex());
3524 size_t erasedHandle = mEffectHandles.erase(patchHandle);
3525 ALOGV("%s %s effecthandle %p for patch %d",
3526 __func__, (erasedHandle == 0 ? "adding" : "replacing"), handle.get(), patchHandle);
3527 mEffectHandles.emplace(patchHandle, handle);
3528 }
3529 ALOGW_IF(status == BAD_VALUE,
3530 "%s cannot attach effect %s on patch %d", __func__, mDescriptor.name, patchHandle);
3531
3532 return status;
3533 }
3534
checkPort(const IAfPatchPanel::Patch & patch,const struct audio_port_config * port,sp<IAfEffectHandle> * handle)3535 status_t DeviceEffectProxy::checkPort(const IAfPatchPanel::Patch& patch,
3536 const struct audio_port_config *port, sp<IAfEffectHandle> *handle)
3537 NO_THREAD_SAFETY_ANALYSIS
3538 // calling function 'createEffect_l' requires holding mutex 'AudioFlinger_Mutex' exclusively
3539 {
3540
3541 ALOGV("%s type %d device type %d address %s device ID %d patch.isSoftware() %d",
3542 __func__, port->type, port->ext.device.type,
3543 port->ext.device.address, port->id, patch.isSoftware());
3544 if (port->type != AUDIO_PORT_TYPE_DEVICE || port->ext.device.type != mDevice.mType ||
3545 port->ext.device.address != mDevice.address()) {
3546 return NAME_NOT_FOUND;
3547 }
3548 if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) &&
3549 (audio_port_config_has_input_direction(port))) {
3550 ALOGI("%s don't create postprocessing effect on record port", __func__);
3551 return NAME_NOT_FOUND;
3552 }
3553 if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) &&
3554 (!audio_port_config_has_input_direction(port))) {
3555 ALOGI("%s don't create preprocessing effect on playback port", __func__);
3556 return NAME_NOT_FOUND;
3557 }
3558 status_t status = NAME_NOT_FOUND;
3559
3560 if (mDescriptor.flags & EFFECT_FLAG_HW_ACC_TUNNEL) {
3561 audio_utils::lock_guard _l(proxyMutex());
3562 if (mHalEffect != nullptr && mDevicePort.id == port->id) {
3563 ALOGV("%s reusing HAL effect", __func__);
3564 } else {
3565 mDevicePort = *port;
3566 mHalEffect = sp<HwAccDeviceEffectModule>::make(mMyCallback,
3567 const_cast<effect_descriptor_t *>(&mDescriptor), mMyCallback->newEffectId(),
3568 port->id);
3569 mHalEffect->configure_l();
3570 if (audio_is_input_device(mDevice.mType)) {
3571 mHalEffect->setInputDevice(mDevice);
3572 } else {
3573 mHalEffect->setDevices({mDevice});
3574 }
3575 }
3576 *handle = sp<InternalEffectHandle>::make(mHalEffect, mNotifyFramesProcessed);
3577 status = (*handle)->initCheck();
3578 if (status == OK) {
3579 status = mHalEffect->addHandle((*handle).get());
3580 } else {
3581 mHalEffect.clear();
3582 mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
3583 }
3584 } else if (patch.isSoftware() || patch.thread().promote() != nullptr) {
3585 sp<IAfThreadBase> thread;
3586 if (audio_port_config_has_input_direction(port)) {
3587 if (patch.isSoftware()) {
3588 thread = patch.mRecord.thread();
3589 } else {
3590 thread = patch.thread().promote();
3591 }
3592 } else {
3593 if (patch.isSoftware()) {
3594 thread = patch.mPlayback.thread();
3595 } else {
3596 thread = patch.thread().promote();
3597 }
3598 }
3599 int enabled;
3600 *handle = thread->createEffect_l(nullptr, nullptr, 0, AUDIO_SESSION_DEVICE,
3601 const_cast<effect_descriptor_t *>(&mDescriptor),
3602 &enabled, &status, false, false /*probe*/,
3603 mNotifyFramesProcessed);
3604 ALOGV("%s thread->createEffect_l status %d", __func__, status);
3605 } else {
3606 status = BAD_VALUE;
3607 }
3608
3609 if (status == NO_ERROR || status == ALREADY_EXISTS) {
3610 Status bs;
3611 if (isEnabled()) {
3612 bs = (*handle)->asIEffect()->enable(&status);
3613 } else {
3614 bs = (*handle)->asIEffect()->disable(&status);
3615 }
3616 if (!bs.isOk()) {
3617 status = statusTFromBinderStatus(bs);
3618 }
3619 }
3620 return status;
3621 }
3622
onReleasePatch(audio_patch_handle_t patchHandle)3623 sp<IAfEffectHandle> DeviceEffectProxy::onReleasePatch(audio_patch_handle_t patchHandle) {
3624 sp<IAfEffectHandle> disconnectedHandle;
3625 {
3626 audio_utils::lock_guard _l(proxyMutex());
3627 if (mEffectHandles.find(patchHandle) != mEffectHandles.end()) {
3628 disconnectedHandle = std::move(mEffectHandles.at(patchHandle));
3629 mEffectHandles.erase(patchHandle);
3630 }
3631 }
3632 return disconnectedHandle;
3633 }
3634
3635
removeEffect(const sp<IAfEffectModule> & effect)3636 size_t DeviceEffectProxy::removeEffect(const sp<IAfEffectModule>& effect)
3637 {
3638 audio_utils::lock_guard _l(proxyMutex());
3639 if (effect == mHalEffect) {
3640 mHalEffect->release_l("DeviceEffectProxy::removeEffect");
3641 mHalEffect.clear();
3642 mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
3643 }
3644 return mHalEffect == nullptr ? 0 : 1;
3645 }
3646
addEffectToHal(const sp<EffectHalInterface> & effect)3647 status_t DeviceEffectProxy::addEffectToHal(
3648 const sp<EffectHalInterface>& effect) {
3649 if (mHalEffect == nullptr) {
3650 return NO_INIT;
3651 }
3652 return mManagerCallback->addEffectToHal(&mDevicePort, effect);
3653 }
3654
removeEffectFromHal(const sp<EffectHalInterface> & effect)3655 status_t DeviceEffectProxy::removeEffectFromHal(
3656 const sp<EffectHalInterface>& effect) {
3657 if (mHalEffect == nullptr) {
3658 return NO_INIT;
3659 }
3660 return mManagerCallback->removeEffectFromHal(&mDevicePort, effect);
3661 }
3662
command(int32_t cmdCode,const std::vector<uint8_t> & cmdData,int32_t maxReplySize,std::vector<uint8_t> * reply)3663 status_t DeviceEffectProxy::command(
3664 int32_t cmdCode, const std::vector<uint8_t>& cmdData, int32_t maxReplySize,
3665 std::vector<uint8_t>* reply) {
3666 audio_utils::lock_guard _l(proxyMutex());
3667 status_t status = EffectBase::command(cmdCode, cmdData, maxReplySize, reply);
3668 if (status == NO_ERROR) {
3669 for (auto& handle : mEffectHandles) {
3670 sp<IAfEffectBase> effect = handle.second->effect().promote();
3671 if (effect != nullptr) {
3672 status = effect->command(cmdCode, cmdData, maxReplySize, reply);
3673 }
3674 }
3675 }
3676 ALOGV("%s status %d", __func__, status);
3677 return status;
3678 }
3679
isOutput() const3680 bool DeviceEffectProxy::isOutput() const {
3681 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE) {
3682 return mDevicePort.role == AUDIO_PORT_ROLE_SINK;
3683 }
3684 return true;
3685 }
3686
sampleRate() const3687 uint32_t DeviceEffectProxy::sampleRate() const {
3688 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
3689 (mDevicePort.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) != 0) {
3690 return mDevicePort.sample_rate;
3691 }
3692 return DEFAULT_OUTPUT_SAMPLE_RATE;
3693 }
3694
channelMask() const3695 audio_channel_mask_t DeviceEffectProxy::channelMask() const {
3696 if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
3697 (mDevicePort.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) != 0) {
3698 return mDevicePort.channel_mask;
3699 }
3700 return AUDIO_CHANNEL_OUT_STEREO;
3701 }
3702
channelCount() const3703 uint32_t DeviceEffectProxy::channelCount() const {
3704 if (isOutput()) {
3705 return audio_channel_count_from_out_mask(channelMask());
3706 }
3707 return audio_channel_count_from_in_mask(channelMask());
3708 }
3709
dump2(int fd,int spaces) const3710 void DeviceEffectProxy::dump2(int fd, int spaces) const
3711 {
3712 const Vector<String16> args;
3713 EffectBase::dump(fd, args);
3714
3715 afutils::FallibleLockGuard l{proxyMutex()};
3716
3717 if (!l) {
3718 String8 result("DeviceEffectProxy may be deadlocked\n");
3719 write(fd, result.c_str(), result.size());
3720 }
3721
3722 String8 outStr;
3723 if (mHalEffect != nullptr) {
3724 outStr.appendFormat("%*sHAL Effect Id: %d\n", spaces, "", mHalEffect->id());
3725 } else {
3726 outStr.appendFormat("%*sNO HAL Effect\n", spaces, "");
3727 }
3728 write(fd, outStr.c_str(), outStr.size());
3729 outStr.clear();
3730
3731 outStr.appendFormat("%*sSub Effects:\n", spaces, "");
3732 write(fd, outStr.c_str(), outStr.size());
3733 outStr.clear();
3734
3735 for (const auto& iter : mEffectHandles) {
3736 outStr.appendFormat("%*sEffect for patch handle %d:\n", spaces + 2, "", iter.first);
3737 write(fd, outStr.c_str(), outStr.size());
3738 outStr.clear();
3739 sp<IAfEffectBase> effect = iter.second->effect().promote();
3740 if (effect != nullptr) {
3741 effect->dump(fd, args);
3742 }
3743 }
3744 }
3745
3746 #undef LOG_TAG
3747 #define LOG_TAG "DeviceEffectProxy::ProxyCallback"
3748
newEffectId()3749 int DeviceEffectProxy::ProxyCallback::newEffectId() {
3750 return mManagerCallback->newEffectId();
3751 }
3752
3753
disconnectEffectHandle(IAfEffectHandle * handle,bool unpinIfLast)3754 bool DeviceEffectProxy::ProxyCallback::disconnectEffectHandle(
3755 IAfEffectHandle *handle, bool unpinIfLast) {
3756 sp<IAfEffectBase> effectBase = handle->effect().promote();
3757 if (effectBase == nullptr) {
3758 return false;
3759 }
3760
3761 sp<IAfEffectModule> effect = effectBase->asEffectModule();
3762 if (effect == nullptr) {
3763 return false;
3764 }
3765
3766 // restore suspended effects if the disconnected handle was enabled and the last one.
3767 bool remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
3768 if (remove) {
3769 sp<DeviceEffectProxy> proxy = mProxy.promote();
3770 if (proxy != nullptr) {
3771 proxy->removeEffect(effect);
3772 }
3773 if (handle->enabled()) {
3774 effectBase->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
3775 }
3776 }
3777 return true;
3778 }
3779
createEffectHal(const effect_uuid_t * pEffectUuid,int32_t sessionId,int32_t deviceId,sp<EffectHalInterface> * effect)3780 status_t DeviceEffectProxy::ProxyCallback::createEffectHal(
3781 const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
3782 sp<EffectHalInterface> *effect) {
3783 return mManagerCallback->createEffectHal(pEffectUuid, sessionId, deviceId, effect);
3784 }
3785
addEffectToHal(const sp<EffectHalInterface> & effect)3786 status_t DeviceEffectProxy::ProxyCallback::addEffectToHal(
3787 const sp<EffectHalInterface>& effect) {
3788 sp<DeviceEffectProxy> proxy = mProxy.promote();
3789 if (proxy == nullptr) {
3790 return NO_INIT;
3791 }
3792 return proxy->addEffectToHal(effect);
3793 }
3794
removeEffectFromHal(const sp<EffectHalInterface> & effect)3795 status_t DeviceEffectProxy::ProxyCallback::removeEffectFromHal(
3796 const sp<EffectHalInterface>& effect) {
3797 sp<DeviceEffectProxy> proxy = mProxy.promote();
3798 if (proxy == nullptr) {
3799 return NO_INIT;
3800 }
3801 return proxy->removeEffectFromHal(effect);
3802 }
3803
isOutput() const3804 bool DeviceEffectProxy::ProxyCallback::isOutput() const {
3805 sp<DeviceEffectProxy> proxy = mProxy.promote();
3806 if (proxy == nullptr) {
3807 return true;
3808 }
3809 return proxy->isOutput();
3810 }
3811
sampleRate() const3812 uint32_t DeviceEffectProxy::ProxyCallback::sampleRate() const {
3813 sp<DeviceEffectProxy> proxy = mProxy.promote();
3814 if (proxy == nullptr) {
3815 return DEFAULT_OUTPUT_SAMPLE_RATE;
3816 }
3817 return proxy->sampleRate();
3818 }
3819
inChannelMask(int id __unused) const3820 audio_channel_mask_t DeviceEffectProxy::ProxyCallback::inChannelMask(
3821 int id __unused) const {
3822 sp<DeviceEffectProxy> proxy = mProxy.promote();
3823 if (proxy == nullptr) {
3824 return AUDIO_CHANNEL_OUT_STEREO;
3825 }
3826 return proxy->channelMask();
3827 }
3828
inChannelCount(int id __unused) const3829 uint32_t DeviceEffectProxy::ProxyCallback::inChannelCount(int id __unused) const {
3830 sp<DeviceEffectProxy> proxy = mProxy.promote();
3831 if (proxy == nullptr) {
3832 return 2;
3833 }
3834 return proxy->channelCount();
3835 }
3836
outChannelMask() const3837 audio_channel_mask_t DeviceEffectProxy::ProxyCallback::outChannelMask() const {
3838 sp<DeviceEffectProxy> proxy = mProxy.promote();
3839 if (proxy == nullptr) {
3840 return AUDIO_CHANNEL_OUT_STEREO;
3841 }
3842 return proxy->channelMask();
3843 }
3844
outChannelCount() const3845 uint32_t DeviceEffectProxy::ProxyCallback::outChannelCount() const {
3846 sp<DeviceEffectProxy> proxy = mProxy.promote();
3847 if (proxy == nullptr) {
3848 return 2;
3849 }
3850 return proxy->channelCount();
3851 }
3852
onEffectEnable(const sp<IAfEffectBase> & effectBase)3853 void DeviceEffectProxy::ProxyCallback::onEffectEnable(
3854 const sp<IAfEffectBase>& effectBase) {
3855 sp<IAfEffectModule> effect = effectBase->asEffectModule();
3856 if (effect == nullptr) {
3857 return;
3858 }
3859 effect->start_l();
3860 }
3861
onEffectDisable(const sp<IAfEffectBase> & effectBase)3862 void DeviceEffectProxy::ProxyCallback::onEffectDisable(
3863 const sp<IAfEffectBase>& effectBase) {
3864 sp<IAfEffectModule> effect = effectBase->asEffectModule();
3865 if (effect == nullptr) {
3866 return;
3867 }
3868 effect->stop_l();
3869 }
3870
3871 } // namespace android
3872