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

Commit 043bd860 authored by Andy Hung's avatar Andy Hung Committed by Automerger Merge Worker
Browse files

Merge "AudioPolicyEffects: Remove raw malloc and free code" into main am: df22bc0a 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2996741



Change-Id: I11520da6c47c958d789f4a6a299960434d0d76c0
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents b4efe510 df22bc0a

services/audiopolicy/service/AudioPolicyEffects.cpp

+18 −16
Original line number Diff line number Diff line
@@ -137,15 +137,16 @@ status_t AudioPolicyEffects::addInputEffects(audio_io_handle_t input, 
            status_t status = fx->initCheck();

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

                ALOGW("addInputEffects(): failed to create Fx %s on source %d",

                      effect->mName, (int32_t)aliasSource);

                      effect->mName.c_str(), (int32_t)aliasSource);

                // fx goes out of scope and strong ref on AudioEffect is released

                continue;

            }

            for (size_t j = 0; j < effect->mParams.size(); j++) {

                fx->setParameter(effect->mParams[j]);

                // const_cast here due to API.

                fx->setParameter(const_cast<effect_param_t*>(effect->mParams[j].get()));

            }

            ALOGV("addInputEffects(): added Fx %s on source: %d",

                  effect->mName, (int32_t)aliasSource);

                  effect->mName.c_str(), (int32_t)aliasSource);

            sessionDesc->mEffects.add(fx);

        }

        sessionDesc->setProcessorEnabled(true);
@@ -290,12 +291,12 @@ status_t AudioPolicyEffects::addOutputSessionEffects(audio_io_handle_t output, 
            status_t status = fx->initCheck();

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

                ALOGE("addOutputSessionEffects(): failed to create Fx  %s on session %d",

                      effect->mName, audioSession);

                      effect->mName.c_str(), audioSession);

                // fx goes out of scope and strong ref on AudioEffect is released

                continue;

            }

            ALOGV("addOutputSessionEffects(): added Fx %s on session: %d for stream: %d",

                  effect->mName, audioSession, (int32_t)stream);

                  effect->mName.c_str(), audioSession, (int32_t)stream);

            procDesc->mEffects.add(fx);

        }
@@ -701,7 +702,7 @@ exit: 
}



/* static */

effect_param_t *AudioPolicyEffects::loadEffectParameter(cnode *root)

std::shared_ptr<const effect_param_t> AudioPolicyEffects::loadEffectParameter(cnode* root)

{

    cnode *param;

    cnode *value;
@@ -731,7 +732,7 @@ effect_param_t *AudioPolicyEffects::loadEffectParameter(cnode *root) 
            *ptr = atoi(param->value);

            fx_param->psize = sizeof(int);

            fx_param->vsize = sizeof(int);

            return fx_param;

            return {fx_param, free};

        }

    }

    if (param == NULL || value == NULL) {
@@ -769,7 +770,7 @@ effect_param_t *AudioPolicyEffects::loadEffectParameter(cnode *root) 
        value = value->next;

    }



    return fx_param;

    return {fx_param, free};



error:

    free(fx_param);
@@ -777,14 +778,15 @@ error: 
}



/* static */

void AudioPolicyEffects::loadEffectParameters(cnode *root, Vector <effect_param_t *>& params)

void AudioPolicyEffects::loadEffectParameters(

        cnode* root, std::vector<std::shared_ptr<const effect_param_t>>& params)

{

    cnode *node = root->first_child;

    while (node) {

        ALOGV("loadEffectParameters() loading param %s", node->name);

        effect_param_t *param = loadEffectParameter(node);

        if (param != NULL) {

            params.add(param);

        const auto param = loadEffectParameter(node);

        if (param != nullptr) {

            params.push_back(param);

        }

        node = node->next;

    }
@@ -805,7 +807,7 @@ AudioPolicyEffects::EffectDescVector *AudioPolicyEffects::loadEffectConfig( 
        size_t i;



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

            if (strncmp(effects[i]->mName, node->name, EFFECT_STRING_LEN_MAX) == 0) {

            if (effects[i]->mName == node->name) {

                ALOGV("loadEffectConfig() found effect %s in list", node->name);

                break;

            }
@@ -818,7 +820,7 @@ AudioPolicyEffects::EffectDescVector *AudioPolicyEffects::loadEffectConfig( 
        EffectDesc *effect = new EffectDesc(*effects[i]);   // deep copy

        loadEffectParameters(node, effect->mParams);

        ALOGV("loadEffectConfig() adding effect %s uuid %08x",

              effect->mName, effect->mUuid.timeLow);

              effect->mName.c_str(), effect->mUuid.timeLow);

        desc->mEffects.add(effect);

        node = node->next;

    }
@@ -1013,14 +1015,14 @@ void AudioPolicyEffects::initDefaultDeviceEffects() 
            status_t status = fx->initCheck();

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

                ALOGE("%s(): failed to create Fx %s on port type=%d address=%s", __func__,

                      effectDesc->mName, deviceEffects->getDeviceType(),

                      effectDesc->mName.c_str(), deviceEffects->getDeviceType(),

                      deviceEffects->getDeviceAddress().c_str());

                // fx goes out of scope and strong ref on AudioEffect is released

                continue;

            }

            fx->setEnabled(true);

            ALOGV("%s(): create Fx %s added on port type=%d address=%s", __func__,

                  effectDesc->mName, deviceEffects->getDeviceType(),

                  effectDesc->mName.c_str(), deviceEffects->getDeviceType(),

                  deviceEffects->getDeviceAddress().c_str());

            deviceEffects->mEffects.push_back(fx);

        }

services/audiopolicy/service/AudioPolicyEffects.h

+22 −38
Original line number Diff line number Diff line
@@ -134,12 +134,13 @@ private: 
                   const effect_uuid_t& uuid,

                   uint32_t priority,

                   audio_unique_id_t id) :

                        mName(strdup(name)),

                        mName(name),

                        mTypeUuid(typeUuid),

                        mOpPackageName(opPackageName),

                        mUuid(uuid),

                        mPriority(priority),

                        mId(id) { }

        // Modern EffectDesc usage:

        EffectDesc(const char *name, const effect_uuid_t& uuid) :

                        EffectDesc(name,

                                   *EFFECT_UUID_NULL,
@@ -148,40 +149,21 @@ private: 
                                   0,

                                   AUDIO_UNIQUE_ID_ALLOCATE) { }

        EffectDesc(const EffectDesc& orig) :

                        mName(strdup(orig.mName)),

                        mName(orig.mName),

                        mTypeUuid(orig.mTypeUuid),

                        mOpPackageName(orig.mOpPackageName),

                        mUuid(orig.mUuid),

                        mPriority(orig.mPriority),

                        mId(orig.mId) {

                            // deep copy mParams

                            for (size_t k = 0; k < orig.mParams.size(); k++) {

                                effect_param_t *origParam = orig.mParams[k];

                                // psize and vsize are rounded up to an int boundary for allocation

                                size_t origSize = sizeof(effect_param_t) +

                                                  ((origParam->psize + 3) & ~3) +

                                                  ((origParam->vsize + 3) & ~3);

                                effect_param_t *dupParam = (effect_param_t *) malloc(origSize);

                                memcpy(dupParam, origParam, origSize);

                                // This works because the param buffer allocation is also done by

                                // multiples of 4 bytes originally. In theory we should memcpy only

                                // the actual param size, that is without rounding vsize.

                                mParams.add(dupParam);

                            }

                        }

        /*virtual*/ ~EffectDesc() {

            free(mName);

            for (size_t k = 0; k < mParams.size(); k++) {

                free(mParams[k]);

            }

        }

        char *mName;

        effect_uuid_t mTypeUuid;

        String16 mOpPackageName;

        effect_uuid_t mUuid;

        int32_t mPriority;

        audio_unique_id_t mId;

        Vector <effect_param_t *> mParams;

                        mId(orig.mId),

                        mParams(orig.mParams) { }



        const std::string mName;

        const effect_uuid_t mTypeUuid;

        const String16 mOpPackageName;

        const effect_uuid_t mUuid;

        const int32_t mPriority;

        const audio_unique_id_t mId;

        std::vector<std::shared_ptr<const effect_param_t>> mParams;

    };



    // class to store voctor of EffectDesc
@@ -199,15 +181,14 @@ private: 
    // class to store voctor of AudioEffects

    class EffectVector {

    public:

        explicit EffectVector(audio_session_t session) : mSessionId(session), mRefCount(0) {}

        /*virtual*/ ~EffectVector() {}

        explicit EffectVector(audio_session_t session) : mSessionId(session) {}



        // Enable or disable all effects in effect vector

        void setProcessorEnabled(bool enabled);



        const audio_session_t mSessionId;

        // AudioPolicyManager keeps mMutex, no need for lock on reference count here

        int mRefCount;

        int mRefCount = 0;

        Vector< sp<AudioEffect> >mEffects;

    };
@@ -220,7 +201,6 @@ private: 
                               audio_devices_t device, const std::string& address) :

            mEffectDescriptors(std::move(effectDescriptors)),

            mDeviceType(device), mDeviceAddress(address) {}

        /*virtual*/ ~DeviceEffects() = default;



        std::vector<sp<AudioEffect>> mEffects;

        audio_devices_t getDeviceType() const { return mDeviceType; }
@@ -263,8 +243,12 @@ private: 
    static EffectDescVector *loadEffectConfig(cnode *root, const Vector <EffectDesc *>& effects);



    // Load all automatic effect parameters

    static void loadEffectParameters(cnode* root, Vector<effect_param_t*>& params);

    static effect_param_t* loadEffectParameter(cnode* root);

    static void loadEffectParameters(

            cnode* root, std::vector<std::shared_ptr<const effect_param_t>>& params);



    // loadEffectParameter returns a shared_ptr instead of a unique_ptr as there may

    // be multiple references to the same effect parameter.

    static std::shared_ptr<const effect_param_t> loadEffectParameter(cnode* root);

    static size_t readParamValue(cnode* node,

                          char **param,

                          size_t *curSize,