Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2fa06c1b authored by Shunkai Yao's avatar Shunkai Yao
Browse files

AudioEffect: prevent adding effect for unknown session on first io 

Bug: 309578734
Test: add an effect chain on a music ouput (first) and enable.
Add another chain on another output.
Ensure chain on music output is not suspended.

Adding a chain on a different output may suspend chain on default output
First output is assigned when an effect is created, then may be moved once the
session is associated to its output.
It leads to suspend the chain of first output.
This CL fixes this bug by adding effect in orphan chains until track is
created.
Test: atest CtsMediaAudioTestCases

Change-Id: I2ce880dea862df1b29a67893d60a9c98c4c4eb46
Merged-In: I2ce880dea862df1b29a67893d60a9c98c4c4eb46
parent c0d688d0

services/audioflinger/AudioFlinger.cpp

+110 −9
Original line number Diff line number Diff line
@@ -1082,6 +1082,7 @@ status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input, 
        client = registerPid(clientPid);



        IAfPlaybackThread* effectThread = nullptr;

        sp<IAfEffectChain> effectChain = nullptr;

        // check if an effect chain with the same session ID is present on another

        // output thread and move it here.

        for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
@@ -1094,6 +1095,10 @@ status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input, 
                }

            }

        }

        // Check if an orphan effect chain exists for this session

        if (effectThread == nullptr) {

            effectChain = getOrphanEffectChain_l(sessionId);

        }

        ALOGV("createTrack() sessionId: %d", sessionId);



        output.sampleRate = input.config.sample_rate;
@@ -1138,6 +1143,13 @@ status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input, 
                    effectIds = thread->getEffectIds_l(sessionId);

                }

            }

            if (effectChain != nullptr) {

                if (moveEffectChain_ll(sessionId, nullptr, thread, effectChain.get())

                        == NO_ERROR) {

                    effectThreadId = thread->id();

                    effectIds = thread->getEffectIds_l(sessionId);

                }

            }

        }



        // Look for sync events awaiting for a session to be used.
@@ -4280,8 +4292,9 @@ status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request, 
            // before creating the AudioEffect or the io handle must be specified.

            //

            // Detect if the effect is created after an AudioRecord is destroyed.

            if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) &&

                    getOrphanEffectChain_l(sessionId).get() != nullptr) {

            if (sessionId != AUDIO_SESSION_OUTPUT_MIX

                  && ((descOut.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)

                  && getOrphanEffectChain_l(sessionId).get() != nullptr) {

                ALOGE("%s: effect %s with no specified io handle is denied because the AudioRecord"

                      " for session %d no longer exists",

                      __func__, descOut.name, sessionId);
@@ -4292,11 +4305,27 @@ status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request, 
            // Legacy handling of creating an effect on an expired or made-up

            // session id.  We think that it is a Playback effect.

            //

            // If no output thread contains the requested session ID, default to

            // first output. The effect chain will be moved to the correct output

            // thread when a track with the same session ID is created

            if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) {

                io = mPlaybackThreads.keyAt(0);

            // If no output thread contains the requested session ID, park the effect to

            // the orphan chains. The effect chain will be moved to the correct output

            // thread when a track with the same session ID is created.

            if (io == AUDIO_IO_HANDLE_NONE) {

                if (probe) {

                    // In probe mode, as no compatible thread found, exit with error.

                    lStatus = BAD_VALUE;

                    goto Exit;

                }

                ALOGV("%s() got io %d for effect %s", __func__, io, descOut.name);

                sp<Client> client = registerPid(currentPid);

                bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);

                handle = createOrphanEffect_l(client, effectClient, priority, sessionId,

                                              &descOut, &enabledOut, &lStatus, pinned,

                                              request.notifyFramesProcessed);

                if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {

                    // remove local strong reference to Client with clientMutex() held

                    audio_utils::lock_guard _cl(clientMutex());

                    client.clear();

                }

                goto Register;

            }

            ALOGV("createEffect() got io %d for effect %s", io, descOut.name);

        } else if (checkPlaybackThread_l(io) != nullptr
@@ -4414,6 +4443,78 @@ Exit: 
    return lStatus;

}



sp<IAfEffectHandle> AudioFlinger::createOrphanEffect_l(

        const sp<Client>& client,

        const sp<IEffectClient>& effectClient,

        int32_t priority,

        audio_session_t sessionId,

        effect_descriptor_t *desc,

        int *enabled,

        status_t *status,

        bool pinned,

        bool notifyFramesProcessed)

{

    ALOGV("%s effectClient %p, priority %d, sessionId %d, factory %p",

          __func__, effectClient.get(), priority, sessionId, mEffectsFactoryHal.get());



    // Check if an orphan effect chain exists for this session or create new chain for this session

    sp<IAfEffectModule> effect;

    sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);

    bool chainCreated = false;

    if (chain == nullptr) {

        chain = IAfEffectChain::create(/* ThreadBase= */ nullptr, sessionId, this);

        chainCreated = true;

    } else {

        effect = chain->getEffectFromDesc(desc);

    }

    bool effectCreated = false;

    if (effect == nullptr) {

        audio_unique_id_t effectId = nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);

        // create a new effect module if none present in the chain

        status_t llStatus =

                chain->createEffect(effect, desc, effectId, sessionId, pinned);

        if (llStatus != NO_ERROR) {

            *status = llStatus;

            return nullptr;

        }

        effect->setMode(getMode());



        if (effect->isHapticGenerator()) {

            // TODO(b/184194057): Use the vibrator information from the vibrator that will be used

            // for the HapticGenerator.

            const std::optional<media::AudioVibratorInfo> defaultVibratorInfo =

                    std::move(getDefaultVibratorInfo_l());

            if (defaultVibratorInfo) {

                // Only set the vibrator info when it is a valid one.

                audio_utils::lock_guard _cl(chain->mutex());

                effect->setVibratorInfo_l(*defaultVibratorInfo);

            }

        }

        effectCreated = true;

    }

    // create effect handle and connect it to effect module

    sp<IAfEffectHandle> handle =

            IAfEffectHandle::create(effect, client, effectClient, priority, notifyFramesProcessed);

    status_t lStatus = handle->initCheck();

    if (lStatus == OK) {

        lStatus = effect->addHandle(handle.get());

    }

    if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {

        if (effectCreated) {

            chain->removeEffect(effect);

        }

    } else {

        if (enabled != NULL) {

            *enabled = (int)effect->isEnabled();

        }

        if (chainCreated) {

            putOrphanEffectChain_l(chain);

        }

    }

    *status = lStatus;

    return handle;

}



status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcIo,

        audio_io_handle_t dstIo)

NO_THREAD_SAFETY_ANALYSIS
@@ -4545,7 +4646,7 @@ status_t AudioFlinger::moveEffectChain_ll(audio_session_t sessionId, 
        if (srcThread != nullptr) {

            srcThread->removeEffect_l(effect);

        } else {

            chain->removeEffect_l(effect);

            chain->removeEffect(effect);

        }

        removed.add(effect);

        status = dstThread->addEffect_ll(effect);
@@ -4788,7 +4889,7 @@ bool AudioFlinger::updateOrphanEffectChains_l(const sp<IAfEffectModule>& effect) 
    ALOGV("updateOrphanEffectChains session %d index %zd", session, index);

    if (index >= 0) {

        sp<IAfEffectChain> chain = mOrphanEffectChains.valueAt(index);

        if (chain->removeEffect_l(effect, true) == 0) {

        if (chain->removeEffect(effect, true) == 0) {

            ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index);

            mOrphanEffectChains.removeItemsAt(index);

        }

services/audioflinger/AudioFlinger.h

+10 −0
Original line number Diff line number Diff line
@@ -711,6 +711,16 @@ private: 


    sp<Client> registerPid(pid_t pid) EXCLUDES_AudioFlinger_ClientMutex; // always returns non-0



    sp<IAfEffectHandle> createOrphanEffect_l(const sp<Client>& client,

                                          const sp<media::IEffectClient>& effectClient,

                                          int32_t priority,

                                          audio_session_t sessionId,

                                          effect_descriptor_t *desc,

                                          int *enabled,

                                          status_t *status /*non-NULL*/,

                                          bool pinned,

                                          bool notifyFramesProcessed) REQUIRES(mutex());



    // for use from destructor

    status_t closeOutput_nonvirtual(audio_io_handle_t output) EXCLUDES_AudioFlinger_Mutex;

    status_t closeInput_nonvirtual(audio_io_handle_t input) EXCLUDES_AudioFlinger_Mutex;

services/audioflinger/Effects.cpp

+52 −32
Original line number Diff line number Diff line
@@ -2155,27 +2155,31 @@ NO_THREAD_SAFETY_ANALYSIS // conditional try lock 
/* static */

sp<IAfEffectChain> IAfEffectChain::create(

        const sp<IAfThreadBase>& thread,

        audio_session_t sessionId)

        audio_session_t sessionId,

        const sp<IAfThreadCallback>& afThreadCallback)

{

    return sp<EffectChain>::make(thread, sessionId);

    return sp<EffectChain>::make(thread, sessionId, afThreadCallback);

}



EffectChain::EffectChain(const sp<IAfThreadBase>& thread,

                                       audio_session_t sessionId)

EffectChain::EffectChain(const sp<IAfThreadBase>& thread, audio_session_t sessionId,

                         const sp<IAfThreadCallback>& afThreadCallback)

    : mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),

      mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),

      mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),

      mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread))

      mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread, afThreadCallback))

{

    if (thread != nullptr) {

        mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);

    mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /

        mMaxTailBuffers =

            ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /

                thread->frameCount();

    }

}



// getEffectFromDesc_l() must be called with IAfThreadBase::mutex() held

sp<IAfEffectModule> EffectChain::getEffectFromDesc_l(

sp<IAfEffectModule> EffectChain::getEffectFromDesc(

        effect_descriptor_t *descriptor) const

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();



    for (size_t i = 0; i < size; i++) {
@@ -2189,6 +2193,7 @@ sp<IAfEffectModule> EffectChain::getEffectFromDesc_l( 
// getEffectFromId_l() must be called with IAfThreadBase::mutex() held

sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();



    for (size_t i = 0; i < size; i++) {
@@ -2204,6 +2209,7 @@ sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const 
sp<IAfEffectModule> EffectChain::getEffectFromType_l(

        const effect_uuid_t *type) const

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();



    for (size_t i = 0; i < size; i++) {
@@ -2294,8 +2300,7 @@ void EffectChain::process_l() { 
    }

}



// createEffect_l() must be called with IAfThreadBase::mutex() held

status_t EffectChain::createEffect_l(sp<IAfEffectModule>& effect,

status_t EffectChain::createEffect(sp<IAfEffectModule>& effect,

                                                   effect_descriptor_t *desc,

                                                   int id,

                                                   audio_session_t sessionId,
@@ -2305,7 +2310,7 @@ status_t EffectChain::createEffect_l(sp<IAfEffectModule>& effect, 
    effect = new EffectModule(mEffectCallback, desc, id, sessionId, pinned, AUDIO_PORT_HANDLE_NONE);

    status_t lStatus = effect->status();

    if (lStatus == NO_ERROR) {

        lStatus = addEffect_ll(effect);

        lStatus = addEffect_l(effect);

    }

    if (lStatus != NO_ERROR) {

        effect.clear();
@@ -2313,14 +2318,13 @@ status_t EffectChain::createEffect_l(sp<IAfEffectModule>& effect, 
    return lStatus;

}



// addEffect_l() must be called with IAfThreadBase::mutex() held

status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)

status_t EffectChain::addEffect(const sp<IAfEffectModule>& effect)

{

    audio_utils::lock_guard _l(mutex());

    return addEffect_ll(effect);

    return addEffect_l(effect);

}

// addEffect_l() must be called with IAfThreadBase::mutex() and EffectChain::mutex() held

status_t EffectChain::addEffect_ll(const sp<IAfEffectModule>& effect)

// addEffect_l() must be called with EffectChain::mutex() held

status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)

{

    effect->setCallback(mEffectCallback);
@@ -2348,7 +2352,7 @@ status_t EffectChain::addEffect_ll(const sp<IAfEffectModule>& effect) 
        // by insert effects

        effect->setOutBuffer(mInBuffer);

    } else {

        ssize_t idx_insert = getInsertIndex_ll(desc);

        ssize_t idx_insert = getInsertIndex_l(desc);

        if (idx_insert < 0) {

            return INVALID_OPERATION;

        }
@@ -2409,7 +2413,7 @@ std::optional<size_t> EffectChain::findVolumeControl_l(size_t from, size_t to) c 
    return std::nullopt;

}



ssize_t EffectChain::getInsertIndex_ll(const effect_descriptor_t& desc) {

ssize_t EffectChain::getInsertIndex_l(const effect_descriptor_t& desc) {

    // Insert effects are inserted at the end of mEffects vector as they are processed

    //  after track and auxiliary effects.

    // Insert effect order as a function of indicated preference:
@@ -2482,8 +2486,7 @@ ssize_t EffectChain::getInsertIndex_ll(const effect_descriptor_t& desc) { 
    return idx_insert;

}



// removeEffect_l() must be called with IAfThreadBase::mutex() held

size_t EffectChain::removeEffect_l(const sp<IAfEffectModule>& effect,

size_t EffectChain::removeEffect(const sp<IAfEffectModule>& effect,

                                                 bool release)

{

    audio_utils::lock_guard _l(mutex());
@@ -2534,6 +2537,7 @@ size_t EffectChain::removeEffect_l(const sp<IAfEffectModule>& effect, 
// setDevices_l() must be called with IAfThreadBase::mutex() held

void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices)

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();

    for (size_t i = 0; i < size; i++) {

        mEffects[i]->setDevices(devices);
@@ -2543,6 +2547,7 @@ void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices) 
// setInputDevice_l() must be called with IAfThreadBase::mutex() held

void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device)

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();

    for (size_t i = 0; i < size; i++) {

        mEffects[i]->setInputDevice(device);
@@ -2552,6 +2557,7 @@ void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device) 
// setMode_l() must be called with IAfThreadBase::mutex() held

void EffectChain::setMode_l(audio_mode_t mode)

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();

    for (size_t i = 0; i < size; i++) {

        mEffects[i]->setMode(mode);
@@ -2561,6 +2567,7 @@ void EffectChain::setMode_l(audio_mode_t mode) 
// setAudioSource_l() must be called with IAfThreadBase::mutex() held

void EffectChain::setAudioSource_l(audio_source_t source)

{

    audio_utils::lock_guard _l(mutex());

    size_t size = mEffects.size();

    for (size_t i = 0; i < size; i++) {

        mEffects[i]->setAudioSource(source);
@@ -2666,8 +2673,12 @@ void EffectChain::resetVolume_l() 
    }

}



// containsHapticGeneratingEffect_l must be called with

// IAfThreadBase::mutex() or EffectChain::mutex() held

bool EffectChain::containsHapticGeneratingEffect()

{

    audio_utils::lock_guard _l(mutex());

    return containsHapticGeneratingEffect_l();

}

// containsHapticGeneratingEffect_l must be called with EffectChain::mutex() held

bool EffectChain::containsHapticGeneratingEffect_l()

{

    for (size_t i = 0; i < mEffects.size(); ++i) {
@@ -2808,7 +2819,7 @@ void EffectChain::setEffectSuspendedAll_l(bool suspend) 
        }

        if (desc->mRefCount++ == 0) {

            Vector< sp<IAfEffectModule> > effects;

            getSuspendEligibleEffects_l(effects);

            getSuspendEligibleEffects(effects);

            for (size_t i = 0; i < effects.size(); i++) {

                setEffectSuspended_l(&effects[i]->desc().type, true);

            }
@@ -2858,7 +2869,7 @@ bool EffectChain::isEffectEligibleForBtNrecSuspend_l(const effect_uuid_t* type) 
    return false;

}



bool EffectChain::isEffectEligibleForSuspend_l(const effect_descriptor_t& desc)

bool EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)

{

    // auxiliary effects and visualizer are never suspended on output mix

    if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
@@ -2871,12 +2882,13 @@ bool EffectChain::isEffectEligibleForSuspend_l(const effect_descriptor_t& desc) 
    return true;

}



void EffectChain::getSuspendEligibleEffects_l(

void EffectChain::getSuspendEligibleEffects(

        Vector< sp<IAfEffectModule> > &effects)

{

    effects.clear();

    audio_utils::lock_guard _l(mutex());

    for (size_t i = 0; i < mEffects.size(); i++) {

        if (isEffectEligibleForSuspend_l(mEffects[i]->desc())) {

        if (isEffectEligibleForSuspend(mEffects[i]->desc())) {

            effects.add(mEffects[i]);

        }

    }
@@ -2897,7 +2909,7 @@ void EffectChain::checkSuspendOnEffectEnabled_l(const sp<IAfEffectModule>& effec 
            if (index < 0) {

                return;

            }

            if (!isEffectEligibleForSuspend_l(effect->desc())) {

            if (!isEffectEligibleForSuspend(effect->desc())) {

                return;

            }

            setEffectSuspended_l(&effect->desc().type, enabled);
@@ -2945,6 +2957,12 @@ bool EffectChain::isNonOffloadableEnabled_l() const 


void EffectChain::setThread(const sp<IAfThreadBase>& thread)

{

    if (thread != nullptr) {

        mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);

        mMaxTailBuffers =

            ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /

                thread->frameCount();

    }

    audio_utils::lock_guard _l(mutex());

    mEffectCallback->setThread(thread);

}
@@ -3134,7 +3152,7 @@ bool EffectChain::EffectCallback::isSpatializer() const { 
uint32_t EffectChain::EffectCallback::sampleRate() const {

    const sp<IAfThreadBase> t = thread().promote();

    if (t == nullptr) {

        return 0;

        return DEFAULT_OUTPUT_SAMPLE_RATE;

    }

    return t->sampleRate();

}
@@ -3142,6 +3160,7 @@ uint32_t EffectChain::EffectCallback::sampleRate() const { 
audio_channel_mask_t EffectChain::EffectCallback::inChannelMask(int id) const

NO_THREAD_SAFETY_ANALYSIS

// calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively

// calling function 'isFirstEffect_l' requires holding mutex 'EffectChain_Mutex' exclusively

{

    const sp<IAfThreadBase> t = thread().promote();

    if (t == nullptr) {
@@ -3154,7 +3173,7 @@ NO_THREAD_SAFETY_ANALYSIS 


    if (mThreadType == IAfThreadBase::SPATIALIZER) {

        if (c->sessionId() == AUDIO_SESSION_OUTPUT_STAGE) {

            if (c->isFirstEffect(id)) {

            if (c->isFirstEffect_l(id)) {

                return t->mixerChannelMask();

            } else {

                return t->channelMask();
@@ -3222,7 +3241,8 @@ audio_channel_mask_t EffectChain::EffectCallback::hapticChannelMask() const { 
size_t EffectChain::EffectCallback::frameCount() const {

    const sp<IAfThreadBase> t = thread().promote();

    if (t == nullptr) {

        return 0;

        // frameCount cannot be zero.

        return 1;

    }

    return t->frameCount();

}

services/audioflinger/Effects.h

+53 −36

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/IAfEffect.h

+24 −18
Original line number Diff line number Diff line
@@ -181,9 +181,9 @@ public: 
    virtual bool isSpatializer() const = 0;



    virtual status_t setHapticScale_l(int id, os::HapticScale hapticScale)

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectBase_Mutex = 0;

            REQUIRES(audio_utils::EffectChain_Mutex) EXCLUDES_EffectBase_Mutex = 0;

    virtual status_t setVibratorInfo_l(const media::AudioVibratorInfo& vibratorInfo)

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectBase_Mutex = 0;

            REQUIRES(audio_utils::EffectChain_Mutex) EXCLUDES_EffectBase_Mutex = 0;

    virtual status_t sendMetadata_ll(const std::vector<playback_track_metadata_v7_t>& metadata)

            REQUIRES(audio_utils::ThreadBase_Mutex,

                     audio_utils::EffectChain_Mutex) EXCLUDES_EffectBase_Mutex = 0;
@@ -218,7 +218,8 @@ class IAfEffectChain : public RefBase { 
public:

    static sp<IAfEffectChain> create(

            const sp<IAfThreadBase>& thread,

            audio_session_t sessionId);

            audio_session_t sessionId,

            const sp<IAfThreadCallback>& afThreadCallback);



    // special key used for an entry in mSuspendedEffects keyed vector

    // corresponding to a suspend all request.
@@ -232,35 +233,36 @@ public: 


    virtual audio_utils::mutex& mutex() const RETURN_CAPABILITY(audio_utils::EffectChain_Mutex) = 0;



    virtual status_t createEffect_l(sp<IAfEffectModule>& effect, effect_descriptor_t* desc, int id,

    virtual status_t createEffect(sp<IAfEffectModule>& effect, effect_descriptor_t* desc, int id,

                                    audio_session_t sessionId, bool pinned)

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;

            EXCLUDES_EffectChain_Mutex = 0;



    virtual status_t addEffect(const sp<IAfEffectModule>& handle)

            EXCLUDES_EffectChain_Mutex = 0;

    virtual status_t addEffect_l(const sp<IAfEffectModule>& handle)

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;

    virtual status_t addEffect_ll(const sp<IAfEffectModule>& handle)

            REQUIRES(audio_utils::ThreadBase_Mutex, audio_utils::EffectChain_Mutex) = 0;

    virtual size_t removeEffect_l(const sp<IAfEffectModule>& handle,

            REQUIRES(audio_utils::EffectChain_Mutex) = 0;

    virtual size_t removeEffect(const sp<IAfEffectModule>& handle,

                                  bool release = false) EXCLUDES_EffectChain_Mutex = 0;



    virtual audio_session_t sessionId() const = 0;

    virtual void setSessionId(audio_session_t sessionId) = 0;



    virtual sp<IAfEffectModule> getEffectFromDesc_l(effect_descriptor_t* descriptor) const

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

    virtual sp<IAfEffectModule> getEffectFromDesc(effect_descriptor_t* descriptor) const

            EXCLUDES_EffectChain_Mutex = 0;

    virtual sp<IAfEffectModule> getEffectFromId_l(int id) const

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;

    virtual sp<IAfEffectModule> getEffectFromType_l(const effect_uuid_t* type) const

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;

    virtual std::vector<int> getEffectIds_l() const = 0;

    virtual bool setVolume(uint32_t* left, uint32_t* right,

                           bool force = false) EXCLUDES_EffectChain_Mutex = 0;

    virtual void resetVolume_l() REQUIRES(audio_utils::EffectChain_Mutex) = 0;

    virtual void setDevices_l(const AudioDeviceTypeAddrVector& devices)

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;

    virtual void setInputDevice_l(const AudioDeviceTypeAddr& device)

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

    virtual void setMode_l(audio_mode_t mode) REQUIRES(audio_utils::ThreadBase_Mutex) = 0;

            REQUIRES(audio_utils::ThreadBase_Mutex)  EXCLUDES_EffectChain_Mutex = 0;

    virtual void setMode_l(audio_mode_t mode)

            REQUIRES(audio_utils::ThreadBase_Mutex)  EXCLUDES_EffectChain_Mutex = 0;

    virtual void setAudioSource_l(audio_source_t source)

            REQUIRES(audio_utils::ThreadBase_Mutex) = 0;
@@ -317,7 +319,11 @@ public: 
    virtual bool isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;



    virtual bool containsHapticGeneratingEffect_l() = 0;

    virtual bool containsHapticGeneratingEffect()

            EXCLUDES_EffectChain_Mutex = 0;



    virtual bool containsHapticGeneratingEffect_l()

            REQUIRES(audio_utils::EffectChain_Mutex) = 0;



    virtual void setHapticScale_l(int id, os::HapticScale hapticScale)

            REQUIRES(audio_utils::ThreadBase_Mutex) EXCLUDES_EffectChain_Mutex = 0;
@@ -327,7 +333,7 @@ public: 
    virtual wp<IAfThreadBase> thread() const = 0;

    virtual void setThread(const sp<IAfThreadBase>& thread) EXCLUDES_EffectChain_Mutex = 0;



    virtual bool isFirstEffect(int id) const = 0;

    virtual bool isFirstEffect_l(int id) const REQUIRES(audio_utils::EffectChain_Mutex) = 0;



    virtual size_t numberOfEffects() const = 0;

    virtual sp<IAfEffectModule> getEffectModule(size_t index) const = 0;