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 <algorithm>
23
24 #include "Configuration.h"
25 #include <utils/Log.h>
26 #include <system/audio_effects/effect_aec.h>
27 #include <system/audio_effects/effect_ns.h>
28 #include <system/audio_effects/effect_visualizer.h>
29 #include <audio_utils/channels.h>
30 #include <audio_utils/primitives.h>
31 #include <media/AudioEffect.h>
32 #include <media/audiohal/EffectHalInterface.h>
33 #include <media/audiohal/EffectsFactoryHalInterface.h>
34
35 #include "AudioFlinger.h"
36 #include "ServiceUtilities.h"
37
38 // ----------------------------------------------------------------------------
39
40 // Note: the following macro is used for extremely verbose logging message. In
41 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
42 // 0; but one side effect of this is to turn all LOGV's as well. Some messages
43 // are so verbose that we want to suppress them even when we have ALOG_ASSERT
44 // turned on. Do not uncomment the #def below unless you really know what you
45 // are doing and want to see all of the extremely verbose messages.
46 //#define VERY_VERY_VERBOSE_LOGGING
47 #ifdef VERY_VERY_VERBOSE_LOGGING
48 #define ALOGVV ALOGV
49 #else
50 #define ALOGVV(a...) do { } while(0)
51 #endif
52
53 namespace android {
54
55 // ----------------------------------------------------------------------------
56 // EffectModule implementation
57 // ----------------------------------------------------------------------------
58
59 #undef LOG_TAG
60 #define LOG_TAG "AudioFlinger::EffectModule"
61
EffectModule(ThreadBase * thread,const wp<AudioFlinger::EffectChain> & chain,effect_descriptor_t * desc,int id,audio_session_t sessionId,bool pinned)62 AudioFlinger::EffectModule::EffectModule(ThreadBase *thread,
63 const wp<AudioFlinger::EffectChain>& chain,
64 effect_descriptor_t *desc,
65 int id,
66 audio_session_t sessionId,
67 bool pinned)
68 : mPinned(pinned),
69 mThread(thread), mChain(chain), mId(id), mSessionId(sessionId),
70 mDescriptor(*desc),
71 // clear mConfig to ensure consistent initial value of buffer framecount
72 // in case buffers are associated by setInBuffer() or setOutBuffer()
73 // prior to configure().
74 mConfig{{}, {}},
75 mStatus(NO_INIT), mState(IDLE),
76 mMaxDisableWaitCnt(1), // set by configure(), should be >= 1
77 mDisableWaitCnt(0), // set by process() and updateState()
78 mSuspended(false),
79 mOffloaded(false),
80 mAudioFlinger(thread->mAudioFlinger)
81 #ifdef FLOAT_EFFECT_CHAIN
82 , mSupportsFloat(false)
83 #endif
84 {
85 ALOGV("Constructor %p pinned %d", this, pinned);
86 int lStatus;
87
88 // create effect engine from effect factory
89 mStatus = -ENODEV;
90 sp<AudioFlinger> audioFlinger = mAudioFlinger.promote();
91 if (audioFlinger != 0) {
92 sp<EffectsFactoryHalInterface> effectsFactory = audioFlinger->getEffectsFactory();
93 if (effectsFactory != 0) {
94 mStatus = effectsFactory->createEffect(
95 &desc->uuid, sessionId, thread->id(), &mEffectInterface);
96 }
97 }
98
99 if (mStatus != NO_ERROR) {
100 return;
101 }
102 lStatus = init();
103 if (lStatus < 0) {
104 mStatus = lStatus;
105 goto Error;
106 }
107
108 setOffloaded(thread->type() == ThreadBase::OFFLOAD, thread->id());
109 ALOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface.get());
110
111 return;
112 Error:
113 mEffectInterface.clear();
114 ALOGV("Constructor Error %d", mStatus);
115 }
116
~EffectModule()117 AudioFlinger::EffectModule::~EffectModule()
118 {
119 ALOGV("Destructor %p", this);
120 if (mEffectInterface != 0) {
121 char uuidStr[64];
122 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
123 ALOGW("EffectModule %p destructor called with unreleased interface, effect %s",
124 this, uuidStr);
125 release_l();
126 }
127
128 }
129
addHandle(EffectHandle * handle)130 status_t AudioFlinger::EffectModule::addHandle(EffectHandle *handle)
131 {
132 status_t status;
133
134 Mutex::Autolock _l(mLock);
135 int priority = handle->priority();
136 size_t size = mHandles.size();
137 EffectHandle *controlHandle = NULL;
138 size_t i;
139 for (i = 0; i < size; i++) {
140 EffectHandle *h = mHandles[i];
141 if (h == NULL || h->disconnected()) {
142 continue;
143 }
144 // first non destroyed handle is considered in control
145 if (controlHandle == NULL) {
146 controlHandle = h;
147 }
148 if (h->priority() <= priority) {
149 break;
150 }
151 }
152 // if inserted in first place, move effect control from previous owner to this handle
153 if (i == 0) {
154 bool enabled = false;
155 if (controlHandle != NULL) {
156 enabled = controlHandle->enabled();
157 controlHandle->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
158 }
159 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
160 status = NO_ERROR;
161 } else {
162 status = ALREADY_EXISTS;
163 }
164 ALOGV("addHandle() %p added handle %p in position %zu", this, handle, i);
165 mHandles.insertAt(handle, i);
166 return status;
167 }
168
removeHandle(EffectHandle * handle)169 ssize_t AudioFlinger::EffectModule::removeHandle(EffectHandle *handle)
170 {
171 Mutex::Autolock _l(mLock);
172 return removeHandle_l(handle);
173 }
174
removeHandle_l(EffectHandle * handle)175 ssize_t AudioFlinger::EffectModule::removeHandle_l(EffectHandle *handle)
176 {
177 size_t size = mHandles.size();
178 size_t i;
179 for (i = 0; i < size; i++) {
180 if (mHandles[i] == handle) {
181 break;
182 }
183 }
184 if (i == size) {
185 ALOGW("%s %p handle not found %p", __FUNCTION__, this, handle);
186 return BAD_VALUE;
187 }
188 ALOGV("removeHandle_l() %p removed handle %p in position %zu", this, handle, i);
189
190 mHandles.removeAt(i);
191 // if removed from first place, move effect control from this handle to next in line
192 if (i == 0) {
193 EffectHandle *h = controlHandle_l();
194 if (h != NULL) {
195 h->setControl(true /*hasControl*/, true /*signal*/ , handle->enabled() /*enabled*/);
196 }
197 }
198
199 // Prevent calls to process() and other functions on effect interface from now on.
200 // The effect engine will be released by the destructor when the last strong reference on
201 // this object is released which can happen after next process is called.
202 if (mHandles.size() == 0 && !mPinned) {
203 mState = DESTROYED;
204 mEffectInterface->close();
205 }
206
207 return mHandles.size();
208 }
209
210 // must be called with EffectModule::mLock held
controlHandle_l()211 AudioFlinger::EffectHandle *AudioFlinger::EffectModule::controlHandle_l()
212 {
213 // the first valid handle in the list has control over the module
214 for (size_t i = 0; i < mHandles.size(); i++) {
215 EffectHandle *h = mHandles[i];
216 if (h != NULL && !h->disconnected()) {
217 return h;
218 }
219 }
220
221 return NULL;
222 }
223
224 // unsafe method called when the effect parent thread has been destroyed
disconnectHandle(EffectHandle * handle,bool unpinIfLast)225 ssize_t AudioFlinger::EffectModule::disconnectHandle(EffectHandle *handle, bool unpinIfLast)
226 {
227 ALOGV("disconnect() %p handle %p", this, handle);
228 Mutex::Autolock _l(mLock);
229 ssize_t numHandles = removeHandle_l(handle);
230 if ((numHandles == 0) && (!mPinned || unpinIfLast)) {
231 AudioSystem::unregisterEffect(mId);
232 sp<AudioFlinger> af = mAudioFlinger.promote();
233 if (af != 0) {
234 mLock.unlock();
235 af->updateOrphanEffectChains(this);
236 mLock.lock();
237 }
238 }
239 return numHandles;
240 }
241
updateState()242 bool AudioFlinger::EffectModule::updateState() {
243 Mutex::Autolock _l(mLock);
244
245 bool started = false;
246 switch (mState) {
247 case RESTART:
248 reset_l();
249 // FALL THROUGH
250
251 case STARTING:
252 // clear auxiliary effect input buffer for next accumulation
253 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
254 memset(mConfig.inputCfg.buffer.raw,
255 0,
256 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
257 }
258 if (start_l() == NO_ERROR) {
259 mState = ACTIVE;
260 started = true;
261 } else {
262 mState = IDLE;
263 }
264 break;
265 case STOPPING:
266 if (stop_l() == NO_ERROR) {
267 mDisableWaitCnt = mMaxDisableWaitCnt;
268 } else {
269 mDisableWaitCnt = 1; // will cause immediate transition to IDLE
270 }
271 mState = STOPPED;
272 break;
273 case STOPPED:
274 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
275 // turn off sequence.
276 if (--mDisableWaitCnt == 0) {
277 reset_l();
278 mState = IDLE;
279 }
280 break;
281 default: //IDLE , ACTIVE, DESTROYED
282 break;
283 }
284
285 return started;
286 }
287
process()288 void AudioFlinger::EffectModule::process()
289 {
290 Mutex::Autolock _l(mLock);
291
292 if (mState == DESTROYED || mEffectInterface == 0 || mInBuffer == 0 || mOutBuffer == 0) {
293 return;
294 }
295
296 const uint32_t inChannelCount =
297 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
298 const uint32_t outChannelCount =
299 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
300 const bool auxType =
301 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
302
303 // safeInputOutputSampleCount is 0 if the channel count between input and output
304 // buffers do not match. This prevents automatic accumulation or copying between the
305 // input and output effect buffers without an intermediary effect process.
306 // TODO: consider implementing channel conversion.
307 const size_t safeInputOutputSampleCount =
308 inChannelCount != outChannelCount ? 0
309 : outChannelCount * std::min(
310 mConfig.inputCfg.buffer.frameCount,
311 mConfig.outputCfg.buffer.frameCount);
312 const auto accumulateInputToOutput = [this, safeInputOutputSampleCount]() {
313 #ifdef FLOAT_EFFECT_CHAIN
314 accumulate_float(
315 mConfig.outputCfg.buffer.f32,
316 mConfig.inputCfg.buffer.f32,
317 safeInputOutputSampleCount);
318 #else
319 accumulate_i16(
320 mConfig.outputCfg.buffer.s16,
321 mConfig.inputCfg.buffer.s16,
322 safeInputOutputSampleCount);
323 #endif
324 };
325 const auto copyInputToOutput = [this, safeInputOutputSampleCount]() {
326 #ifdef FLOAT_EFFECT_CHAIN
327 memcpy(
328 mConfig.outputCfg.buffer.f32,
329 mConfig.inputCfg.buffer.f32,
330 safeInputOutputSampleCount * sizeof(*mConfig.outputCfg.buffer.f32));
331
332 #else
333 memcpy(
334 mConfig.outputCfg.buffer.s16,
335 mConfig.inputCfg.buffer.s16,
336 safeInputOutputSampleCount * sizeof(*mConfig.outputCfg.buffer.s16));
337 #endif
338 };
339
340 if (isProcessEnabled()) {
341 int ret;
342 if (isProcessImplemented()) {
343 if (auxType) {
344 // We overwrite the aux input buffer here and clear after processing.
345 // aux input is always mono.
346 #ifdef FLOAT_EFFECT_CHAIN
347 if (mSupportsFloat) {
348 #ifndef FLOAT_AUX
349 // Do in-place float conversion for auxiliary effect input buffer.
350 static_assert(sizeof(float) <= sizeof(int32_t),
351 "in-place conversion requires sizeof(float) <= sizeof(int32_t)");
352
353 memcpy_to_float_from_q4_27(
354 mConfig.inputCfg.buffer.f32,
355 mConfig.inputCfg.buffer.s32,
356 mConfig.inputCfg.buffer.frameCount);
357 #endif // !FLOAT_AUX
358 } else
359 #endif // FLOAT_EFFECT_CHAIN
360 {
361 #ifdef FLOAT_AUX
362 memcpy_to_i16_from_float(
363 mConfig.inputCfg.buffer.s16,
364 mConfig.inputCfg.buffer.f32,
365 mConfig.inputCfg.buffer.frameCount);
366 #else
367 memcpy_to_i16_from_q4_27(
368 mConfig.inputCfg.buffer.s16,
369 mConfig.inputCfg.buffer.s32,
370 mConfig.inputCfg.buffer.frameCount);
371 #endif
372 }
373 }
374 #ifdef FLOAT_EFFECT_CHAIN
375 sp<EffectBufferHalInterface> inBuffer = mInBuffer;
376 sp<EffectBufferHalInterface> outBuffer = mOutBuffer;
377
378 if (!auxType && mInChannelCountRequested != inChannelCount) {
379 adjust_channels(
380 inBuffer->audioBuffer()->f32, mInChannelCountRequested,
381 mInConversionBuffer->audioBuffer()->f32, inChannelCount,
382 sizeof(float),
383 sizeof(float)
384 * mInChannelCountRequested * mConfig.inputCfg.buffer.frameCount);
385 inBuffer = mInConversionBuffer;
386 }
387 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE
388 && mOutChannelCountRequested != outChannelCount) {
389 adjust_selected_channels(
390 outBuffer->audioBuffer()->f32, mOutChannelCountRequested,
391 mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
392 sizeof(float),
393 sizeof(float)
394 * mOutChannelCountRequested * mConfig.outputCfg.buffer.frameCount);
395 outBuffer = mOutConversionBuffer;
396 }
397 if (!mSupportsFloat) { // convert input to int16_t as effect doesn't support float.
398 if (!auxType) {
399 if (mInConversionBuffer.get() == nullptr) {
400 ALOGW("%s: mInConversionBuffer is null, bypassing", __func__);
401 goto data_bypass;
402 }
403 memcpy_to_i16_from_float(
404 mInConversionBuffer->audioBuffer()->s16,
405 inBuffer->audioBuffer()->f32,
406 inChannelCount * mConfig.inputCfg.buffer.frameCount);
407 inBuffer = mInConversionBuffer;
408 }
409 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
410 if (mOutConversionBuffer.get() == nullptr) {
411 ALOGW("%s: mOutConversionBuffer is null, bypassing", __func__);
412 goto data_bypass;
413 }
414 memcpy_to_i16_from_float(
415 mOutConversionBuffer->audioBuffer()->s16,
416 outBuffer->audioBuffer()->f32,
417 outChannelCount * mConfig.outputCfg.buffer.frameCount);
418 outBuffer = mOutConversionBuffer;
419 }
420 }
421 #endif
422 ret = mEffectInterface->process();
423 #ifdef FLOAT_EFFECT_CHAIN
424 if (!mSupportsFloat) { // convert output int16_t back to float.
425 sp<EffectBufferHalInterface> target =
426 mOutChannelCountRequested != outChannelCount
427 ? mOutConversionBuffer : mOutBuffer;
428
429 memcpy_to_float_from_i16(
430 target->audioBuffer()->f32,
431 mOutConversionBuffer->audioBuffer()->s16,
432 outChannelCount * mConfig.outputCfg.buffer.frameCount);
433 }
434 if (mOutChannelCountRequested != outChannelCount) {
435 adjust_selected_channels(mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
436 mOutBuffer->audioBuffer()->f32, mOutChannelCountRequested,
437 sizeof(float),
438 sizeof(float) * outChannelCount * mConfig.outputCfg.buffer.frameCount);
439 }
440 #endif
441 } else {
442 #ifdef FLOAT_EFFECT_CHAIN
443 data_bypass:
444 #endif
445 if (!auxType /* aux effects do not require data bypass */
446 && mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
447 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
448 accumulateInputToOutput();
449 } else {
450 copyInputToOutput();
451 }
452 }
453 ret = -ENODATA;
454 }
455
456 // force transition to IDLE state when engine is ready
457 if (mState == STOPPED && ret == -ENODATA) {
458 mDisableWaitCnt = 1;
459 }
460
461 // clear auxiliary effect input buffer for next accumulation
462 if (auxType) {
463 #ifdef FLOAT_AUX
464 const size_t size =
465 mConfig.inputCfg.buffer.frameCount * inChannelCount * sizeof(float);
466 #else
467 const size_t size =
468 mConfig.inputCfg.buffer.frameCount * inChannelCount * sizeof(int32_t);
469 #endif
470 memset(mConfig.inputCfg.buffer.raw, 0, size);
471 }
472 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
473 // mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw
474 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
475 // If an insert effect is idle and input buffer is different from output buffer,
476 // accumulate input onto output
477 sp<EffectChain> chain = mChain.promote();
478 if (chain.get() != nullptr && chain->activeTrackCnt() != 0) {
479 accumulateInputToOutput();
480 }
481 }
482 }
483
reset_l()484 void AudioFlinger::EffectModule::reset_l()
485 {
486 if (mStatus != NO_ERROR || mEffectInterface == 0) {
487 return;
488 }
489 mEffectInterface->command(EFFECT_CMD_RESET, 0, NULL, 0, NULL);
490 }
491
configure()492 status_t AudioFlinger::EffectModule::configure()
493 {
494 ALOGVV("configure() started");
495 status_t status;
496 sp<ThreadBase> thread;
497 uint32_t size;
498 audio_channel_mask_t channelMask;
499
500 if (mEffectInterface == 0) {
501 status = NO_INIT;
502 goto exit;
503 }
504
505 thread = mThread.promote();
506 if (thread == 0) {
507 status = DEAD_OBJECT;
508 goto exit;
509 }
510
511 // TODO: handle configuration of effects replacing track process
512 // TODO: handle configuration of input (record) SW effects above the HAL,
513 // similar to output EFFECT_FLAG_TYPE_INSERT/REPLACE,
514 // in which case input channel masks should be used here.
515 channelMask = thread->channelMask();
516 mConfig.inputCfg.channels = channelMask;
517 mConfig.outputCfg.channels = channelMask;
518
519 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
520 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_MONO) {
521 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
522 ALOGV("Overriding auxiliary effect input channels %#x as MONO",
523 mConfig.inputCfg.channels);
524 }
525 #ifndef MULTICHANNEL_EFFECT_CHAIN
526 if (mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
527 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
528 ALOGV("Overriding auxiliary effect output channels %#x as STEREO",
529 mConfig.outputCfg.channels);
530 }
531 #endif
532 } else {
533 #ifndef MULTICHANNEL_EFFECT_CHAIN
534 // TODO: Update this logic when multichannel effects are implemented.
535 // For offloaded tracks consider mono output as stereo for proper effect initialization
536 if (channelMask == AUDIO_CHANNEL_OUT_MONO) {
537 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
538 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
539 ALOGV("Overriding effect input and output as STEREO");
540 }
541 #endif
542 }
543 mInChannelCountRequested =
544 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
545 mOutChannelCountRequested =
546 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
547
548 mConfig.inputCfg.format = EFFECT_BUFFER_FORMAT;
549 mConfig.outputCfg.format = EFFECT_BUFFER_FORMAT;
550 mConfig.inputCfg.samplingRate = thread->sampleRate();
551 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
552 mConfig.inputCfg.bufferProvider.cookie = NULL;
553 mConfig.inputCfg.bufferProvider.getBuffer = NULL;
554 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
555 mConfig.outputCfg.bufferProvider.cookie = NULL;
556 mConfig.outputCfg.bufferProvider.getBuffer = NULL;
557 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
558 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
559 // Insert effect:
560 // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE,
561 // always overwrites output buffer: input buffer == output buffer
562 // - in other sessions:
563 // last effect in the chain accumulates in output buffer: input buffer != output buffer
564 // other effect: overwrites output buffer: input buffer == output buffer
565 // Auxiliary effect:
566 // accumulates in output buffer: input buffer != output buffer
567 // Therefore: accumulate <=> input buffer != output buffer
568 if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
569 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
570 } else {
571 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
572 }
573 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
574 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
575 mConfig.inputCfg.buffer.frameCount = thread->frameCount();
576 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
577
578 ALOGV("configure() %p thread %p buffer %p framecount %zu",
579 this, thread.get(), mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount);
580
581 status_t cmdStatus;
582 size = sizeof(int);
583 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
584 sizeof(mConfig),
585 &mConfig,
586 &size,
587 &cmdStatus);
588 if (status == NO_ERROR) {
589 status = cmdStatus;
590 }
591
592 #ifdef MULTICHANNEL_EFFECT_CHAIN
593 if (status != NO_ERROR &&
594 thread->isOutput() &&
595 (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
596 || mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO)) {
597 // Older effects may require exact STEREO position mask.
598 if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
599 && (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
600 ALOGV("Overriding effect input channels %#x as STEREO", mConfig.inputCfg.channels);
601 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
602 }
603 if (mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
604 ALOGV("Overriding effect output channels %#x as STEREO", mConfig.outputCfg.channels);
605 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
606 }
607 size = sizeof(int);
608 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
609 sizeof(mConfig),
610 &mConfig,
611 &size,
612 &cmdStatus);
613 if (status == NO_ERROR) {
614 status = cmdStatus;
615 }
616 }
617 #endif
618
619 #ifdef FLOAT_EFFECT_CHAIN
620 if (status == NO_ERROR) {
621 mSupportsFloat = true;
622 }
623
624 if (status != NO_ERROR) {
625 ALOGV("EFFECT_CMD_SET_CONFIG failed with float format, retry with int16_t.");
626 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
627 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
628 size = sizeof(int);
629 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
630 sizeof(mConfig),
631 &mConfig,
632 &size,
633 &cmdStatus);
634 if (status == NO_ERROR) {
635 status = cmdStatus;
636 }
637 if (status == NO_ERROR) {
638 mSupportsFloat = false;
639 ALOGVV("config worked with 16 bit");
640 } else {
641 ALOGE("%s failed %d with int16_t (as well as float)", __func__, status);
642 }
643 }
644 #endif
645
646 if (status == NO_ERROR) {
647 // Establish Buffer strategy
648 setInBuffer(mInBuffer);
649 setOutBuffer(mOutBuffer);
650
651 // Update visualizer latency
652 if (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) {
653 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
654 effect_param_t *p = (effect_param_t *)buf32;
655
656 p->psize = sizeof(uint32_t);
657 p->vsize = sizeof(uint32_t);
658 size = sizeof(int);
659 *(int32_t *)p->data = VISUALIZER_PARAM_LATENCY;
660
661 uint32_t latency = 0;
662 PlaybackThread *pbt = thread->mAudioFlinger->checkPlaybackThread_l(thread->mId);
663 if (pbt != NULL) {
664 latency = pbt->latency_l();
665 }
666
667 *((int32_t *)p->data + 1)= latency;
668 mEffectInterface->command(EFFECT_CMD_SET_PARAM,
669 sizeof(effect_param_t) + 8,
670 &buf32,
671 &size,
672 &cmdStatus);
673 }
674 }
675
676 // mConfig.outputCfg.buffer.frameCount cannot be zero.
677 mMaxDisableWaitCnt = (uint32_t)std::max(
678 (uint64_t)1, // mMaxDisableWaitCnt must be greater than zero.
679 (uint64_t)MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate
680 / ((uint64_t)1000 * mConfig.outputCfg.buffer.frameCount));
681
682 exit:
683 // TODO: consider clearing mConfig on error.
684 mStatus = status;
685 ALOGVV("configure ended");
686 return status;
687 }
688
init()689 status_t AudioFlinger::EffectModule::init()
690 {
691 Mutex::Autolock _l(mLock);
692 if (mEffectInterface == 0) {
693 return NO_INIT;
694 }
695 status_t cmdStatus;
696 uint32_t size = sizeof(status_t);
697 status_t status = mEffectInterface->command(EFFECT_CMD_INIT,
698 0,
699 NULL,
700 &size,
701 &cmdStatus);
702 if (status == 0) {
703 status = cmdStatus;
704 }
705 return status;
706 }
707
addEffectToHal_l()708 void AudioFlinger::EffectModule::addEffectToHal_l()
709 {
710 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
711 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
712 sp<ThreadBase> thread = mThread.promote();
713 if (thread != 0) {
714 sp<StreamHalInterface> stream = thread->stream();
715 if (stream != 0) {
716 status_t result = stream->addEffect(mEffectInterface);
717 ALOGE_IF(result != OK, "Error when adding effect: %d", result);
718 }
719 }
720 }
721 }
722
723 // start() must be called with PlaybackThread::mLock or EffectChain::mLock held
start()724 status_t AudioFlinger::EffectModule::start()
725 {
726 sp<EffectChain> chain;
727 status_t status;
728 {
729 Mutex::Autolock _l(mLock);
730 status = start_l();
731 if (status == NO_ERROR) {
732 chain = mChain.promote();
733 }
734 }
735 if (chain != 0) {
736 chain->resetVolume_l();
737 }
738 return status;
739 }
740
start_l()741 status_t AudioFlinger::EffectModule::start_l()
742 {
743 if (mEffectInterface == 0) {
744 return NO_INIT;
745 }
746 if (mStatus != NO_ERROR) {
747 return mStatus;
748 }
749 status_t cmdStatus;
750 uint32_t size = sizeof(status_t);
751 status_t status = mEffectInterface->command(EFFECT_CMD_ENABLE,
752 0,
753 NULL,
754 &size,
755 &cmdStatus);
756 if (status == 0) {
757 status = cmdStatus;
758 }
759 if (status == 0) {
760 addEffectToHal_l();
761 }
762 return status;
763 }
764
stop()765 status_t AudioFlinger::EffectModule::stop()
766 {
767 Mutex::Autolock _l(mLock);
768 return stop_l();
769 }
770
stop_l()771 status_t AudioFlinger::EffectModule::stop_l()
772 {
773 if (mEffectInterface == 0) {
774 return NO_INIT;
775 }
776 if (mStatus != NO_ERROR) {
777 return mStatus;
778 }
779 status_t cmdStatus = NO_ERROR;
780 uint32_t size = sizeof(status_t);
781 status_t status = mEffectInterface->command(EFFECT_CMD_DISABLE,
782 0,
783 NULL,
784 &size,
785 &cmdStatus);
786 if (status == NO_ERROR) {
787 status = cmdStatus;
788 }
789 if (status == NO_ERROR) {
790 status = remove_effect_from_hal_l();
791 }
792 return status;
793 }
794
795 // must be called with EffectChain::mLock held
release_l()796 void AudioFlinger::EffectModule::release_l()
797 {
798 if (mEffectInterface != 0) {
799 remove_effect_from_hal_l();
800 // release effect engine
801 mEffectInterface->close();
802 mEffectInterface.clear();
803 }
804 }
805
remove_effect_from_hal_l()806 status_t AudioFlinger::EffectModule::remove_effect_from_hal_l()
807 {
808 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
809 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
810 sp<ThreadBase> thread = mThread.promote();
811 if (thread != 0) {
812 sp<StreamHalInterface> stream = thread->stream();
813 if (stream != 0) {
814 status_t result = stream->removeEffect(mEffectInterface);
815 ALOGE_IF(result != OK, "Error when removing effect: %d", result);
816 }
817 }
818 }
819 return NO_ERROR;
820 }
821
822 // round up delta valid if value and divisor are positive.
823 template <typename T>
roundUpDelta(const T & value,const T & divisor)824 static T roundUpDelta(const T &value, const T &divisor) {
825 T remainder = value % divisor;
826 return remainder == 0 ? 0 : divisor - remainder;
827 }
828
command(uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)829 status_t AudioFlinger::EffectModule::command(uint32_t cmdCode,
830 uint32_t cmdSize,
831 void *pCmdData,
832 uint32_t *replySize,
833 void *pReplyData)
834 {
835 Mutex::Autolock _l(mLock);
836 ALOGVV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface.get());
837
838 if (mState == DESTROYED || mEffectInterface == 0) {
839 return NO_INIT;
840 }
841 if (mStatus != NO_ERROR) {
842 return mStatus;
843 }
844 if (cmdCode == EFFECT_CMD_GET_PARAM &&
845 (sizeof(effect_param_t) > cmdSize ||
846 ((effect_param_t *)pCmdData)->psize > cmdSize
847 - sizeof(effect_param_t))) {
848 android_errorWriteLog(0x534e4554, "32438594");
849 android_errorWriteLog(0x534e4554, "33003822");
850 return -EINVAL;
851 }
852 if (cmdCode == EFFECT_CMD_GET_PARAM &&
853 (*replySize < sizeof(effect_param_t) ||
854 ((effect_param_t *)pCmdData)->psize > *replySize - sizeof(effect_param_t))) {
855 android_errorWriteLog(0x534e4554, "29251553");
856 return -EINVAL;
857 }
858 if (cmdCode == EFFECT_CMD_GET_PARAM &&
859 (sizeof(effect_param_t) > *replySize
860 || ((effect_param_t *)pCmdData)->psize > *replySize
861 - sizeof(effect_param_t)
862 || ((effect_param_t *)pCmdData)->vsize > *replySize
863 - sizeof(effect_param_t)
864 - ((effect_param_t *)pCmdData)->psize
865 || roundUpDelta(((effect_param_t *)pCmdData)->psize, (uint32_t)sizeof(int)) >
866 *replySize
867 - sizeof(effect_param_t)
868 - ((effect_param_t *)pCmdData)->psize
869 - ((effect_param_t *)pCmdData)->vsize)) {
870 ALOGV("\tLVM_ERROR : EFFECT_CMD_GET_PARAM: reply size inconsistent");
871 android_errorWriteLog(0x534e4554, "32705438");
872 return -EINVAL;
873 }
874 if ((cmdCode == EFFECT_CMD_SET_PARAM
875 || cmdCode == EFFECT_CMD_SET_PARAM_DEFERRED) && // DEFERRED not generally used
876 (sizeof(effect_param_t) > cmdSize
877 || ((effect_param_t *)pCmdData)->psize > cmdSize
878 - sizeof(effect_param_t)
879 || ((effect_param_t *)pCmdData)->vsize > cmdSize
880 - sizeof(effect_param_t)
881 - ((effect_param_t *)pCmdData)->psize
882 || roundUpDelta(((effect_param_t *)pCmdData)->psize, (uint32_t)sizeof(int)) >
883 cmdSize
884 - sizeof(effect_param_t)
885 - ((effect_param_t *)pCmdData)->psize
886 - ((effect_param_t *)pCmdData)->vsize)) {
887 android_errorWriteLog(0x534e4554, "30204301");
888 return -EINVAL;
889 }
890 status_t status = mEffectInterface->command(cmdCode,
891 cmdSize,
892 pCmdData,
893 replySize,
894 pReplyData);
895 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
896 uint32_t size = (replySize == NULL) ? 0 : *replySize;
897 for (size_t i = 1; i < mHandles.size(); i++) {
898 EffectHandle *h = mHandles[i];
899 if (h != NULL && !h->disconnected()) {
900 h->commandExecuted(cmdCode, cmdSize, pCmdData, size, pReplyData);
901 }
902 }
903 }
904 return status;
905 }
906
setEnabled(bool enabled)907 status_t AudioFlinger::EffectModule::setEnabled(bool enabled)
908 {
909 Mutex::Autolock _l(mLock);
910 return setEnabled_l(enabled);
911 }
912
913 // must be called with EffectModule::mLock held
setEnabled_l(bool enabled)914 status_t AudioFlinger::EffectModule::setEnabled_l(bool enabled)
915 {
916
917 ALOGV("setEnabled %p enabled %d", this, enabled);
918
919 if (enabled != isEnabled()) {
920 status_t status = AudioSystem::setEffectEnabled(mId, enabled);
921 if (enabled && status != NO_ERROR) {
922 return status;
923 }
924
925 switch (mState) {
926 // going from disabled to enabled
927 case IDLE:
928 mState = STARTING;
929 break;
930 case STOPPED:
931 mState = RESTART;
932 break;
933 case STOPPING:
934 mState = ACTIVE;
935 break;
936
937 // going from enabled to disabled
938 case RESTART:
939 mState = STOPPED;
940 break;
941 case STARTING:
942 mState = IDLE;
943 break;
944 case ACTIVE:
945 mState = STOPPING;
946 break;
947 case DESTROYED:
948 return NO_ERROR; // simply ignore as we are being destroyed
949 }
950 for (size_t i = 1; i < mHandles.size(); i++) {
951 EffectHandle *h = mHandles[i];
952 if (h != NULL && !h->disconnected()) {
953 h->setEnabled(enabled);
954 }
955 }
956 }
957 return NO_ERROR;
958 }
959
isEnabled() const960 bool AudioFlinger::EffectModule::isEnabled() const
961 {
962 switch (mState) {
963 case RESTART:
964 case STARTING:
965 case ACTIVE:
966 return true;
967 case IDLE:
968 case STOPPING:
969 case STOPPED:
970 case DESTROYED:
971 default:
972 return false;
973 }
974 }
975
isProcessEnabled() const976 bool AudioFlinger::EffectModule::isProcessEnabled() const
977 {
978 if (mStatus != NO_ERROR) {
979 return false;
980 }
981
982 switch (mState) {
983 case RESTART:
984 case ACTIVE:
985 case STOPPING:
986 case STOPPED:
987 return true;
988 case IDLE:
989 case STARTING:
990 case DESTROYED:
991 default:
992 return false;
993 }
994 }
995
setInBuffer(const sp<EffectBufferHalInterface> & buffer)996 void AudioFlinger::EffectModule::setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
997 ALOGVV("setInBuffer %p",(&buffer));
998
999 // mConfig.inputCfg.buffer.frameCount may be zero if configure() is not called yet.
1000 if (buffer != 0) {
1001 mConfig.inputCfg.buffer.raw = buffer->audioBuffer()->raw;
1002 buffer->setFrameCount(mConfig.inputCfg.buffer.frameCount);
1003 } else {
1004 mConfig.inputCfg.buffer.raw = NULL;
1005 }
1006 mInBuffer = buffer;
1007 mEffectInterface->setInBuffer(buffer);
1008
1009 #ifdef FLOAT_EFFECT_CHAIN
1010 // aux effects do in place conversion to float - we don't allocate mInConversionBuffer.
1011 // Theoretically insert effects can also do in-place conversions (destroying
1012 // the original buffer) when the output buffer is identical to the input buffer,
1013 // but we don't optimize for it here.
1014 const bool auxType = (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
1015 const uint32_t inChannelCount =
1016 audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
1017 const bool formatMismatch = !mSupportsFloat || mInChannelCountRequested != inChannelCount;
1018 if (!auxType && formatMismatch && mInBuffer.get() != nullptr) {
1019 // we need to translate - create hidl shared buffer and intercept
1020 const size_t inFrameCount = mConfig.inputCfg.buffer.frameCount;
1021 // Use FCC_2 in case mInChannelCountRequested is mono and the effect is stereo.
1022 const uint32_t inChannels = std::max((uint32_t)FCC_2, mInChannelCountRequested);
1023 const size_t size = inChannels * inFrameCount * std::max(sizeof(int16_t), sizeof(float));
1024
1025 ALOGV("%s: setInBuffer updating for inChannels:%d inFrameCount:%zu total size:%zu",
1026 __func__, inChannels, inFrameCount, size);
1027
1028 if (size > 0 && (mInConversionBuffer.get() == nullptr
1029 || size > mInConversionBuffer->getSize())) {
1030 mInConversionBuffer.clear();
1031 ALOGV("%s: allocating mInConversionBuffer %zu", __func__, size);
1032 sp<AudioFlinger> audioFlinger = mAudioFlinger.promote();
1033 LOG_ALWAYS_FATAL_IF(audioFlinger == nullptr, "EM could not retrieved audioFlinger");
1034 (void)audioFlinger->mEffectsFactoryHal->allocateBuffer(size, &mInConversionBuffer);
1035 }
1036 if (mInConversionBuffer.get() != nullptr) {
1037 mInConversionBuffer->setFrameCount(inFrameCount);
1038 mEffectInterface->setInBuffer(mInConversionBuffer);
1039 } else if (size > 0) {
1040 ALOGE("%s cannot create mInConversionBuffer", __func__);
1041 }
1042 }
1043 #endif
1044 }
1045
setOutBuffer(const sp<EffectBufferHalInterface> & buffer)1046 void AudioFlinger::EffectModule::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
1047 ALOGVV("setOutBuffer %p",(&buffer));
1048
1049 // mConfig.outputCfg.buffer.frameCount may be zero if configure() is not called yet.
1050 if (buffer != 0) {
1051 mConfig.outputCfg.buffer.raw = buffer->audioBuffer()->raw;
1052 buffer->setFrameCount(mConfig.outputCfg.buffer.frameCount);
1053 } else {
1054 mConfig.outputCfg.buffer.raw = NULL;
1055 }
1056 mOutBuffer = buffer;
1057 mEffectInterface->setOutBuffer(buffer);
1058
1059 #ifdef FLOAT_EFFECT_CHAIN
1060 // Note: Any effect that does not accumulate does not need mOutConversionBuffer and
1061 // can do in-place conversion from int16_t to float. We don't optimize here.
1062 const uint32_t outChannelCount =
1063 audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
1064 const bool formatMismatch = !mSupportsFloat || mOutChannelCountRequested != outChannelCount;
1065 if (formatMismatch && mOutBuffer.get() != nullptr) {
1066 const size_t outFrameCount = mConfig.outputCfg.buffer.frameCount;
1067 // Use FCC_2 in case mOutChannelCountRequested is mono and the effect is stereo.
1068 const uint32_t outChannels = std::max((uint32_t)FCC_2, mOutChannelCountRequested);
1069 const size_t size = outChannels * outFrameCount * std::max(sizeof(int16_t), sizeof(float));
1070
1071 ALOGV("%s: setOutBuffer updating for outChannels:%d outFrameCount:%zu total size:%zu",
1072 __func__, outChannels, outFrameCount, size);
1073
1074 if (size > 0 && (mOutConversionBuffer.get() == nullptr
1075 || size > mOutConversionBuffer->getSize())) {
1076 mOutConversionBuffer.clear();
1077 ALOGV("%s: allocating mOutConversionBuffer %zu", __func__, size);
1078 sp<AudioFlinger> audioFlinger = mAudioFlinger.promote();
1079 LOG_ALWAYS_FATAL_IF(audioFlinger == nullptr, "EM could not retrieved audioFlinger");
1080 (void)audioFlinger->mEffectsFactoryHal->allocateBuffer(size, &mOutConversionBuffer);
1081 }
1082 if (mOutConversionBuffer.get() != nullptr) {
1083 mOutConversionBuffer->setFrameCount(outFrameCount);
1084 mEffectInterface->setOutBuffer(mOutConversionBuffer);
1085 } else if (size > 0) {
1086 ALOGE("%s cannot create mOutConversionBuffer", __func__);
1087 }
1088 }
1089 #endif
1090 }
1091
setVolume(uint32_t * left,uint32_t * right,bool controller)1092 status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller)
1093 {
1094 Mutex::Autolock _l(mLock);
1095 if (mStatus != NO_ERROR) {
1096 return mStatus;
1097 }
1098 status_t status = NO_ERROR;
1099 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
1100 // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set)
1101 if (isProcessEnabled() &&
1102 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
1103 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND)) {
1104 uint32_t volume[2];
1105 uint32_t *pVolume = NULL;
1106 uint32_t size = sizeof(volume);
1107 volume[0] = *left;
1108 volume[1] = *right;
1109 if (controller) {
1110 pVolume = volume;
1111 }
1112 status = mEffectInterface->command(EFFECT_CMD_SET_VOLUME,
1113 size,
1114 volume,
1115 &size,
1116 pVolume);
1117 if (controller && status == NO_ERROR && size == sizeof(volume)) {
1118 *left = volume[0];
1119 *right = volume[1];
1120 }
1121 }
1122 return status;
1123 }
1124
setDevice(audio_devices_t device)1125 status_t AudioFlinger::EffectModule::setDevice(audio_devices_t device)
1126 {
1127 if (device == AUDIO_DEVICE_NONE) {
1128 return NO_ERROR;
1129 }
1130
1131 Mutex::Autolock _l(mLock);
1132 if (mStatus != NO_ERROR) {
1133 return mStatus;
1134 }
1135 status_t status = NO_ERROR;
1136 if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
1137 status_t cmdStatus;
1138 uint32_t size = sizeof(status_t);
1139 uint32_t cmd = audio_is_output_devices(device) ? EFFECT_CMD_SET_DEVICE :
1140 EFFECT_CMD_SET_INPUT_DEVICE;
1141 status = mEffectInterface->command(cmd,
1142 sizeof(uint32_t),
1143 &device,
1144 &size,
1145 &cmdStatus);
1146 }
1147 return status;
1148 }
1149
setMode(audio_mode_t mode)1150 status_t AudioFlinger::EffectModule::setMode(audio_mode_t mode)
1151 {
1152 Mutex::Autolock _l(mLock);
1153 if (mStatus != NO_ERROR) {
1154 return mStatus;
1155 }
1156 status_t status = NO_ERROR;
1157 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
1158 status_t cmdStatus;
1159 uint32_t size = sizeof(status_t);
1160 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_MODE,
1161 sizeof(audio_mode_t),
1162 &mode,
1163 &size,
1164 &cmdStatus);
1165 if (status == NO_ERROR) {
1166 status = cmdStatus;
1167 }
1168 }
1169 return status;
1170 }
1171
setAudioSource(audio_source_t source)1172 status_t AudioFlinger::EffectModule::setAudioSource(audio_source_t source)
1173 {
1174 Mutex::Autolock _l(mLock);
1175 if (mStatus != NO_ERROR) {
1176 return mStatus;
1177 }
1178 status_t status = NO_ERROR;
1179 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_SOURCE_MASK) == EFFECT_FLAG_AUDIO_SOURCE_IND) {
1180 uint32_t size = 0;
1181 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_SOURCE,
1182 sizeof(audio_source_t),
1183 &source,
1184 &size,
1185 NULL);
1186 }
1187 return status;
1188 }
1189
setSuspended(bool suspended)1190 void AudioFlinger::EffectModule::setSuspended(bool suspended)
1191 {
1192 Mutex::Autolock _l(mLock);
1193 mSuspended = suspended;
1194 }
1195
suspended() const1196 bool AudioFlinger::EffectModule::suspended() const
1197 {
1198 Mutex::Autolock _l(mLock);
1199 return mSuspended;
1200 }
1201
purgeHandles()1202 bool AudioFlinger::EffectModule::purgeHandles()
1203 {
1204 bool enabled = false;
1205 Mutex::Autolock _l(mLock);
1206 for (size_t i = 0; i < mHandles.size(); i++) {
1207 EffectHandle *handle = mHandles[i];
1208 if (handle != NULL && !handle->disconnected()) {
1209 if (handle->hasControl()) {
1210 enabled = handle->enabled();
1211 }
1212 }
1213 }
1214 return enabled;
1215 }
1216
setOffloaded(bool offloaded,audio_io_handle_t io)1217 status_t AudioFlinger::EffectModule::setOffloaded(bool offloaded, audio_io_handle_t io)
1218 {
1219 Mutex::Autolock _l(mLock);
1220 if (mStatus != NO_ERROR) {
1221 return mStatus;
1222 }
1223 status_t status = NO_ERROR;
1224 if ((mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0) {
1225 status_t cmdStatus;
1226 uint32_t size = sizeof(status_t);
1227 effect_offload_param_t cmd;
1228
1229 cmd.isOffload = offloaded;
1230 cmd.ioHandle = io;
1231 status = mEffectInterface->command(EFFECT_CMD_OFFLOAD,
1232 sizeof(effect_offload_param_t),
1233 &cmd,
1234 &size,
1235 &cmdStatus);
1236 if (status == NO_ERROR) {
1237 status = cmdStatus;
1238 }
1239 mOffloaded = (status == NO_ERROR) ? offloaded : false;
1240 } else {
1241 if (offloaded) {
1242 status = INVALID_OPERATION;
1243 }
1244 mOffloaded = false;
1245 }
1246 ALOGV("setOffloaded() offloaded %d io %d status %d", offloaded, io, status);
1247 return status;
1248 }
1249
isOffloaded() const1250 bool AudioFlinger::EffectModule::isOffloaded() const
1251 {
1252 Mutex::Autolock _l(mLock);
1253 return mOffloaded;
1254 }
1255
effectFlagsToString(uint32_t flags)1256 String8 effectFlagsToString(uint32_t flags) {
1257 String8 s;
1258
1259 s.append("conn. mode: ");
1260 switch (flags & EFFECT_FLAG_TYPE_MASK) {
1261 case EFFECT_FLAG_TYPE_INSERT: s.append("insert"); break;
1262 case EFFECT_FLAG_TYPE_AUXILIARY: s.append("auxiliary"); break;
1263 case EFFECT_FLAG_TYPE_REPLACE: s.append("replace"); break;
1264 case EFFECT_FLAG_TYPE_PRE_PROC: s.append("preproc"); break;
1265 case EFFECT_FLAG_TYPE_POST_PROC: s.append("postproc"); break;
1266 default: s.append("unknown/reserved"); break;
1267 }
1268 s.append(", ");
1269
1270 s.append("insert pref: ");
1271 switch (flags & EFFECT_FLAG_INSERT_MASK) {
1272 case EFFECT_FLAG_INSERT_ANY: s.append("any"); break;
1273 case EFFECT_FLAG_INSERT_FIRST: s.append("first"); break;
1274 case EFFECT_FLAG_INSERT_LAST: s.append("last"); break;
1275 case EFFECT_FLAG_INSERT_EXCLUSIVE: s.append("exclusive"); break;
1276 default: s.append("unknown/reserved"); break;
1277 }
1278 s.append(", ");
1279
1280 s.append("volume mgmt: ");
1281 switch (flags & EFFECT_FLAG_VOLUME_MASK) {
1282 case EFFECT_FLAG_VOLUME_NONE: s.append("none"); break;
1283 case EFFECT_FLAG_VOLUME_CTRL: s.append("implements control"); break;
1284 case EFFECT_FLAG_VOLUME_IND: s.append("requires indication"); break;
1285 default: s.append("unknown/reserved"); break;
1286 }
1287 s.append(", ");
1288
1289 uint32_t devind = flags & EFFECT_FLAG_DEVICE_MASK;
1290 if (devind) {
1291 s.append("device indication: ");
1292 switch (devind) {
1293 case EFFECT_FLAG_DEVICE_IND: s.append("requires updates"); break;
1294 default: s.append("unknown/reserved"); break;
1295 }
1296 s.append(", ");
1297 }
1298
1299 s.append("input mode: ");
1300 switch (flags & EFFECT_FLAG_INPUT_MASK) {
1301 case EFFECT_FLAG_INPUT_DIRECT: s.append("direct"); break;
1302 case EFFECT_FLAG_INPUT_PROVIDER: s.append("provider"); break;
1303 case EFFECT_FLAG_INPUT_BOTH: s.append("direct+provider"); break;
1304 default: s.append("not set"); break;
1305 }
1306 s.append(", ");
1307
1308 s.append("output mode: ");
1309 switch (flags & EFFECT_FLAG_OUTPUT_MASK) {
1310 case EFFECT_FLAG_OUTPUT_DIRECT: s.append("direct"); break;
1311 case EFFECT_FLAG_OUTPUT_PROVIDER: s.append("provider"); break;
1312 case EFFECT_FLAG_OUTPUT_BOTH: s.append("direct+provider"); break;
1313 default: s.append("not set"); break;
1314 }
1315 s.append(", ");
1316
1317 uint32_t accel = flags & EFFECT_FLAG_HW_ACC_MASK;
1318 if (accel) {
1319 s.append("hardware acceleration: ");
1320 switch (accel) {
1321 case EFFECT_FLAG_HW_ACC_SIMPLE: s.append("non-tunneled"); break;
1322 case EFFECT_FLAG_HW_ACC_TUNNEL: s.append("tunneled"); break;
1323 default: s.append("unknown/reserved"); break;
1324 }
1325 s.append(", ");
1326 }
1327
1328 uint32_t modeind = flags & EFFECT_FLAG_AUDIO_MODE_MASK;
1329 if (modeind) {
1330 s.append("mode indication: ");
1331 switch (modeind) {
1332 case EFFECT_FLAG_AUDIO_MODE_IND: s.append("required"); break;
1333 default: s.append("unknown/reserved"); break;
1334 }
1335 s.append(", ");
1336 }
1337
1338 uint32_t srcind = flags & EFFECT_FLAG_AUDIO_SOURCE_MASK;
1339 if (srcind) {
1340 s.append("source indication: ");
1341 switch (srcind) {
1342 case EFFECT_FLAG_AUDIO_SOURCE_IND: s.append("required"); break;
1343 default: s.append("unknown/reserved"); break;
1344 }
1345 s.append(", ");
1346 }
1347
1348 if (flags & EFFECT_FLAG_OFFLOAD_MASK) {
1349 s.append("offloadable, ");
1350 }
1351
1352 int len = s.length();
1353 if (s.length() > 2) {
1354 (void) s.lockBuffer(len);
1355 s.unlockBuffer(len - 2);
1356 }
1357 return s;
1358 }
1359
dumpInOutBuffer(bool isInput,const sp<EffectBufferHalInterface> & buffer)1360 static std::string dumpInOutBuffer(bool isInput, const sp<EffectBufferHalInterface> &buffer) {
1361 std::stringstream ss;
1362
1363 if (buffer.get() == nullptr) {
1364 return "nullptr"; // make different than below
1365 } else if (buffer->externalData() != nullptr) {
1366 ss << (isInput ? buffer->externalData() : buffer->audioBuffer()->raw)
1367 << " -> "
1368 << (isInput ? buffer->audioBuffer()->raw : buffer->externalData());
1369 } else {
1370 ss << buffer->audioBuffer()->raw;
1371 }
1372 return ss.str();
1373 }
1374
dump(int fd,const Vector<String16> & args __unused)1375 void AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args __unused)
1376 {
1377 String8 result;
1378
1379 result.appendFormat("\tEffect ID %d:\n", mId);
1380
1381 bool locked = AudioFlinger::dumpTryLock(mLock);
1382 // failed to lock - AudioFlinger is probably deadlocked
1383 if (!locked) {
1384 result.append("\t\tCould not lock Fx mutex:\n");
1385 }
1386
1387 result.append("\t\tSession Status State Engine:\n");
1388 result.appendFormat("\t\t%05d %03d %03d %p\n",
1389 mSessionId, mStatus, mState, mEffectInterface.get());
1390
1391 result.append("\t\tDescriptor:\n");
1392 char uuidStr[64];
1393 AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
1394 result.appendFormat("\t\t- UUID: %s\n", uuidStr);
1395 AudioEffect::guidToString(&mDescriptor.type, uuidStr, sizeof(uuidStr));
1396 result.appendFormat("\t\t- TYPE: %s\n", uuidStr);
1397 result.appendFormat("\t\t- apiVersion: %08X\n\t\t- flags: %08X (%s)\n",
1398 mDescriptor.apiVersion,
1399 mDescriptor.flags,
1400 effectFlagsToString(mDescriptor.flags).string());
1401 result.appendFormat("\t\t- name: %s\n",
1402 mDescriptor.name);
1403
1404 result.appendFormat("\t\t- implementor: %s\n",
1405 mDescriptor.implementor);
1406
1407 result.appendFormat("\t\t- data: %s\n", mSupportsFloat ? "float" : "int16");
1408
1409 result.append("\t\t- Input configuration:\n");
1410 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
1411 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
1412 mConfig.inputCfg.buffer.raw,
1413 mConfig.inputCfg.buffer.frameCount,
1414 mConfig.inputCfg.samplingRate,
1415 mConfig.inputCfg.channels,
1416 mConfig.inputCfg.format,
1417 formatToString((audio_format_t)mConfig.inputCfg.format).c_str());
1418
1419 result.append("\t\t- Output configuration:\n");
1420 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
1421 result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
1422 mConfig.outputCfg.buffer.raw,
1423 mConfig.outputCfg.buffer.frameCount,
1424 mConfig.outputCfg.samplingRate,
1425 mConfig.outputCfg.channels,
1426 mConfig.outputCfg.format,
1427 formatToString((audio_format_t)mConfig.outputCfg.format).c_str());
1428
1429 #ifdef FLOAT_EFFECT_CHAIN
1430
1431 result.appendFormat("\t\t- HAL buffers:\n"
1432 "\t\t\tIn(%s) InConversion(%s) Out(%s) OutConversion(%s)\n",
1433 dumpInOutBuffer(true /* isInput */, mInBuffer).c_str(),
1434 dumpInOutBuffer(true /* isInput */, mInConversionBuffer).c_str(),
1435 dumpInOutBuffer(false /* isInput */, mOutBuffer).c_str(),
1436 dumpInOutBuffer(false /* isInput */, mOutConversionBuffer).c_str());
1437 #endif
1438
1439 result.appendFormat("\t\t%zu Clients:\n", mHandles.size());
1440 result.append("\t\t\t Pid Priority Ctrl Locked client server\n");
1441 char buffer[256];
1442 for (size_t i = 0; i < mHandles.size(); ++i) {
1443 EffectHandle *handle = mHandles[i];
1444 if (handle != NULL && !handle->disconnected()) {
1445 handle->dumpToBuffer(buffer, sizeof(buffer));
1446 result.append(buffer);
1447 }
1448 }
1449
1450 write(fd, result.string(), result.length());
1451
1452 if (locked) {
1453 mLock.unlock();
1454 }
1455 }
1456
1457 // ----------------------------------------------------------------------------
1458 // EffectHandle implementation
1459 // ----------------------------------------------------------------------------
1460
1461 #undef LOG_TAG
1462 #define LOG_TAG "AudioFlinger::EffectHandle"
1463
EffectHandle(const sp<EffectModule> & effect,const sp<AudioFlinger::Client> & client,const sp<IEffectClient> & effectClient,int32_t priority)1464 AudioFlinger::EffectHandle::EffectHandle(const sp<EffectModule>& effect,
1465 const sp<AudioFlinger::Client>& client,
1466 const sp<IEffectClient>& effectClient,
1467 int32_t priority)
1468 : BnEffect(),
1469 mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL),
1470 mPriority(priority), mHasControl(false), mEnabled(false), mDisconnected(false)
1471 {
1472 ALOGV("constructor %p", this);
1473
1474 if (client == 0) {
1475 return;
1476 }
1477 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
1478 mCblkMemory = client->heap()->allocate(EFFECT_PARAM_BUFFER_SIZE + bufOffset);
1479 if (mCblkMemory == 0 ||
1480 (mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->pointer())) == NULL) {
1481 ALOGE("not enough memory for Effect size=%zu", EFFECT_PARAM_BUFFER_SIZE +
1482 sizeof(effect_param_cblk_t));
1483 mCblkMemory.clear();
1484 return;
1485 }
1486 new(mCblk) effect_param_cblk_t();
1487 mBuffer = (uint8_t *)mCblk + bufOffset;
1488 }
1489
~EffectHandle()1490 AudioFlinger::EffectHandle::~EffectHandle()
1491 {
1492 ALOGV("Destructor %p", this);
1493 disconnect(false);
1494 }
1495
initCheck()1496 status_t AudioFlinger::EffectHandle::initCheck()
1497 {
1498 return mClient == 0 || mCblkMemory != 0 ? OK : NO_MEMORY;
1499 }
1500
enable()1501 status_t AudioFlinger::EffectHandle::enable()
1502 {
1503 AutoMutex _l(mLock);
1504 ALOGV("enable %p", this);
1505 sp<EffectModule> effect = mEffect.promote();
1506 if (effect == 0 || mDisconnected) {
1507 return DEAD_OBJECT;
1508 }
1509 if (!mHasControl) {
1510 return INVALID_OPERATION;
1511 }
1512
1513 if (mEnabled) {
1514 return NO_ERROR;
1515 }
1516
1517 mEnabled = true;
1518
1519 sp<ThreadBase> thread = effect->thread().promote();
1520 if (thread != 0) {
1521 thread->checkSuspendOnEffectEnabled(effect, true, effect->sessionId());
1522 }
1523
1524 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled
1525 if (effect->suspended()) {
1526 return NO_ERROR;
1527 }
1528
1529 status_t status = effect->setEnabled(true);
1530 if (status != NO_ERROR) {
1531 if (thread != 0) {
1532 thread->checkSuspendOnEffectEnabled(effect, false, effect->sessionId());
1533 }
1534 mEnabled = false;
1535 } else {
1536 if (thread != 0) {
1537 if (thread->type() == ThreadBase::OFFLOAD || thread->type() == ThreadBase::MMAP) {
1538 Mutex::Autolock _l(thread->mLock);
1539 thread->broadcast_l();
1540 }
1541 if (!effect->isOffloadable()) {
1542 if (thread->type() == ThreadBase::OFFLOAD) {
1543 PlaybackThread *t = (PlaybackThread *)thread.get();
1544 t->invalidateTracks(AUDIO_STREAM_MUSIC);
1545 }
1546 if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
1547 thread->mAudioFlinger->onNonOffloadableGlobalEffectEnable();
1548 }
1549 }
1550 }
1551 }
1552 return status;
1553 }
1554
disable()1555 status_t AudioFlinger::EffectHandle::disable()
1556 {
1557 ALOGV("disable %p", this);
1558 AutoMutex _l(mLock);
1559 sp<EffectModule> effect = mEffect.promote();
1560 if (effect == 0 || mDisconnected) {
1561 return DEAD_OBJECT;
1562 }
1563 if (!mHasControl) {
1564 return INVALID_OPERATION;
1565 }
1566
1567 if (!mEnabled) {
1568 return NO_ERROR;
1569 }
1570 mEnabled = false;
1571
1572 if (effect->suspended()) {
1573 return NO_ERROR;
1574 }
1575
1576 status_t status = effect->setEnabled(false);
1577
1578 sp<ThreadBase> thread = effect->thread().promote();
1579 if (thread != 0) {
1580 thread->checkSuspendOnEffectEnabled(effect, false, effect->sessionId());
1581 if (thread->type() == ThreadBase::OFFLOAD || thread->type() == ThreadBase::MMAP) {
1582 Mutex::Autolock _l(thread->mLock);
1583 thread->broadcast_l();
1584 }
1585 }
1586
1587 return status;
1588 }
1589
disconnect()1590 void AudioFlinger::EffectHandle::disconnect()
1591 {
1592 ALOGV("%s %p", __FUNCTION__, this);
1593 disconnect(true);
1594 }
1595
disconnect(bool unpinIfLast)1596 void AudioFlinger::EffectHandle::disconnect(bool unpinIfLast)
1597 {
1598 AutoMutex _l(mLock);
1599 ALOGV("disconnect(%s) %p", unpinIfLast ? "true" : "false", this);
1600 if (mDisconnected) {
1601 if (unpinIfLast) {
1602 android_errorWriteLog(0x534e4554, "32707507");
1603 }
1604 return;
1605 }
1606 mDisconnected = true;
1607 sp<ThreadBase> thread;
1608 {
1609 sp<EffectModule> effect = mEffect.promote();
1610 if (effect != 0) {
1611 thread = effect->thread().promote();
1612 }
1613 }
1614 if (thread != 0) {
1615 thread->disconnectEffectHandle(this, unpinIfLast);
1616 } else {
1617 // try to cleanup as much as we can
1618 sp<EffectModule> effect = mEffect.promote();
1619 if (effect != 0 && effect->disconnectHandle(this, unpinIfLast) > 0) {
1620 ALOGW("%s Effect handle %p disconnected after thread destruction", __FUNCTION__, this);
1621 }
1622 }
1623
1624 if (mClient != 0) {
1625 if (mCblk != NULL) {
1626 // unlike ~TrackBase(), mCblk is never a local new, so don't delete
1627 mCblk->~effect_param_cblk_t(); // destroy our shared-structure.
1628 }
1629 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
1630 // Client destructor must run with AudioFlinger client mutex locked
1631 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
1632 mClient.clear();
1633 }
1634 }
1635
command(uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)1636 status_t AudioFlinger::EffectHandle::command(uint32_t cmdCode,
1637 uint32_t cmdSize,
1638 void *pCmdData,
1639 uint32_t *replySize,
1640 void *pReplyData)
1641 {
1642 ALOGVV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
1643 cmdCode, mHasControl, mEffect.unsafe_get());
1644
1645 // reject commands reserved for internal use by audio framework if coming from outside
1646 // of audioserver
1647 switch(cmdCode) {
1648 case EFFECT_CMD_ENABLE:
1649 case EFFECT_CMD_DISABLE:
1650 case EFFECT_CMD_SET_PARAM:
1651 case EFFECT_CMD_SET_PARAM_DEFERRED:
1652 case EFFECT_CMD_SET_PARAM_COMMIT:
1653 case EFFECT_CMD_GET_PARAM:
1654 break;
1655 default:
1656 if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY) {
1657 break;
1658 }
1659 android_errorWriteLog(0x534e4554, "62019992");
1660 return BAD_VALUE;
1661 }
1662
1663 if (cmdCode == EFFECT_CMD_ENABLE) {
1664 if (*replySize < sizeof(int)) {
1665 android_errorWriteLog(0x534e4554, "32095713");
1666 return BAD_VALUE;
1667 }
1668 *(int *)pReplyData = NO_ERROR;
1669 *replySize = sizeof(int);
1670 return enable();
1671 } else if (cmdCode == EFFECT_CMD_DISABLE) {
1672 if (*replySize < sizeof(int)) {
1673 android_errorWriteLog(0x534e4554, "32095713");
1674 return BAD_VALUE;
1675 }
1676 *(int *)pReplyData = NO_ERROR;
1677 *replySize = sizeof(int);
1678 return disable();
1679 }
1680
1681 AutoMutex _l(mLock);
1682 sp<EffectModule> effect = mEffect.promote();
1683 if (effect == 0 || mDisconnected) {
1684 return DEAD_OBJECT;
1685 }
1686 // only get parameter command is permitted for applications not controlling the effect
1687 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
1688 return INVALID_OPERATION;
1689 }
1690 if (mClient == 0) {
1691 return INVALID_OPERATION;
1692 }
1693
1694 // handle commands that are not forwarded transparently to effect engine
1695 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
1696 if (*replySize < sizeof(int)) {
1697 android_errorWriteLog(0x534e4554, "32095713");
1698 return BAD_VALUE;
1699 }
1700 *(int *)pReplyData = NO_ERROR;
1701 *replySize = sizeof(int);
1702
1703 // No need to trylock() here as this function is executed in the binder thread serving a
1704 // particular client process: no risk to block the whole media server process or mixer
1705 // threads if we are stuck here
1706 Mutex::Autolock _l(mCblk->lock);
1707 // keep local copy of index in case of client corruption b/32220769
1708 const uint32_t clientIndex = mCblk->clientIndex;
1709 const uint32_t serverIndex = mCblk->serverIndex;
1710 if (clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
1711 serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
1712 mCblk->serverIndex = 0;
1713 mCblk->clientIndex = 0;
1714 return BAD_VALUE;
1715 }
1716 status_t status = NO_ERROR;
1717 effect_param_t *param = NULL;
1718 for (uint32_t index = serverIndex; index < clientIndex;) {
1719 int *p = (int *)(mBuffer + index);
1720 const int size = *p++;
1721 if (size < 0
1722 || size > EFFECT_PARAM_BUFFER_SIZE
1723 || ((uint8_t *)p + size) > mBuffer + clientIndex) {
1724 ALOGW("command(): invalid parameter block size");
1725 status = BAD_VALUE;
1726 break;
1727 }
1728
1729 // copy to local memory in case of client corruption b/32220769
1730 param = (effect_param_t *)realloc(param, size);
1731 if (param == NULL) {
1732 ALOGW("command(): out of memory");
1733 status = NO_MEMORY;
1734 break;
1735 }
1736 memcpy(param, p, size);
1737
1738 int reply = 0;
1739 uint32_t rsize = sizeof(reply);
1740 status_t ret = effect->command(EFFECT_CMD_SET_PARAM,
1741 size,
1742 param,
1743 &rsize,
1744 &reply);
1745
1746 // verify shared memory: server index shouldn't change; client index can't go back.
1747 if (serverIndex != mCblk->serverIndex
1748 || clientIndex > mCblk->clientIndex) {
1749 android_errorWriteLog(0x534e4554, "32220769");
1750 status = BAD_VALUE;
1751 break;
1752 }
1753
1754 // stop at first error encountered
1755 if (ret != NO_ERROR) {
1756 status = ret;
1757 *(int *)pReplyData = reply;
1758 break;
1759 } else if (reply != NO_ERROR) {
1760 *(int *)pReplyData = reply;
1761 break;
1762 }
1763 index += size;
1764 }
1765 free(param);
1766 mCblk->serverIndex = 0;
1767 mCblk->clientIndex = 0;
1768 return status;
1769 }
1770
1771 return effect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
1772 }
1773
setControl(bool hasControl,bool signal,bool enabled)1774 void AudioFlinger::EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
1775 {
1776 ALOGV("setControl %p control %d", this, hasControl);
1777
1778 mHasControl = hasControl;
1779 mEnabled = enabled;
1780
1781 if (signal && mEffectClient != 0) {
1782 mEffectClient->controlStatusChanged(hasControl);
1783 }
1784 }
1785
commandExecuted(uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t replySize,void * pReplyData)1786 void AudioFlinger::EffectHandle::commandExecuted(uint32_t cmdCode,
1787 uint32_t cmdSize,
1788 void *pCmdData,
1789 uint32_t replySize,
1790 void *pReplyData)
1791 {
1792 if (mEffectClient != 0) {
1793 mEffectClient->commandExecuted(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
1794 }
1795 }
1796
1797
1798
setEnabled(bool enabled)1799 void AudioFlinger::EffectHandle::setEnabled(bool enabled)
1800 {
1801 if (mEffectClient != 0) {
1802 mEffectClient->enableStatusChanged(enabled);
1803 }
1804 }
1805
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)1806 status_t AudioFlinger::EffectHandle::onTransact(
1807 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1808 {
1809 return BnEffect::onTransact(code, data, reply, flags);
1810 }
1811
1812
dumpToBuffer(char * buffer,size_t size)1813 void AudioFlinger::EffectHandle::dumpToBuffer(char* buffer, size_t size)
1814 {
1815 bool locked = mCblk != NULL && AudioFlinger::dumpTryLock(mCblk->lock);
1816
1817 snprintf(buffer, size, "\t\t\t%5d %5d %3s %3s %5u %5u\n",
1818 (mClient == 0) ? getpid_cached : mClient->pid(),
1819 mPriority,
1820 mHasControl ? "yes" : "no",
1821 locked ? "yes" : "no",
1822 mCblk ? mCblk->clientIndex : 0,
1823 mCblk ? mCblk->serverIndex : 0
1824 );
1825
1826 if (locked) {
1827 mCblk->lock.unlock();
1828 }
1829 }
1830
1831 #undef LOG_TAG
1832 #define LOG_TAG "AudioFlinger::EffectChain"
1833
EffectChain(ThreadBase * thread,audio_session_t sessionId)1834 AudioFlinger::EffectChain::EffectChain(ThreadBase *thread,
1835 audio_session_t sessionId)
1836 : mThread(thread), mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
1837 mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
1838 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX)
1839 {
1840 mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
1841 if (thread == NULL) {
1842 return;
1843 }
1844 mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
1845 thread->frameCount();
1846 }
1847
~EffectChain()1848 AudioFlinger::EffectChain::~EffectChain()
1849 {
1850 }
1851
1852 // getEffectFromDesc_l() must be called with ThreadBase::mLock held
getEffectFromDesc_l(effect_descriptor_t * descriptor)1853 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromDesc_l(
1854 effect_descriptor_t *descriptor)
1855 {
1856 size_t size = mEffects.size();
1857
1858 for (size_t i = 0; i < size; i++) {
1859 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
1860 return mEffects[i];
1861 }
1862 }
1863 return 0;
1864 }
1865
1866 // getEffectFromId_l() must be called with ThreadBase::mLock held
getEffectFromId_l(int id)1867 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromId_l(int id)
1868 {
1869 size_t size = mEffects.size();
1870
1871 for (size_t i = 0; i < size; i++) {
1872 // by convention, return first effect if id provided is 0 (0 is never a valid id)
1873 if (id == 0 || mEffects[i]->id() == id) {
1874 return mEffects[i];
1875 }
1876 }
1877 return 0;
1878 }
1879
1880 // getEffectFromType_l() must be called with ThreadBase::mLock held
getEffectFromType_l(const effect_uuid_t * type)1881 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromType_l(
1882 const effect_uuid_t *type)
1883 {
1884 size_t size = mEffects.size();
1885
1886 for (size_t i = 0; i < size; i++) {
1887 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
1888 return mEffects[i];
1889 }
1890 }
1891 return 0;
1892 }
1893
clearInputBuffer()1894 void AudioFlinger::EffectChain::clearInputBuffer()
1895 {
1896 Mutex::Autolock _l(mLock);
1897 sp<ThreadBase> thread = mThread.promote();
1898 if (thread == 0) {
1899 ALOGW("clearInputBuffer(): cannot promote mixer thread");
1900 return;
1901 }
1902 clearInputBuffer_l(thread);
1903 }
1904
1905 // Must be called with EffectChain::mLock locked
clearInputBuffer_l(const sp<ThreadBase> & thread)1906 void AudioFlinger::EffectChain::clearInputBuffer_l(const sp<ThreadBase>& thread)
1907 {
1908 if (mInBuffer == NULL) {
1909 return;
1910 }
1911 const size_t frameSize =
1912 audio_bytes_per_sample(EFFECT_BUFFER_FORMAT) * thread->channelCount();
1913
1914 memset(mInBuffer->audioBuffer()->raw, 0, thread->frameCount() * frameSize);
1915 mInBuffer->commit();
1916 }
1917
1918 // Must be called with EffectChain::mLock locked
process_l()1919 void AudioFlinger::EffectChain::process_l()
1920 {
1921 sp<ThreadBase> thread = mThread.promote();
1922 if (thread == 0) {
1923 ALOGW("process_l(): cannot promote mixer thread");
1924 return;
1925 }
1926 bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) ||
1927 (mSessionId == AUDIO_SESSION_OUTPUT_STAGE);
1928 // never process effects when:
1929 // - on an OFFLOAD thread
1930 // - no more tracks are on the session and the effect tail has been rendered
1931 bool doProcess = (thread->type() != ThreadBase::OFFLOAD)
1932 && (thread->type() != ThreadBase::MMAP);
1933 if (!isGlobalSession) {
1934 bool tracksOnSession = (trackCnt() != 0);
1935
1936 if (!tracksOnSession && mTailBufferCount == 0) {
1937 doProcess = false;
1938 }
1939
1940 if (activeTrackCnt() == 0) {
1941 // if no track is active and the effect tail has not been rendered,
1942 // the input buffer must be cleared here as the mixer process will not do it
1943 if (tracksOnSession || mTailBufferCount > 0) {
1944 clearInputBuffer_l(thread);
1945 if (mTailBufferCount > 0) {
1946 mTailBufferCount--;
1947 }
1948 }
1949 }
1950 }
1951
1952 size_t size = mEffects.size();
1953 if (doProcess) {
1954 // Only the input and output buffers of the chain can be external,
1955 // and 'update' / 'commit' do nothing for allocated buffers, thus
1956 // it's not needed to consider any other buffers here.
1957 mInBuffer->update();
1958 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
1959 mOutBuffer->update();
1960 }
1961 for (size_t i = 0; i < size; i++) {
1962 mEffects[i]->process();
1963 }
1964 mInBuffer->commit();
1965 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
1966 mOutBuffer->commit();
1967 }
1968 }
1969 bool doResetVolume = false;
1970 for (size_t i = 0; i < size; i++) {
1971 doResetVolume = mEffects[i]->updateState() || doResetVolume;
1972 }
1973 if (doResetVolume) {
1974 resetVolume_l();
1975 }
1976 }
1977
1978 // createEffect_l() must be called with ThreadBase::mLock held
createEffect_l(sp<EffectModule> & effect,ThreadBase * thread,effect_descriptor_t * desc,int id,audio_session_t sessionId,bool pinned)1979 status_t AudioFlinger::EffectChain::createEffect_l(sp<EffectModule>& effect,
1980 ThreadBase *thread,
1981 effect_descriptor_t *desc,
1982 int id,
1983 audio_session_t sessionId,
1984 bool pinned)
1985 {
1986 Mutex::Autolock _l(mLock);
1987 effect = new EffectModule(thread, this, desc, id, sessionId, pinned);
1988 status_t lStatus = effect->status();
1989 if (lStatus == NO_ERROR) {
1990 lStatus = addEffect_ll(effect);
1991 }
1992 if (lStatus != NO_ERROR) {
1993 effect.clear();
1994 }
1995 return lStatus;
1996 }
1997
1998 // addEffect_l() must be called with ThreadBase::mLock held
addEffect_l(const sp<EffectModule> & effect)1999 status_t AudioFlinger::EffectChain::addEffect_l(const sp<EffectModule>& effect)
2000 {
2001 Mutex::Autolock _l(mLock);
2002 return addEffect_ll(effect);
2003 }
2004 // addEffect_l() must be called with ThreadBase::mLock and EffectChain::mLock held
addEffect_ll(const sp<EffectModule> & effect)2005 status_t AudioFlinger::EffectChain::addEffect_ll(const sp<EffectModule>& effect)
2006 {
2007 effect_descriptor_t desc = effect->desc();
2008 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
2009
2010 effect->setChain(this);
2011 sp<ThreadBase> thread = mThread.promote();
2012 if (thread == 0) {
2013 return NO_INIT;
2014 }
2015 effect->setThread(thread);
2016
2017 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2018 // Auxiliary effects are inserted at the beginning of mEffects vector as
2019 // they are processed first and accumulated in chain input buffer
2020 mEffects.insertAt(effect, 0);
2021
2022 // the input buffer for auxiliary effect contains mono samples in
2023 // 32 bit format. This is to avoid saturation in AudoMixer
2024 // accumulation stage. Saturation is done in EffectModule::process() before
2025 // calling the process in effect engine
2026 size_t numSamples = thread->frameCount();
2027 sp<EffectBufferHalInterface> halBuffer;
2028 #ifdef FLOAT_EFFECT_CHAIN
2029 status_t result = thread->mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
2030 numSamples * sizeof(float), &halBuffer);
2031 #else
2032 status_t result = thread->mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
2033 numSamples * sizeof(int32_t), &halBuffer);
2034 #endif
2035 if (result != OK) return result;
2036 effect->setInBuffer(halBuffer);
2037 // auxiliary effects output samples to chain input buffer for further processing
2038 // by insert effects
2039 effect->setOutBuffer(mInBuffer);
2040 } else {
2041 // Insert effects are inserted at the end of mEffects vector as they are processed
2042 // after track and auxiliary effects.
2043 // Insert effect order as a function of indicated preference:
2044 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
2045 // another effect is present
2046 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
2047 // last effect claiming first position
2048 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
2049 // first effect claiming last position
2050 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last
2051 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
2052 // already present
2053
2054 size_t size = mEffects.size();
2055 size_t idx_insert = size;
2056 ssize_t idx_insert_first = -1;
2057 ssize_t idx_insert_last = -1;
2058
2059 for (size_t i = 0; i < size; i++) {
2060 effect_descriptor_t d = mEffects[i]->desc();
2061 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
2062 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
2063 if (iMode == EFFECT_FLAG_TYPE_INSERT) {
2064 // check invalid effect chaining combinations
2065 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
2066 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
2067 ALOGW("addEffect_l() could not insert effect %s: exclusive conflict with %s",
2068 desc.name, d.name);
2069 return INVALID_OPERATION;
2070 }
2071 // remember position of first insert effect and by default
2072 // select this as insert position for new effect
2073 if (idx_insert == size) {
2074 idx_insert = i;
2075 }
2076 // remember position of last insert effect claiming
2077 // first position
2078 if (iPref == EFFECT_FLAG_INSERT_FIRST) {
2079 idx_insert_first = i;
2080 }
2081 // remember position of first insert effect claiming
2082 // last position
2083 if (iPref == EFFECT_FLAG_INSERT_LAST &&
2084 idx_insert_last == -1) {
2085 idx_insert_last = i;
2086 }
2087 }
2088 }
2089
2090 // modify idx_insert from first position if needed
2091 if (insertPref == EFFECT_FLAG_INSERT_LAST) {
2092 if (idx_insert_last != -1) {
2093 idx_insert = idx_insert_last;
2094 } else {
2095 idx_insert = size;
2096 }
2097 } else {
2098 if (idx_insert_first != -1) {
2099 idx_insert = idx_insert_first + 1;
2100 }
2101 }
2102
2103 // always read samples from chain input buffer
2104 effect->setInBuffer(mInBuffer);
2105
2106 // if last effect in the chain, output samples to chain
2107 // output buffer, otherwise to chain input buffer
2108 if (idx_insert == size) {
2109 if (idx_insert != 0) {
2110 mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
2111 mEffects[idx_insert-1]->configure();
2112 }
2113 effect->setOutBuffer(mOutBuffer);
2114 } else {
2115 effect->setOutBuffer(mInBuffer);
2116 }
2117 mEffects.insertAt(effect, idx_insert);
2118
2119 ALOGV("addEffect_l() effect %p, added in chain %p at rank %zu", effect.get(), this,
2120 idx_insert);
2121 }
2122 effect->configure();
2123
2124 return NO_ERROR;
2125 }
2126
2127 // removeEffect_l() must be called with ThreadBase::mLock held
removeEffect_l(const sp<EffectModule> & effect,bool release)2128 size_t AudioFlinger::EffectChain::removeEffect_l(const sp<EffectModule>& effect,
2129 bool release)
2130 {
2131 Mutex::Autolock _l(mLock);
2132 size_t size = mEffects.size();
2133 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
2134
2135 for (size_t i = 0; i < size; i++) {
2136 if (effect == mEffects[i]) {
2137 // calling stop here will remove pre-processing effect from the audio HAL.
2138 // This is safe as we hold the EffectChain mutex which guarantees that we are not in
2139 // the middle of a read from audio HAL
2140 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2141 mEffects[i]->state() == EffectModule::STOPPING) {
2142 mEffects[i]->stop();
2143 }
2144 if (release) {
2145 mEffects[i]->release_l();
2146 }
2147
2148 if (type != EFFECT_FLAG_TYPE_AUXILIARY) {
2149 if (i == size - 1 && i != 0) {
2150 mEffects[i - 1]->setOutBuffer(mOutBuffer);
2151 mEffects[i - 1]->configure();
2152 }
2153 }
2154 mEffects.removeAt(i);
2155 ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %zu", effect.get(),
2156 this, i);
2157
2158 break;
2159 }
2160 }
2161
2162 return mEffects.size();
2163 }
2164
2165 // setDevice_l() must be called with ThreadBase::mLock held
setDevice_l(audio_devices_t device)2166 void AudioFlinger::EffectChain::setDevice_l(audio_devices_t device)
2167 {
2168 size_t size = mEffects.size();
2169 for (size_t i = 0; i < size; i++) {
2170 mEffects[i]->setDevice(device);
2171 }
2172 }
2173
2174 // setMode_l() must be called with ThreadBase::mLock held
setMode_l(audio_mode_t mode)2175 void AudioFlinger::EffectChain::setMode_l(audio_mode_t mode)
2176 {
2177 size_t size = mEffects.size();
2178 for (size_t i = 0; i < size; i++) {
2179 mEffects[i]->setMode(mode);
2180 }
2181 }
2182
2183 // setAudioSource_l() must be called with ThreadBase::mLock held
setAudioSource_l(audio_source_t source)2184 void AudioFlinger::EffectChain::setAudioSource_l(audio_source_t source)
2185 {
2186 size_t size = mEffects.size();
2187 for (size_t i = 0; i < size; i++) {
2188 mEffects[i]->setAudioSource(source);
2189 }
2190 }
2191
2192 // setVolume_l() must be called with ThreadBase::mLock or EffectChain::mLock held
setVolume_l(uint32_t * left,uint32_t * right,bool force)2193 bool AudioFlinger::EffectChain::setVolume_l(uint32_t *left, uint32_t *right, bool force)
2194 {
2195 uint32_t newLeft = *left;
2196 uint32_t newRight = *right;
2197 bool hasControl = false;
2198 int ctrlIdx = -1;
2199 size_t size = mEffects.size();
2200
2201 // first update volume controller
2202 for (size_t i = size; i > 0; i--) {
2203 if (mEffects[i - 1]->isProcessEnabled() &&
2204 (mEffects[i - 1]->desc().flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL) {
2205 ctrlIdx = i - 1;
2206 hasControl = true;
2207 break;
2208 }
2209 }
2210
2211 if (!force && ctrlIdx == mVolumeCtrlIdx &&
2212 *left == mLeftVolume && *right == mRightVolume) {
2213 if (hasControl) {
2214 *left = mNewLeftVolume;
2215 *right = mNewRightVolume;
2216 }
2217 return hasControl;
2218 }
2219
2220 mVolumeCtrlIdx = ctrlIdx;
2221 mLeftVolume = newLeft;
2222 mRightVolume = newRight;
2223
2224 // second get volume update from volume controller
2225 if (ctrlIdx >= 0) {
2226 mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true);
2227 mNewLeftVolume = newLeft;
2228 mNewRightVolume = newRight;
2229 }
2230 // then indicate volume to all other effects in chain.
2231 // Pass altered volume to effects before volume controller
2232 // and requested volume to effects after controller
2233 uint32_t lVol = newLeft;
2234 uint32_t rVol = newRight;
2235
2236 for (size_t i = 0; i < size; i++) {
2237 if ((int)i == ctrlIdx) {
2238 continue;
2239 }
2240 // this also works for ctrlIdx == -1 when there is no volume controller
2241 if ((int)i > ctrlIdx) {
2242 lVol = *left;
2243 rVol = *right;
2244 }
2245 mEffects[i]->setVolume(&lVol, &rVol, false);
2246 }
2247 *left = newLeft;
2248 *right = newRight;
2249
2250 return hasControl;
2251 }
2252
2253 // resetVolume_l() must be called with ThreadBase::mLock or EffectChain::mLock held
resetVolume_l()2254 void AudioFlinger::EffectChain::resetVolume_l()
2255 {
2256 if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) {
2257 uint32_t left = mLeftVolume;
2258 uint32_t right = mRightVolume;
2259 (void)setVolume_l(&left, &right, true);
2260 }
2261 }
2262
syncHalEffectsState()2263 void AudioFlinger::EffectChain::syncHalEffectsState()
2264 {
2265 Mutex::Autolock _l(mLock);
2266 for (size_t i = 0; i < mEffects.size(); i++) {
2267 if (mEffects[i]->state() == EffectModule::ACTIVE ||
2268 mEffects[i]->state() == EffectModule::STOPPING) {
2269 mEffects[i]->addEffectToHal_l();
2270 }
2271 }
2272 }
2273
dump(int fd,const Vector<String16> & args)2274 void AudioFlinger::EffectChain::dump(int fd, const Vector<String16>& args)
2275 {
2276 const size_t SIZE = 256;
2277 char buffer[SIZE];
2278 String8 result;
2279
2280 size_t numEffects = mEffects.size();
2281 snprintf(buffer, SIZE, " %zu effects for session %d\n", numEffects, mSessionId);
2282 result.append(buffer);
2283
2284 if (numEffects) {
2285 bool locked = AudioFlinger::dumpTryLock(mLock);
2286 // failed to lock - AudioFlinger is probably deadlocked
2287 if (!locked) {
2288 result.append("\tCould not lock mutex:\n");
2289 }
2290
2291 const std::string inBufferStr = dumpInOutBuffer(true /* isInput */, mInBuffer);
2292 const std::string outBufferStr = dumpInOutBuffer(false /* isInput */, mOutBuffer);
2293 result.appendFormat("\t%-*s%-*s Active tracks:\n",
2294 (int)inBufferStr.size(), "In buffer ",
2295 (int)outBufferStr.size(), "Out buffer ");
2296 result.appendFormat("\t%s %s %d\n",
2297 inBufferStr.c_str(), outBufferStr.c_str(), mActiveTrackCnt);
2298 write(fd, result.string(), result.size());
2299
2300 for (size_t i = 0; i < numEffects; ++i) {
2301 sp<EffectModule> effect = mEffects[i];
2302 if (effect != 0) {
2303 effect->dump(fd, args);
2304 }
2305 }
2306
2307 if (locked) {
2308 mLock.unlock();
2309 }
2310 }
2311 }
2312
2313 // must be called with ThreadBase::mLock held
setEffectSuspended_l(const effect_uuid_t * type,bool suspend)2314 void AudioFlinger::EffectChain::setEffectSuspended_l(
2315 const effect_uuid_t *type, bool suspend)
2316 {
2317 sp<SuspendedEffectDesc> desc;
2318 // use effect type UUID timelow as key as there is no real risk of identical
2319 // timeLow fields among effect type UUIDs.
2320 ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow);
2321 if (suspend) {
2322 if (index >= 0) {
2323 desc = mSuspendedEffects.valueAt(index);
2324 } else {
2325 desc = new SuspendedEffectDesc();
2326 desc->mType = *type;
2327 mSuspendedEffects.add(type->timeLow, desc);
2328 ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
2329 }
2330
2331 if (desc->mRefCount++ == 0) {
2332 sp<EffectModule> effect = getEffectIfEnabled(type);
2333 if (effect != 0) {
2334 desc->mEffect = effect;
2335 effect->setSuspended(true);
2336 effect->setEnabled(false);
2337 }
2338 }
2339 } else {
2340 if (index < 0) {
2341 return;
2342 }
2343 desc = mSuspendedEffects.valueAt(index);
2344 if (desc->mRefCount <= 0) {
2345 ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
2346 desc->mRefCount = 0;
2347 return;
2348 }
2349 if (--desc->mRefCount == 0) {
2350 ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
2351 if (desc->mEffect != 0) {
2352 sp<EffectModule> effect = desc->mEffect.promote();
2353 if (effect != 0) {
2354 effect->setSuspended(false);
2355 effect->lock();
2356 EffectHandle *handle = effect->controlHandle_l();
2357 if (handle != NULL && !handle->disconnected()) {
2358 effect->setEnabled_l(handle->enabled());
2359 }
2360 effect->unlock();
2361 }
2362 desc->mEffect.clear();
2363 }
2364 mSuspendedEffects.removeItemsAt(index);
2365 }
2366 }
2367 }
2368
2369 // must be called with ThreadBase::mLock held
setEffectSuspendedAll_l(bool suspend)2370 void AudioFlinger::EffectChain::setEffectSuspendedAll_l(bool suspend)
2371 {
2372 sp<SuspendedEffectDesc> desc;
2373
2374 ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2375 if (suspend) {
2376 if (index >= 0) {
2377 desc = mSuspendedEffects.valueAt(index);
2378 } else {
2379 desc = new SuspendedEffectDesc();
2380 mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
2381 ALOGV("setEffectSuspendedAll_l() add entry for 0");
2382 }
2383 if (desc->mRefCount++ == 0) {
2384 Vector< sp<EffectModule> > effects;
2385 getSuspendEligibleEffects(effects);
2386 for (size_t i = 0; i < effects.size(); i++) {
2387 setEffectSuspended_l(&effects[i]->desc().type, true);
2388 }
2389 }
2390 } else {
2391 if (index < 0) {
2392 return;
2393 }
2394 desc = mSuspendedEffects.valueAt(index);
2395 if (desc->mRefCount <= 0) {
2396 ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
2397 desc->mRefCount = 1;
2398 }
2399 if (--desc->mRefCount == 0) {
2400 Vector<const effect_uuid_t *> types;
2401 for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
2402 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
2403 continue;
2404 }
2405 types.add(&mSuspendedEffects.valueAt(i)->mType);
2406 }
2407 for (size_t i = 0; i < types.size(); i++) {
2408 setEffectSuspended_l(types[i], false);
2409 }
2410 ALOGV("setEffectSuspendedAll_l() remove entry for %08x",
2411 mSuspendedEffects.keyAt(index));
2412 mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
2413 }
2414 }
2415 }
2416
2417
2418 // The volume effect is used for automated tests only
2419 #ifndef OPENSL_ES_H_
2420 static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
2421 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
2422 const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
2423 #endif //OPENSL_ES_H_
2424
2425 /* static */
isEffectEligibleForBtNrecSuspend(const effect_uuid_t * type)2426 bool AudioFlinger::EffectChain::isEffectEligibleForBtNrecSuspend(const effect_uuid_t *type)
2427 {
2428 // Only NS and AEC are suspended when BtNRec is off
2429 if ((memcmp(type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) ||
2430 (memcmp(type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
2431 return true;
2432 }
2433 return false;
2434 }
2435
isEffectEligibleForSuspend(const effect_descriptor_t & desc)2436 bool AudioFlinger::EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
2437 {
2438 // auxiliary effects and visualizer are never suspended on output mix
2439 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
2440 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
2441 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
2442 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0))) {
2443 return false;
2444 }
2445 return true;
2446 }
2447
getSuspendEligibleEffects(Vector<sp<AudioFlinger::EffectModule>> & effects)2448 void AudioFlinger::EffectChain::getSuspendEligibleEffects(
2449 Vector< sp<AudioFlinger::EffectModule> > &effects)
2450 {
2451 effects.clear();
2452 for (size_t i = 0; i < mEffects.size(); i++) {
2453 if (isEffectEligibleForSuspend(mEffects[i]->desc())) {
2454 effects.add(mEffects[i]);
2455 }
2456 }
2457 }
2458
getEffectIfEnabled(const effect_uuid_t * type)2459 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectIfEnabled(
2460 const effect_uuid_t *type)
2461 {
2462 sp<EffectModule> effect = getEffectFromType_l(type);
2463 return effect != 0 && effect->isEnabled() ? effect : 0;
2464 }
2465
checkSuspendOnEffectEnabled(const sp<EffectModule> & effect,bool enabled)2466 void AudioFlinger::EffectChain::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
2467 bool enabled)
2468 {
2469 ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
2470 if (enabled) {
2471 if (index < 0) {
2472 // if the effect is not suspend check if all effects are suspended
2473 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
2474 if (index < 0) {
2475 return;
2476 }
2477 if (!isEffectEligibleForSuspend(effect->desc())) {
2478 return;
2479 }
2480 setEffectSuspended_l(&effect->desc().type, enabled);
2481 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
2482 if (index < 0) {
2483 ALOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!");
2484 return;
2485 }
2486 }
2487 ALOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x",
2488 effect->desc().type.timeLow);
2489 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
2490 // if effect is requested to suspended but was not yet enabled, suspend it now.
2491 if (desc->mEffect == 0) {
2492 desc->mEffect = effect;
2493 effect->setEnabled(false);
2494 effect->setSuspended(true);
2495 }
2496 } else {
2497 if (index < 0) {
2498 return;
2499 }
2500 ALOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x",
2501 effect->desc().type.timeLow);
2502 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
2503 desc->mEffect.clear();
2504 effect->setSuspended(false);
2505 }
2506 }
2507
isNonOffloadableEnabled()2508 bool AudioFlinger::EffectChain::isNonOffloadableEnabled()
2509 {
2510 Mutex::Autolock _l(mLock);
2511 size_t size = mEffects.size();
2512 for (size_t i = 0; i < size; i++) {
2513 if (mEffects[i]->isEnabled() && !mEffects[i]->isOffloadable()) {
2514 return true;
2515 }
2516 }
2517 return false;
2518 }
2519
setThread(const sp<ThreadBase> & thread)2520 void AudioFlinger::EffectChain::setThread(const sp<ThreadBase>& thread)
2521 {
2522 Mutex::Autolock _l(mLock);
2523 mThread = thread;
2524 for (size_t i = 0; i < mEffects.size(); i++) {
2525 mEffects[i]->setThread(thread);
2526 }
2527 }
2528
checkOutputFlagCompatibility(audio_output_flags_t * flags) const2529 void AudioFlinger::EffectChain::checkOutputFlagCompatibility(audio_output_flags_t *flags) const
2530 {
2531 if ((*flags & AUDIO_OUTPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
2532 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_RAW);
2533 }
2534 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
2535 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
2536 }
2537 }
2538
checkInputFlagCompatibility(audio_input_flags_t * flags) const2539 void AudioFlinger::EffectChain::checkInputFlagCompatibility(audio_input_flags_t *flags) const
2540 {
2541 if ((*flags & AUDIO_INPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
2542 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_RAW);
2543 }
2544 if ((*flags & AUDIO_INPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
2545 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
2546 }
2547 }
2548
isRawCompatible() const2549 bool AudioFlinger::EffectChain::isRawCompatible() const
2550 {
2551 Mutex::Autolock _l(mLock);
2552 for (const auto &effect : mEffects) {
2553 if (effect->isProcessImplemented()) {
2554 return false;
2555 }
2556 }
2557 // Allow effects without processing.
2558 return true;
2559 }
2560
isFastCompatible() const2561 bool AudioFlinger::EffectChain::isFastCompatible() const
2562 {
2563 Mutex::Autolock _l(mLock);
2564 for (const auto &effect : mEffects) {
2565 if (effect->isProcessImplemented()
2566 && effect->isImplementationSoftware()) {
2567 return false;
2568 }
2569 }
2570 // Allow effects without processing or hw accelerated effects.
2571 return true;
2572 }
2573
2574 // isCompatibleWithThread_l() must be called with thread->mLock held
isCompatibleWithThread_l(const sp<ThreadBase> & thread) const2575 bool AudioFlinger::EffectChain::isCompatibleWithThread_l(const sp<ThreadBase>& thread) const
2576 {
2577 Mutex::Autolock _l(mLock);
2578 for (size_t i = 0; i < mEffects.size(); i++) {
2579 if (thread->checkEffectCompatibility_l(&(mEffects[i]->desc()), mSessionId) != NO_ERROR) {
2580 return false;
2581 }
2582 }
2583 return true;
2584 }
2585
2586 } // namespace android
2587