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

Commit 20bdf7d8 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "DynamicsProcessing: Add range limits for dynamics processing effect... 

Merge "DynamicsProcessing: Add range limits for dynamics processing effect params" am: c1071179 am: 1884aeac am: 961df213

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



Change-Id: Ibe1dee008fe3151e2734c00082b91859344fef12
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 0abc5c74 961df213

media/libeffects/dynamicsproc/Android.bp

+4 −0
Original line number Diff line number Diff line
@@ -92,6 +92,10 @@ cc_library_shared { 
        "dynamicsprocessingdefaults",

    ],



    static_libs: [

        "libaudioaidlranges",

    ],



    visibility: [

        "//hardware/interfaces/audio/aidl/default",

    ],

media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp

+126 −18
Original line number Diff line number Diff line
@@ -62,32 +62,135 @@ namespace aidl::android::hardware::audio::effect { 


const std::string DynamicsProcessingImpl::kEffectName = "DynamicsProcessing";



const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMin =

static const Range::DynamicsProcessingRange kEngineConfigRange = {

        .min = DynamicsProcessing::make<

                DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(

                {.resolutionPreference =

                         DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,

                 .preferredProcessingDurationMs = 0,

                 .preEqStage = {.inUse = false, .bandCount = 0},

                 .postEqStage = {.inUse = false, .bandCount = 0},

                 .mbcStage = {.inUse = false, .bandCount = 0},

                 .limiterInUse = false})),

        .max = DynamicsProcessing::make<

                DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(

                {.resolutionPreference =

                         DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,

                 .preferredProcessingDurationMs = std::numeric_limits<float>::max(),

                 .preEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},

                 .postEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},

                 .mbcStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},

                 .limiterInUse = true}))};



static const DynamicsProcessing::ChannelConfig kChannelConfigMin =

        DynamicsProcessing::ChannelConfig({.channel = 0, .enable = false});



static const DynamicsProcessing::ChannelConfig kChannelConfigMax =

        DynamicsProcessing::ChannelConfig(

                {.channel = std::numeric_limits<int>::max(), .enable = true});



static const Range::DynamicsProcessingRange kPreEqChannelConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMax})};



static const Range::DynamicsProcessingRange kPostEqChannelConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMax})};



static const Range::DynamicsProcessingRange kMbcChannelConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMax})};



static const DynamicsProcessing::EqBandConfig kEqBandConfigMin =

        DynamicsProcessing::EqBandConfig({.channel = 0,

                                          .band = 0,

                                          .enable = false,

                                          .cutoffFrequencyHz = 220,

                                          .gainDb = std::numeric_limits<float>::min()});

const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMax =

                                          .gainDb = std::numeric_limits<float>::lowest()});



static const DynamicsProcessing::EqBandConfig kEqBandConfigMax =

        DynamicsProcessing::EqBandConfig({.channel = std::numeric_limits<int>::max(),

                                          .band = std::numeric_limits<int>::max(),

                                          .enable = true,

                                          .cutoffFrequencyHz = 20000,

                                          .gainDb = std::numeric_limits<float>::max()});

const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPreEqBandRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(

                {DynamicsProcessingImpl::kEqBandConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(

                {DynamicsProcessingImpl::kEqBandConfigMax})};

const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPostEqBandRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(

                {DynamicsProcessingImpl::kEqBandConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(

                {DynamicsProcessingImpl::kEqBandConfigMax})};

const Range DynamicsProcessingImpl::kRange =

        Range::make<Range::dynamicsProcessing>({DynamicsProcessingImpl::kPreEqBandRange});



const Capability DynamicsProcessingImpl::kCapability = {.range = {DynamicsProcessingImpl::kRange}};



static const Range::DynamicsProcessingRange kPreEqBandConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMax})};



static const Range::DynamicsProcessingRange kPostEqBandConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMin}),

        .max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMax})};



static const Range::DynamicsProcessingRange kMbcBandConfigRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(

                {DynamicsProcessing::MbcBandConfig(

                        {.channel = 0,

                         .band = 0,

                         .enable = false,

                         .cutoffFrequencyHz = 220,

                         .attackTimeMs = 0,

                         .releaseTimeMs = 0,

                         .ratio = 0,

                         .thresholdDb = std::numeric_limits<float>::lowest(),

                         .kneeWidthDb = 0,

                         .noiseGateThresholdDb = std::numeric_limits<float>::lowest(),

                         .expanderRatio = 0,

                         .preGainDb = std::numeric_limits<float>::lowest(),

                         .postGainDb = std::numeric_limits<float>::lowest()})}),

        .max = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(

                {DynamicsProcessing::MbcBandConfig(

                        {.channel = std::numeric_limits<int>::max(),

                         .band = std::numeric_limits<int>::max(),

                         .enable = true,

                         .cutoffFrequencyHz = 20000,

                         .attackTimeMs = std::numeric_limits<float>::max(),

                         .releaseTimeMs = std::numeric_limits<float>::max(),

                         .ratio = std::numeric_limits<float>::max(),

                         .thresholdDb = 0,

                         .kneeWidthDb = std::numeric_limits<float>::max(),

                         .noiseGateThresholdDb = 0,

                         .expanderRatio = std::numeric_limits<float>::max(),

                         .preGainDb = std::numeric_limits<float>::max(),

                         .postGainDb = std::numeric_limits<float>::max()})})};



static const Range::DynamicsProcessingRange kInputGainRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::inputGain>(

                {DynamicsProcessing::InputGain(

                        {.channel = 0, .gainDb = std::numeric_limits<float>::lowest()})}),

        .max = DynamicsProcessing::make<DynamicsProcessing::inputGain>(

                {DynamicsProcessing::InputGain({.channel = std::numeric_limits<int>::max(),

                                                .gainDb = std::numeric_limits<float>::max()})})};



static const Range::DynamicsProcessingRange kLimiterRange = {

        .min = DynamicsProcessing::make<DynamicsProcessing::limiter>(

                {DynamicsProcessing::LimiterConfig(

                        {.channel = 0,

                         .enable = false,

                         .linkGroup = std::numeric_limits<int>::min(),

                         .attackTimeMs = 0,

                         .releaseTimeMs = 0,

                         .ratio = 0,

                         .thresholdDb = std::numeric_limits<float>::min(),

                         .postGainDb = std::numeric_limits<float>::min()})}),

        .max = DynamicsProcessing::make<DynamicsProcessing::limiter>(

                {DynamicsProcessing::LimiterConfig(

                        {.channel = std::numeric_limits<int>::max(),

                         .enable = true,

                         .linkGroup = std::numeric_limits<int>::max(),

                         .attackTimeMs = std::numeric_limits<float>::max(),

                         .releaseTimeMs = std::numeric_limits<float>::max(),

                         .ratio = std::numeric_limits<float>::max(),

                         .thresholdDb = 0,

                         .postGainDb = std::numeric_limits<float>::max()})})};



const std::vector<Range::DynamicsProcessingRange> kRanges = {

        kEngineConfigRange,     kPreEqChannelConfigRange, kPostEqChannelConfigRange,

        kMbcChannelConfigRange, kPreEqBandConfigRange,    kPostEqBandConfigRange,

        kMbcBandConfigRange,    kInputGainRange,          kLimiterRange};



const Capability DynamicsProcessingImpl::kCapability = {.range = kRanges};



const Descriptor DynamicsProcessingImpl::kDescriptor = {

        .common = {.id = {.type = getEffectTypeUuidDynamicsProcessing(),
@@ -158,14 +261,19 @@ ndk::ScopedAStatus DynamicsProcessingImpl::commandImpl(CommandId command) { 
    }

}



bool DynamicsProcessingImpl::isParamInRange(const Parameter::Specific& specific) {

    auto& dp = specific.get<Parameter::Specific::dynamicsProcessing>();

    return DynamicsProcessingRanges::isParamInRange(dp, kRanges);

}



ndk::ScopedAStatus DynamicsProcessingImpl::setParameterSpecific(

        const Parameter::Specific& specific) {

    RETURN_IF(Parameter::Specific::dynamicsProcessing != specific.getTag(), EX_ILLEGAL_ARGUMENT,

              "EffectNotSupported");

    RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");



    RETURN_IF(!isParamInRange(specific), EX_ILLEGAL_ARGUMENT, "outOfRange");

    auto& param = specific.get<Parameter::Specific::dynamicsProcessing>();

    // TODO: check range here, dynamicsProcessing need customized method for nested parameters.

    auto tag = param.getTag();



    switch (tag) {

media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h

+3 −6
Original line number Diff line number Diff line
@@ -18,8 +18,9 @@ 


#include <aidl/android/hardware/audio/effect/BnEffect.h>



#include "effect-impl/EffectImpl.h"

#include "DynamicsProcessingContext.h"

#include "EffectRangeSpecific.h"

#include "effect-impl/EffectImpl.h"



namespace aidl::android::hardware::audio::effect {
@@ -51,14 +52,10 @@ class DynamicsProcessingImpl final : public EffectImpl { 
    std::string getEffectName() override { return kEffectName; }



  private:

    static const DynamicsProcessing::EqBandConfig kEqBandConfigMin;

    static const DynamicsProcessing::EqBandConfig kEqBandConfigMax;

    static const Range::DynamicsProcessingRange kPreEqBandRange;

    static const Range::DynamicsProcessingRange kPostEqBandRange;

    static const Range kRange;

    std::shared_ptr<DynamicsProcessingContext> mContext;

    ndk::ScopedAStatus getParameterDynamicsProcessing(const DynamicsProcessing::Tag& tag,

                                                      Parameter::Specific* specific);

    bool isParamInRange(const Parameter::Specific& specific);

};



}  // namespace aidl::android::hardware::audio::effect

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp

+47 −63
Original line number Diff line number Diff line
@@ -16,11 +16,11 @@ 


#define LOG_TAG "AHAL_DPLibEffectsContext"



#include "DynamicsProcessing.h"

#include "DynamicsProcessingContext.h"

#include "DynamicsProcessing.h"



#include <functional>

#include <sys/param.h>

#include <functional>

#include <unordered_set>



namespace aidl::android::hardware::audio::effect {
@@ -91,9 +91,6 @@ void DynamicsProcessingContext::dpSetFreqDomainVariant_l( 


RetCode DynamicsProcessingContext::setEngineArchitecture(

        const DynamicsProcessing::EngineArchitecture& engineArchitecture) {

    RETURN_VALUE_IF(!validateEngineConfig(engineArchitecture), RetCode::ERROR_ILLEGAL_PARAMETER,

                    "illegalEngineConfig");



    std::lock_guard lg(mMutex);

    if (!mEngineInited || mEngineArchitecture != engineArchitecture) {

        if (engineArchitecture.resolutionPreference ==
@@ -134,10 +131,12 @@ RetCode DynamicsProcessingContext::setMbc( 
RetCode DynamicsProcessingContext::setPreEqBand(

        const std::vector<DynamicsProcessing::EqBandConfig>& bands) {

    std::lock_guard lg(mMutex);

    RETURN_VALUE_IF(!mEngineArchitecture.postEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "postEqNotInUse");

    return setBands_l<DynamicsProcessing::EqBandConfig>(

            bands, mEngineArchitecture.preEqStage.bandCount, StageType::PREEQ);

    RETURN_VALUE_IF(!mEngineArchitecture.preEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "preEqNotInUse");

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.preEqStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

    return setBands_l<DynamicsProcessing::EqBandConfig>(bands, StageType::PREEQ);

}



RetCode DynamicsProcessingContext::setPostEqBand(
@@ -145,8 +144,10 @@ RetCode DynamicsProcessingContext::setPostEqBand( 
    std::lock_guard lg(mMutex);

    RETURN_VALUE_IF(!mEngineArchitecture.postEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "postEqNotInUse");

    return setBands_l<DynamicsProcessing::EqBandConfig>(

            bands, mEngineArchitecture.postEqStage.bandCount, StageType::POSTEQ);

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.postEqStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

    return setBands_l<DynamicsProcessing::EqBandConfig>(bands, StageType::POSTEQ);

}



RetCode DynamicsProcessingContext::setMbcBand(
@@ -154,8 +155,10 @@ RetCode DynamicsProcessingContext::setMbcBand( 
    std::lock_guard lg(mMutex);

    RETURN_VALUE_IF(!mEngineArchitecture.mbcStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "mbcNotInUse");

    return setBands_l<DynamicsProcessing::MbcBandConfig>(

            bands, mEngineArchitecture.preEqStage.bandCount, StageType::MBC);

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.mbcStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

    return setBands_l<DynamicsProcessing::MbcBandConfig>(bands, StageType::MBC);

}



RetCode DynamicsProcessingContext::setLimiter(
@@ -163,13 +166,17 @@ RetCode DynamicsProcessingContext::setLimiter( 
    std::lock_guard lg(mMutex);

    RETURN_VALUE_IF(!mEngineArchitecture.limiterInUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "limiterNotInUse");

    return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, -1, StageType::LIMITER);

    RETURN_VALUE_IF(!validateLimiterConfig(limiters, mChannelCount),

                    RetCode::ERROR_ILLEGAL_PARAMETER, "limiterConfigNotValid");

    return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, StageType::LIMITER);

}



RetCode DynamicsProcessingContext::setInputGain(

        const std::vector<DynamicsProcessing::InputGain>& inputGains) {

    std::lock_guard lg(mMutex);

    return setBands_l<DynamicsProcessing::InputGain>(inputGains, -1, StageType::INPUTGAIN);

    RETURN_VALUE_IF(!validateInputGainConfig(inputGains, mChannelCount),

                    RetCode::ERROR_ILLEGAL_PARAMETER, "inputGainNotValid");

    return setBands_l<DynamicsProcessing::InputGain>(inputGains, StageType::INPUTGAIN);

}



DynamicsProcessing::EngineArchitecture DynamicsProcessingContext::getEngineArchitecture() {
@@ -406,45 +413,33 @@ std::vector<DynamicsProcessing::EqBandConfig> DynamicsProcessingContext::getEqBa 
    return eqBands;

}



/**

 * When StageEnablement is in use, bandCount needs to be positive.

 */

bool DynamicsProcessingContext::validateStageEnablement(

        const DynamicsProcessing::StageEnablement& enablement) {

    return !enablement.inUse || (enablement.inUse && enablement.bandCount > 0);

template <typename T>

bool DynamicsProcessingContext::validateBandConfig(const std::vector<T>& bands, int maxChannel,

                                                   int maxBand) {

    std::vector<float> freqs(bands.size(), -1);

    for (auto band : bands) {

        if (!validateChannel(band.channel, maxChannel)) return false;

        if (!validateBand(band.band, maxBand)) return false;

        freqs[band.band] = band.cutoffFrequencyHz;

    }



bool DynamicsProcessingContext::validateEngineConfig(

        const DynamicsProcessing::EngineArchitecture& engine) {

    return engine.preferredProcessingDurationMs >= 0 &&

           validateStageEnablement(engine.preEqStage) &&

           validateStageEnablement(engine.postEqStage) && validateStageEnablement(engine.mbcStage);

    if (std::count(freqs.begin(), freqs.end(), -1)) return false;

    return std::is_sorted(freqs.begin(), freqs.end());

}



bool DynamicsProcessingContext::validateEqBandConfig(const DynamicsProcessing::EqBandConfig& band,

                                                     int maxChannel, int maxBand) {

    return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand);

bool DynamicsProcessingContext::validateLimiterConfig(

        const std::vector<DynamicsProcessing::LimiterConfig>& cfgs, int maxChannel) {

    for (auto cfg : cfgs) {

        if (!validateChannel(cfg.channel, maxChannel)) return false;

    }



bool DynamicsProcessingContext::validateMbcBandConfig(const DynamicsProcessing::MbcBandConfig& band,

                                                      int maxChannel, int maxBand) {

    return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand) &&

           validateTime(band.attackTimeMs) && validateTime(band.releaseTimeMs) &&

           validateRatio(band.ratio) && validateBandDb(band.thresholdDb) &&

           validateBandDb(band.kneeWidthDb) && validateBandDb(band.noiseGateThresholdDb) &&

           validateRatio(band.expanderRatio);

    return true;

}



bool DynamicsProcessingContext::validateLimiterConfig(

        const DynamicsProcessing::LimiterConfig& limiter, int maxChannel) {

    return validateChannel(limiter.channel, maxChannel) && validateTime(limiter.attackTimeMs) &&

           validateTime(limiter.releaseTimeMs) && validateRatio(limiter.ratio) &&

           validateBandDb(limiter.thresholdDb);

bool DynamicsProcessingContext::validateInputGainConfig(

        const std::vector<DynamicsProcessing::InputGain>& cfgs, int maxChannel) {

    for (auto cfg : cfgs) {

        if (!validateChannel(cfg.channel, maxChannel)) return false;

    }



bool DynamicsProcessingContext::validateInputGainConfig(const DynamicsProcessing::InputGain& gain,

                                                        int maxChannel) {

    return validateChannel(gain.channel, maxChannel);

    return true;

}



template <typename D>
@@ -483,7 +478,6 @@ RetCode DynamicsProcessingContext::setDpChannels_l( 
}



RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, StageType type,

                                                      int maxCh, int maxBand,

                                                      std::set<std::pair<int, int>>& chBandSet) {

    RETURN_VALUE_IF(!anyConfig.has_value(), RetCode::ERROR_ILLEGAL_PARAMETER, "bandInvalid");

    RetCode ret = RetCode::SUCCESS;
@@ -494,8 +488,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, 
        case StageType::POSTEQ: {

            dp_fx::DPEq* dp;

            const auto& config = std::any_cast<DynamicsProcessing::EqBandConfig>(anyConfig);

            RETURN_VALUE_IF(!validateEqBandConfig(config, maxCh, maxBand),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

            RETURN_VALUE_IF(

                    nullptr == (dp = getEqWithType_l(type, config.channel)) || !dp->isEnabled(),

                    RetCode::ERROR_ILLEGAL_PARAMETER, "dpEqNotExist");
@@ -508,8 +500,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, 
        case StageType::MBC: {

            dp_fx::DPMbc* dp;

            const auto& config = std::any_cast<DynamicsProcessing::MbcBandConfig>(anyConfig);

            RETURN_VALUE_IF(!validateMbcBandConfig(config, maxCh, maxBand),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "mbcBandNotValid");

            RETURN_VALUE_IF(nullptr == (dp = getMbc_l(config.channel)) || !dp->isEnabled(),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "dpMbcNotExist");

            dp_fx::DPMbcBand band;
@@ -524,8 +514,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, 
        case StageType::LIMITER: {

            dp_fx::DPChannel* dp;

            const auto& config = std::any_cast<DynamicsProcessing::LimiterConfig>(anyConfig);

            RETURN_VALUE_IF(!validateLimiterConfig(config, maxCh),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "limiterBandNotValid");

            RETURN_VALUE_IF(nullptr == (dp = getChannel_l(config.channel)),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "dpChNotExist");

            dp_fx::DPLimiter limiter;
@@ -539,8 +527,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, 
        case StageType::INPUTGAIN: {

            dp_fx::DPChannel* dp;

            const auto& config = std::any_cast<DynamicsProcessing::InputGain>(anyConfig);

            RETURN_VALUE_IF(!validateInputGainConfig(config, maxCh),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "inputGainNotValid");

            RETURN_VALUE_IF(nullptr == (dp = getChannel_l(config.channel)),

                            RetCode::ERROR_ILLEGAL_PARAMETER, "dpChNotExist");

            dp->setInputGain(config.gainDb);
@@ -555,14 +541,12 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, 
}



template <typename T /* BandConfig */>

RetCode DynamicsProcessingContext::setBands_l(

        const std::vector<T>& bands, int maxBand, StageType type) {

RetCode DynamicsProcessingContext::setBands_l(const std::vector<T>& bands, StageType type) {

    RetCode ret = RetCode::SUCCESS;

    std::set<std::pair<int /* channel */, int /* band */>> bandSet;



    for (const auto& it : bands) {

        if (RetCode::SUCCESS !=

            setDpChannelBand_l(std::make_any<T>(it), type, mChannelCount, maxBand, bandSet)) {

        if (RetCode::SUCCESS != setDpChannelBand_l(std::make_any<T>(it), type, bandSet)) {

            LOG(WARNING) << __func__ << " skipping band " << it.toString();

            ret = RetCode::ERROR_ILLEGAL_PARAMETER;

            continue;

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.h

+8 −14
Original line number Diff line number Diff line
@@ -103,28 +103,22 @@ class DynamicsProcessingContext final : public EffectContext { 
    RetCode setDpChannels_l(const std::vector<DynamicsProcessing::ChannelConfig>& channels,

                            bool stageInUse, StageType type) REQUIRES(mMutex);

    template <typename T /* BandConfig */>

    RetCode setBands_l(const std::vector<T>& bands, int maxBand, StageType type) REQUIRES(mMutex);

    RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type, int maxCh, int maxBand,

    RetCode setBands_l(const std::vector<T>& bands, StageType type) REQUIRES(mMutex);

    RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type,

                               std::set<std::pair<int, int>>& chBandSet) REQUIRES(mMutex);



    std::vector<DynamicsProcessing::EqBandConfig> getEqBandConfigs(StageType type);

    std::vector<DynamicsProcessing::ChannelConfig> getChannelConfig(StageType type);



    bool validateStageEnablement(const DynamicsProcessing::StageEnablement& enablement);

    bool validateEngineConfig(const DynamicsProcessing::EngineArchitecture& engine);

    bool validateEqBandConfig(const DynamicsProcessing::EqBandConfig& band, int maxChannel,

                              int maxBand);

    bool validateMbcBandConfig(const DynamicsProcessing::MbcBandConfig& band, int maxChannel,

                               int maxBand);

    bool validateLimiterConfig(const DynamicsProcessing::LimiterConfig& limiter, int maxChannel);

    bool validateInputGainConfig(const DynamicsProcessing::InputGain& gain, int maxChannel);

    template <typename T /* BandConfig */>

    bool validateBandConfig(const std::vector<T>& bands, int maxChannel, int maxBand);

    bool validateLimiterConfig(const std::vector<DynamicsProcessing::LimiterConfig>& cfgs,

                               int maxChannel);

    bool validateInputGainConfig(const std::vector<DynamicsProcessing::InputGain>& cfgs,

                                 int maxChannel);



    inline bool validateCutoffFrequency(float freq);

    inline bool validateChannel(int ch, int maxCh) { return ch >= 0 && ch < maxCh; }

    inline bool validateBand(int band, int maxBand) { return band >= 0 && band < maxBand; }

    inline bool validateTime(int time) { return time >= 0; }

    inline bool validateRatio(int ratio) { return ratio >= 0; }

    inline bool validateBandDb(int db) { return db <= 0; }

};



}  // namespace aidl::android::hardware::audio::effect
 
 No newline at end of file