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

Commit d86851a4 authored by Shunkai Yao's avatar Shunkai Yao
Browse files

[AIDL CTS] Fix DynamicsProcessingTest cts issue with AIDL 

Bug: 270155119
Test: enable aidl
Test: atest
CtsMediaAudioTestCases: android.media.audio.cts.DynamicsProcessingTest
Change-Id: Ic8b4fb9c80da9cc45b1d2774a0c377a8635ace7c
parent a1fbd447

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+26 −5
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ namespace effect { 
using ::aidl::android::aidl_utils::statusTFromBinderStatus;

using ::aidl::android::hardware::audio::effect::CommandId;

using ::aidl::android::hardware::audio::effect::Descriptor;

using ::aidl::android::hardware::audio::effect::Flags;

using ::aidl::android::hardware::audio::effect::Parameter;

using ::aidl::android::media::audio::common::AudioDeviceDescription;

using ::aidl::android::media::audio::common::AudioMode;
@@ -67,7 +68,11 @@ const std::map<uint32_t /* effect_command_e */, EffectConversionHelperAidl::Comm 
EffectConversionHelperAidl::EffectConversionHelperAidl(

        std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> effect,

        int32_t sessionId, int32_t ioId, const Descriptor& desc)

    : mSessionId(sessionId), mIoId(ioId), mDesc(desc), mEffect(std::move(effect)) {

    : mSessionId(sessionId),

      mIoId(ioId),

      mDesc(desc),

      mEffect(std::move(effect)),

      mIsInputStream(mDesc.common.flags.type == Flags::Type::PRE_PROC) {

    mCommon.session = sessionId;

    mCommon.ioHandle = ioId;

    mCommon.input = mCommon.output = kDefaultAudioConfig;
@@ -139,16 +144,32 @@ status_t EffectConversionHelperAidl::handleGetParameter(uint32_t cmdSize, const 
    return ret;

}



status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize,

                                                     const void* pCmdData __unused,

status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const void* pCmdData,

                                                     uint32_t* replySize, void* pReplyData) {

    if (!replySize || *replySize != sizeof(int) || !pReplyData ||

        cmdSize != sizeof(effect_config_t)) {

        ALOGE("%s parameter invalid %u %p %p %p", __func__, cmdSize, pCmdData, replySize,

              pReplyData);

        return BAD_VALUE;

    }



    // TODO: need to implement setConfig with setParameter(common)

    return *static_cast<int32_t*>(pReplyData) = OK;

    effect_config_t* config = (effect_config_t*)pCmdData;

    Parameter::Common aidlCommon = {

            .session = mSessionId,

            .ioHandle = mIoId,

            .input = {.base = VALUE_OR_RETURN_STATUS(

                              ::aidl::android::legacy2aidl_buffer_config_t_AudioConfigBase(

                                      config->inputCfg, mIsInputStream))},

            .output = {.base = VALUE_OR_RETURN_STATUS(

                               ::aidl::android::legacy2aidl_buffer_config_t_AudioConfigBase(

                                       config->outputCfg, mIsInputStream))}};



    Parameter aidlParam = UNION_MAKE(Parameter, common, aidlCommon);



    status_t ret = statusTFromBinderStatus(mEffect->setParameter(aidlParam));

    EffectParamWriter writer(*(effect_param_t*)pReplyData);

    writer.setStatus(ret);

    return ret;

}



status_t EffectConversionHelperAidl::handleGetConfig(uint32_t cmdSize __unused,

media/libaudiohal/impl/EffectConversionHelperAidl.h

+2 −0
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ class EffectConversionHelperAidl { 
    const int32_t mIoId;

    const ::aidl::android::hardware::audio::effect::Descriptor mDesc;

    const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> mEffect;

    // whether the effect is instantiated on an input stream

    const bool mIsInputStream;

    ::aidl::android::hardware::audio::effect::IEffect::OpenEffectReturn mOpenReturn;

    ::aidl::android::hardware::audio::effect::Parameter::Common mCommon;

media/libaudiohal/impl/effectsAidlConversion/AidlConversionDynamicsProcessing.cpp

+91 −148
Original line number Diff line number Diff line
@@ -27,7 +27,7 @@ 
#include <media/audiohal/AudioEffectUuid.h>

#include <system/audio_effect.h>

#include <system/audio_effects/effect_dynamicsprocessing.h>



#include <Utils.h>

#include <utils/Log.h>



#include "AidlConversionDynamicsProcessing.h"
@@ -47,19 +47,13 @@ using utils::EffectParamWriter; 


status_t AidlConversionDp::setParameter(EffectParamReader& param) {

    uint32_t type = 0;

    if (OK != param.readFromParameter(&type)) {

        ALOGE("%s invalid param %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&type));

    Parameter aidlParam;

    switch (type) {

        case DP_PARAM_INPUT_GAIN: {

            DynamicsProcessing::InputGain inputGainAidl;

            if (OK != param.readFromParameter(&inputGainAidl.channel) ||

                OK != param.readFromValue(&inputGainAidl.gainDb)) {

                ALOGE("%s invalid inputGain %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.readFromParameter(&inputGainAidl.channel));

            RETURN_STATUS_IF_ERROR(param.readFromValue(&inputGainAidl.gainDb));

            aidlParam = MAKE_SPECIFIC_PARAMETER(DynamicsProcessing, dynamicsProcessing, inputGain,

                                                {inputGainAidl});

            break;
@@ -132,17 +126,12 @@ status_t AidlConversionDp::setParameter(EffectParamReader& param) { 


status_t AidlConversionDp::getParameter(EffectParamWriter& param) {

    uint32_t type = 0;

    if (OK != param.readFromParameter(&type)) {

        ALOGE("%s invalid param %s", __func__, param.toString().c_str());

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&type));

    Parameter aidlParam;

    switch (type) {

        case DP_PARAM_INPUT_GAIN: {

            int32_t channel;

            if (OK != param.readFromParameter(&channel)) {

                ALOGE("%s invalid inputGain %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.readFromParameter(&channel));

            Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag,

                                                          DynamicsProcessing::inputGain);

            RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
@@ -161,11 +150,6 @@ status_t AidlConversionDp::getParameter(EffectParamWriter& param) { 
            return BAD_VALUE;

        }

        case DP_PARAM_ENGINE_ARCHITECTURE: {

            int32_t channel;

            if (OK != param.readFromParameter(&channel)) {

                ALOGE("%s invalid inputGain %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag,

                                                          DynamicsProcessing::engineArchitecture);

            RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
@@ -186,18 +170,15 @@ status_t AidlConversionDp::getParameter(EffectParamWriter& param) { 
                    VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(engine.postEqStage.inUse));

            int32_t limiterInUse =

                    VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(engine.limiterInUse));

            if (OK != param.writeToValue(&resolution) ||

                OK != param.writeToValue(&engine.preferredProcessingDurationMs) ||

                OK != param.writeToValue(&preEqInUse) ||

                OK != param.writeToValue(&engine.preEqStage.bandCount) ||

                OK != param.writeToValue(&mbcInUse) ||

                OK != param.writeToValue(&engine.mbcStage.bandCount) ||

                OK != param.writeToValue(&postEqInUse) ||

                OK != param.writeToValue(&engine.postEqStage.bandCount) ||

                OK != param.writeToValue(&limiterInUse)) {

                ALOGE("%s invalid engineArchitecture %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.writeToValue(&resolution));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&engine.preferredProcessingDurationMs));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&preEqInUse));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&engine.preEqStage.bandCount));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&mbcInUse));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&engine.mbcStage.bandCount));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&postEqInUse));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&engine.postEqStage.bandCount));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&limiterInUse));

            mEngine = engine;

            return OK;

        }
@@ -223,14 +204,9 @@ status_t AidlConversionDp::getParameter(EffectParamWriter& param) { 
            return getLimiterConfig(param);

        }

        case DP_PARAM_GET_CHANNEL_COUNT: {

            uint32_t channel = VALUE_OR_RETURN_STATUS(

                    aidl::android::aidl2legacy_AudioChannelLayout_audio_channel_mask_t(

                            mCommon.input.base.channelMask, true /* input */));

            if (OK != param.writeToValue(&channel)) {

                ALOGE("%s write channel number %d to param failed %s", __func__, channel,

                      param.toString().c_str());

                return BAD_VALUE;

            }

            uint32_t channel = ::android::hardware::audio::common::getChannelCount(

                    mCommon.input.base.channelMask);

            RETURN_STATUS_IF_ERROR(param.writeToValue(&channel));

            return OK;

        }

        default: {
@@ -243,10 +219,9 @@ status_t AidlConversionDp::getParameter(EffectParamWriter& param) { 
aidl::ConversionResult<DynamicsProcessing::ChannelConfig>

AidlConversionDp::readChannelConfigFromParam(EffectParamReader& param) {

    int32_t enable, channel;

    if (OK != param.readFromParameter(&channel) || OK != param.readFromValue(&enable)) {

        ALOGE("%s invalid channel config param %s", __func__, param.toString().c_str());

        return ::android::base::unexpected(::android::BAD_VALUE);

    }

    RETURN_IF_ERROR(param.readFromParameter(&channel));

    RETURN_IF_ERROR(param.readFromValue(&enable));



    return DynamicsProcessing::ChannelConfig(

            {.enable = VALUE_OR_RETURN(convertIntegral<bool>(enable)), .channel = channel});

}
@@ -255,14 +230,12 @@ aidl::ConversionResult<DynamicsProcessing::EqBandConfig> 
AidlConversionDp::readEqBandConfigFromParam(EffectParamReader& param) {

    DynamicsProcessing::EqBandConfig config;

    int32_t enable;

    if (OK != param.readFromParameter(&config.channel) ||

        OK != param.readFromParameter(&config.band) ||

        OK != param.readFromValue(&enable) ||

        OK != param.readFromValue(&config.cutoffFrequencyHz) ||

        OK != param.readFromValue(&config.gainDb)) {

        ALOGE("%s invalid eq band param %s", __func__, param.toString().c_str());

        return ::android::base::unexpected(::android::BAD_VALUE);

    }

    RETURN_IF_ERROR(param.readFromParameter(&config.channel));

    RETURN_IF_ERROR(param.readFromParameter(&config.band));

    RETURN_IF_ERROR(param.readFromValue(&enable));

    RETURN_IF_ERROR(param.readFromValue(&config.cutoffFrequencyHz));

    RETURN_IF_ERROR(param.readFromValue(&config.gainDb));



    config.enable = VALUE_OR_RETURN(convertIntegral<bool>(enable));

    return config;

}
@@ -271,22 +244,20 @@ aidl::ConversionResult<DynamicsProcessing::MbcBandConfig> 
AidlConversionDp::readMbcBandConfigFromParam(EffectParamReader& param) {

    DynamicsProcessing::MbcBandConfig config;

    int32_t enable;

    if (OK != param.readFromParameter(&config.channel) ||

        OK != param.readFromParameter(&config.band) ||

        OK != param.readFromValue(&enable) ||

        OK != param.readFromValue(&config.cutoffFrequencyHz) ||

        OK != param.readFromValue(&config.attackTimeMs) ||

        OK != param.readFromValue(&config.releaseTimeMs) ||

        OK != param.readFromValue(&config.ratio) ||

        OK != param.readFromValue(&config.thresholdDb) ||

        OK != param.readFromValue(&config.kneeWidthDb) ||

        OK != param.readFromValue(&config.noiseGateThresholdDb) ||

        OK != param.readFromValue(&config.expanderRatio) ||

        OK != param.readFromValue(&config.preGainDb) ||

        OK != param.readFromValue(&config.postGainDb)) {

        ALOGE("%s invalid mbc band config param %s", __func__, param.toString().c_str());

        return ::android::base::unexpected(::android::BAD_VALUE);

    }

    RETURN_IF_ERROR(param.readFromParameter(&config.channel));

    RETURN_IF_ERROR(param.readFromParameter(&config.band));

    RETURN_IF_ERROR(param.readFromValue(&enable));

    RETURN_IF_ERROR(param.readFromValue(&config.cutoffFrequencyHz));

    RETURN_IF_ERROR(param.readFromValue(&config.attackTimeMs));

    RETURN_IF_ERROR(param.readFromValue(&config.releaseTimeMs));

    RETURN_IF_ERROR(param.readFromValue(&config.ratio));

    RETURN_IF_ERROR(param.readFromValue(&config.thresholdDb));

    RETURN_IF_ERROR(param.readFromValue(&config.kneeWidthDb));

    RETURN_IF_ERROR(param.readFromValue(&config.noiseGateThresholdDb));

    RETURN_IF_ERROR(param.readFromValue(&config.expanderRatio));

    RETURN_IF_ERROR(param.readFromValue(&config.preGainDb));

    RETURN_IF_ERROR(param.readFromValue(&config.postGainDb));



    config.enable = VALUE_OR_RETURN(convertIntegral<bool>(enable));

    return config;

}
@@ -295,18 +266,16 @@ aidl::ConversionResult<DynamicsProcessing::LimiterConfig> 
AidlConversionDp::readLimiterConfigFromParam(EffectParamReader& param) {

    DynamicsProcessing::LimiterConfig config;

    int32_t enable, inUse;

    if (OK != param.readFromParameter(&config.channel) ||

        OK != param.readFromValue(&inUse) ||

        OK != param.readFromValue(&enable) ||

        OK != param.readFromValue(&config.linkGroup) ||

        OK != param.readFromValue(&config.attackTimeMs) ||

        OK != param.readFromValue(&config.releaseTimeMs) ||

        OK != param.readFromValue(&config.ratio) ||

        OK != param.readFromValue(&config.thresholdDb) ||

        OK != param.readFromValue(&config.postGainDb)) {

        ALOGE("%s invalid limiter config param %s", __func__, param.toString().c_str());

        return ::android::base::unexpected(::android::BAD_VALUE);

    }

    RETURN_IF_ERROR(param.readFromParameter(&config.channel));

    RETURN_IF_ERROR(param.readFromValue(&inUse));

    RETURN_IF_ERROR(param.readFromValue(&enable));

    RETURN_IF_ERROR(param.readFromValue(&config.linkGroup));

    RETURN_IF_ERROR(param.readFromValue(&config.attackTimeMs));

    RETURN_IF_ERROR(param.readFromValue(&config.releaseTimeMs));

    RETURN_IF_ERROR(param.readFromValue(&config.ratio));

    RETURN_IF_ERROR(param.readFromValue(&config.thresholdDb));

    RETURN_IF_ERROR(param.readFromValue(&config.postGainDb));



    config.enable = VALUE_OR_RETURN(convertIntegral<bool>(enable));

    return config;

}
@@ -315,18 +284,15 @@ aidl::ConversionResult<DynamicsProcessing::EngineArchitecture> 
AidlConversionDp::readEngineArchitectureFromParam(EffectParamReader& param) {

    DynamicsProcessing::EngineArchitecture engine;

    int32_t variant, preEqInUse, mbcInUse, postEqInUse, limiterInUse;

    if (OK != param.readFromValue(&variant) &&

        OK != param.readFromValue(&engine.preferredProcessingDurationMs) &&

        OK != param.readFromValue(&preEqInUse) &&

        OK != param.readFromValue(&engine.preEqStage.bandCount) &&

        OK != param.readFromValue(&mbcInUse) &&

        OK != param.readFromValue(&engine.mbcStage.bandCount) &&

        OK != param.readFromValue(&postEqInUse) &&

        OK != param.readFromValue(&engine.postEqStage.bandCount) &&

        OK != param.readFromValue(&limiterInUse)) {

        ALOGE("%s invalid engineArchitecture %s", __func__, param.toString().c_str());

        return ::android::base::unexpected(::android::BAD_VALUE);

    }

    RETURN_IF_ERROR(param.readFromValue(&variant));

    RETURN_IF_ERROR(param.readFromValue(&engine.preferredProcessingDurationMs));

    RETURN_IF_ERROR(param.readFromValue(&preEqInUse));

    RETURN_IF_ERROR(param.readFromValue(&engine.preEqStage.bandCount));

    RETURN_IF_ERROR(param.readFromValue(&mbcInUse));

    RETURN_IF_ERROR(param.readFromValue(&engine.mbcStage.bandCount));

    RETURN_IF_ERROR(param.readFromValue(&postEqInUse));

    RETURN_IF_ERROR(param.readFromValue(&engine.postEqStage.bandCount));

    RETURN_IF_ERROR(param.readFromValue(&limiterInUse));



    engine.resolutionPreference = VALUE_OR_RETURN(

            aidl::android::legacy2aidl_int32_DynamicsProcessing_ResolutionPreference(variant));
@@ -339,10 +305,7 @@ AidlConversionDp::readEngineArchitectureFromParam(EffectParamReader& param) { 


status_t AidlConversionDp::getChannelConfig(DynamicsProcessing::Tag tag, EffectParamWriter& param) {

    int32_t channel;

    if (OK != param.readFromParameter(&channel)) {

        ALOGE("%s invalid parameter %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&channel));



    Parameter aidlParam;

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag, tag);
@@ -384,13 +347,9 @@ status_t AidlConversionDp::getChannelConfig(DynamicsProcessing::Tag tag, EffectP 
    for (const auto& ch : channels) {

        if (ch.channel == channel) {

            int32_t enable = ch.enable;

            if (OK != param.writeToValue(&inUse) ||

                OK != param.writeToValue(&enable) ||

                OK != param.writeToValue(&bandCount)) {

                ALOGE("%s failed to write into param value %s", __func__,

                      param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.writeToValue(&inUse));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&enable));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandCount));

            return OK;

        }

    }
@@ -400,10 +359,8 @@ status_t AidlConversionDp::getChannelConfig(DynamicsProcessing::Tag tag, EffectP 


status_t AidlConversionDp::getEqBandConfig(DynamicsProcessing::Tag tag, EffectParamWriter& param) {

    int32_t channel, band;

    if (OK != param.readFromParameter(&channel) || OK != param.readFromParameter(&band)) {

        ALOGE("%s invalid parameter %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&channel));

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&band));



    Parameter aidlParam;

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag, tag);
@@ -425,12 +382,9 @@ status_t AidlConversionDp::getEqBandConfig(DynamicsProcessing::Tag tag, EffectPa 
    for (const auto& bandIt : bands) {

        if (bandIt.channel == channel && bandIt.band == band) {

            int32_t enable = bandIt.enable;

            if (OK != param.writeToValue(&enable) ||

                OK != param.writeToValue(&bandIt.cutoffFrequencyHz) ||

                OK != param.writeToValue(&bandIt.gainDb)) {

                ALOGE("%s failed to write into param value %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.writeToValue(&enable));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.cutoffFrequencyHz));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.gainDb));

            return OK;

        }

    }
@@ -440,10 +394,8 @@ status_t AidlConversionDp::getEqBandConfig(DynamicsProcessing::Tag tag, EffectPa 


status_t AidlConversionDp::getMbcBandConfig(EffectParamWriter& param) {

    int32_t channel, band;

    if (OK != param.readFromParameter(&channel) || OK != param.readFromParameter(&band)) {

        ALOGE("%s invalid parameter %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&channel));

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&band));

    Parameter aidlParam;

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag,

                                                  DynamicsProcessing::mbcBand);
@@ -457,20 +409,17 @@ status_t AidlConversionDp::getMbcBandConfig(EffectParamWriter& param) { 
    for (const auto& bandIt : bands) {

        if (bandIt.channel == channel && bandIt.band == band) {

            int32_t enable = bandIt.enable;

            if (OK != param.writeToValue(&enable) ||

                OK != param.writeToValue(&bandIt.cutoffFrequencyHz) ||

                OK != param.writeToValue(&bandIt.attackTimeMs) ||

                OK != param.writeToValue(&bandIt.releaseTimeMs) ||

                OK != param.writeToValue(&bandIt.ratio) ||

                OK != param.writeToValue(&bandIt.thresholdDb) ||

                OK != param.writeToValue(&bandIt.kneeWidthDb) ||

                OK != param.writeToValue(&bandIt.noiseGateThresholdDb) ||

                OK != param.writeToValue(&bandIt.expanderRatio) ||

                OK != param.writeToValue(&bandIt.preGainDb) ||

                OK != param.writeToValue(&bandIt.postGainDb)) {

                ALOGE("%s failed to write into param value %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.writeToValue(&enable));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.cutoffFrequencyHz));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.attackTimeMs));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.releaseTimeMs));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.ratio));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.thresholdDb));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.kneeWidthDb));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.noiseGateThresholdDb));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.expanderRatio));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.preGainDb));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&bandIt.postGainDb));

            return OK;

        }

    }
@@ -480,10 +429,7 @@ status_t AidlConversionDp::getMbcBandConfig(EffectParamWriter& param) { 


status_t AidlConversionDp::getLimiterConfig(EffectParamWriter& param) {

    int32_t channel;

    if (OK != param.readFromParameter(&channel)) {

        ALOGE("%s invalid parameter %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    RETURN_STATUS_IF_ERROR(param.readFromParameter(&channel));

    Parameter aidlParam;

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(DynamicsProcessing, dynamicsProcessingTag,

                                                  DynamicsProcessing::limiter);
@@ -498,17 +444,14 @@ status_t AidlConversionDp::getLimiterConfig(EffectParamWriter& param) { 
        if (config.channel == channel) {

            int32_t inUse = mEngine.limiterInUse;

            int32_t enable = config.enable;

            if (OK != param.writeToValue(&inUse) ||

                OK != param.writeToValue(&enable) ||

                OK != param.writeToValue(&config.linkGroup) ||

                OK != param.writeToValue(&config.attackTimeMs) ||

                OK != param.writeToValue(&config.releaseTimeMs) ||

                OK != param.writeToValue(&config.ratio) ||

                OK != param.writeToValue(&config.thresholdDb) ||

                OK != param.writeToValue(&config.postGainDb)) {

                ALOGE("%s failed to write into param value %s", __func__, param.toString().c_str());

                return BAD_VALUE;

            }

            RETURN_STATUS_IF_ERROR(param.writeToValue(&inUse));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&enable));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.linkGroup));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.attackTimeMs));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.releaseTimeMs));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.ratio));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.thresholdDb));

            RETURN_STATUS_IF_ERROR(param.writeToValue(&config.postGainDb));

            return OK;

        }

    }

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp

+1 −0
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ void DynamicsProcessingContext::reset() { 
RetCode DynamicsProcessingContext::setCommon(const Parameter::Common& common) {

    mCommon = common;

    init();

    LOG(INFO) << __func__ << common.toString();

    return RetCode::SUCCESS;

}