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