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

Commit 866fab10 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "DynamicsProcessing: Add tests to validate Limiter Config Parameters"... 

Merge "DynamicsProcessing: Add tests to validate Limiter Config Parameters" into main am: f4a7a8f2

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/3298573



Change-Id: I6e76686f79cadf967dd15b9dabe53e7d9448f128
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 6f1e2b96 f4a7a8f2

audio/aidl/vts/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -115,6 +115,9 @@ cc_test { 
    defaults: ["VtsHalAudioEffectTargetTestDefaults"],

    static_libs: ["libaudioaidlranges"],

    srcs: ["VtsHalDynamicsProcessingTest.cpp"],

    shared_libs: [

        "libaudioutils",

    ],

}



cc_test {

audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp

+243 −73
Original line number Diff line number Diff line
@@ -20,6 +20,8 @@ 


#define LOG_TAG "VtsHalDynamicsProcessingTest"

#include <android-base/logging.h>

#include <audio_utils/power.h>

#include <audio_utils/primitives.h>



#include <Utils.h>
@@ -44,26 +46,25 @@ using android::hardware::audio::common::testing::detail::TestExecutionTracer; 
class DynamicsProcessingTestHelper : public EffectHelper {

  public:

    DynamicsProcessingTestHelper(std::pair<std::shared_ptr<IFactory>, Descriptor> pair,

                                 int32_t channelLayOut = AudioChannelLayout::LAYOUT_STEREO) {

                                 int32_t channelLayOut = AudioChannelLayout::LAYOUT_STEREO)

        : mChannelLayout(channelLayOut),

          mChannelCount(::aidl::android::hardware::audio::common::getChannelCount(

                  AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout))) {

        std::tie(mFactory, mDescriptor) = pair;

        mChannelLayout = channelLayOut;

        mChannelCount = ::aidl::android::hardware::audio::common::getChannelCount(

                AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout));

    }



    // setup

    void SetUpDynamicsProcessingEffect() {

        ASSERT_NE(nullptr, mFactory);

        ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));



        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = createParamCommon(

                0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,

                0x100 /* iFrameCount */, 0x100 /* oFrameCount */,

                0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,

                kSamplingFrequency /* oSampleRate */, kFrameCount /* iFrameCount */,

                kFrameCount /* oFrameCount */,

                AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout),

                AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout));

        IEffect::OpenEffectReturn ret;

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE));

        ASSERT_NE(nullptr, mEffect);

        mEngineConfigApplied = mEngineConfigPreset;

    }
@@ -113,6 +114,8 @@ class DynamicsProcessingTestHelper : public EffectHelper { 
    // get set params and validate

    void SetAndGetDynamicsProcessingParameters();



    bool isAllParamsValid();



    // enqueue test parameters

    void addEngineConfig(const DynamicsProcessing::EngineArchitecture& cfg);

    void addPreEqChannelConfig(const std::vector<DynamicsProcessing::ChannelConfig>& cfg);
@@ -126,9 +129,12 @@ class DynamicsProcessingTestHelper : public EffectHelper { 


    static constexpr float kPreferredProcessingDurationMs = 10.0f;

    static constexpr int kBandCount = 5;

    static constexpr int kSamplingFrequency = 44100;

    static constexpr int kFrameCount = 2048;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;

    IEffect::OpenEffectReturn mOpenEffectReturn;

    DynamicsProcessing::EngineArchitecture mEngineConfigApplied;

    DynamicsProcessing::EngineArchitecture mEngineConfigPreset{

            .resolutionPreference =
@@ -148,12 +154,12 @@ class DynamicsProcessingTestHelper : public EffectHelper { 
    static const std::set<DynamicsProcessing::StageEnablement> kStageEnablementTestSet;

    static const std::set<std::vector<DynamicsProcessing::InputGain>> kInputGainTestSet;



  protected:

    int mChannelCount;



  private:

    int32_t mChannelLayout;

    const int32_t mChannelLayout;

    std::vector<std::pair<DynamicsProcessing::Tag, DynamicsProcessing>> mTags;



  protected:

    const int mChannelCount;

    void CleanUp() {

        mTags.clear();

        mPreEqChannelEnable.clear();
@@ -329,10 +335,7 @@ bool DynamicsProcessingTestHelper::isAidlVectorEqualAfterFilter(const std::vecto 
}



void DynamicsProcessingTestHelper::SetAndGetDynamicsProcessingParameters() {

    for (auto& it : mTags) {

        auto& tag = it.first;

        auto& dp = it.second;



    for (const auto& [tag, dp] : mTags) {

        // validate parameter

        Descriptor desc;

        ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
@@ -371,6 +374,22 @@ void DynamicsProcessingTestHelper::SetAndGetDynamicsProcessingParameters() { 
    }

}



bool DynamicsProcessingTestHelper::isAllParamsValid() {

    if (mTags.empty()) {

        return false;

    }

    for (const auto& [tag, dp] : mTags) {

        // validate parameter

        if (!isParamInRange(dp, mDescriptor.capability.range.get<Range::dynamicsProcessing>())) {

            return false;

        }

        if (!isParamValid(tag, dp)) {

            return false;

        }

    }

    return true;

}



void DynamicsProcessingTestHelper::addEngineConfig(

        const DynamicsProcessing::EngineArchitecture& cfg) {

    DynamicsProcessing dp;
@@ -446,6 +465,21 @@ void DynamicsProcessingTestHelper::addInputGain( 
    mTags.push_back({DynamicsProcessing::inputGain, dp});

}



void fillLimiterConfig(std::vector<DynamicsProcessing::LimiterConfig>& limiterConfigList,

                       int channelIndex, bool enable, int linkGroup, float attackTime,

                       float releaseTime, float ratio, float threshold, float postGain) {

    DynamicsProcessing::LimiterConfig cfg;

    cfg.channel = channelIndex;

    cfg.enable = enable;

    cfg.linkGroup = linkGroup;

    cfg.attackTimeMs = attackTime;

    cfg.releaseTimeMs = releaseTime;

    cfg.ratio = ratio;

    cfg.thresholdDb = threshold;

    cfg.postGainDb = postGain;

    limiterConfigList.push_back(cfg);

}



/**

 * Test DynamicsProcessing Engine Configuration

 */
@@ -486,7 +520,7 @@ class DynamicsProcessingTestEngineArchitecture 


TEST_P(DynamicsProcessingTestEngineArchitecture, SetAndGetEngineArch) {

    EXPECT_NO_FATAL_FAILURE(addEngineConfig(mCfg));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



INSTANTIATE_TEST_SUITE_P(
@@ -538,7 +572,7 @@ class DynamicsProcessingTestInputGain 


TEST_P(DynamicsProcessingTestInputGain, SetAndGetInputGain) {

    EXPECT_NO_FATAL_FAILURE(addInputGain(mInputGain));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



INSTANTIATE_TEST_SUITE_P(
@@ -565,40 +599,23 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestInputGain); 
enum LimiterConfigTestParamName {

    LIMITER_INSTANCE_NAME,

    LIMITER_CHANNEL,

    LIMITER_ENABLE,

    LIMITER_LINK_GROUP,

    LIMITER_ADDITIONAL,

};

enum LimiterConfigTestAdditionalParam {

    LIMITER_ATTACK_TIME,

    LIMITER_RELEASE_TIME,

    LIMITER_RATIO,

    LIMITER_THRESHOLD,

    LIMITER_POST_GAIN,

    LIMITER_MAX_NUM,

};

using LimiterConfigTestAdditional = std::array<float, LIMITER_MAX_NUM>;

// attackTime, releaseTime, ratio, thresh, postGain

static constexpr std::array<LimiterConfigTestAdditional, 4> kLimiterConfigTestAdditionalParam = {

        {{-1, -60, -2.5, -2, -3.14},

         {-1, 60, -2.5, 2, -3.14},

         {1, -60, 2.5, -2, 3.14},

         {1, 60, 2.5, -2, 3.14}}};



using LimiterConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,

                                           int32_t, bool, int32_t, LimiterConfigTestAdditional>;

                                           int32_t, int32_t, float, float, float, float, float>;



void fillLimiterConfig(DynamicsProcessing::LimiterConfig& cfg,

void fillLimiterConfig(std::vector<DynamicsProcessing::LimiterConfig>& cfg,

                       const LimiterConfigTestParams& params) {

    const std::array<float, LIMITER_MAX_NUM> additional = std::get<LIMITER_ADDITIONAL>(params);

    cfg.channel = std::get<LIMITER_CHANNEL>(params);

    cfg.enable = std::get<LIMITER_ENABLE>(params);

    cfg.linkGroup = std::get<LIMITER_LINK_GROUP>(params);

    cfg.attackTimeMs = additional[LIMITER_ATTACK_TIME];

    cfg.releaseTimeMs = additional[LIMITER_RELEASE_TIME];

    cfg.ratio = additional[LIMITER_RATIO];

    cfg.thresholdDb = additional[LIMITER_THRESHOLD];

    cfg.postGainDb = additional[LIMITER_POST_GAIN];

    fillLimiterConfig(cfg, std::get<LIMITER_CHANNEL>(params), true,

                      std::get<LIMITER_LINK_GROUP>(params), std::get<LIMITER_ATTACK_TIME>(params),

                      std::get<LIMITER_RELEASE_TIME>(params), std::get<LIMITER_RATIO>(params),

                      std::get<LIMITER_THRESHOLD>(params), std::get<LIMITER_POST_GAIN>(params));

}



class DynamicsProcessingTestLimiterConfig
@@ -607,7 +624,7 @@ class DynamicsProcessingTestLimiterConfig 
  public:

    DynamicsProcessingTestLimiterConfig()

        : DynamicsProcessingTestHelper(std::get<LIMITER_INSTANCE_NAME>(GetParam())) {

        fillLimiterConfig(mCfg, GetParam());

        fillLimiterConfig(mLimiterConfigList, GetParam());

    }



    void SetUp() override { SetUpDynamicsProcessingEffect(); }
@@ -615,36 +632,193 @@ class DynamicsProcessingTestLimiterConfig 
    void TearDown() override { TearDownDynamicsProcessingEffect(); }



    DynamicsProcessing::LimiterConfig mCfg;

    std::vector<DynamicsProcessing::LimiterConfig> mLimiterConfigList;

};



TEST_P(DynamicsProcessingTestLimiterConfig, SetAndGetLimiterConfig) {

    EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));

    EXPECT_NO_FATAL_FAILURE(addLimiterConfig({mCfg}));

    SetAndGetDynamicsProcessingParameters();

    EXPECT_NO_FATAL_FAILURE(addLimiterConfig(mLimiterConfigList));

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



INSTANTIATE_TEST_SUITE_P(

        DynamicsProcessingTest, DynamicsProcessingTestLimiterConfig,

        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                                   IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),

                           testing::Values(-1, 0, 1, 2),                           // channel count

                           testing::Bool(),                                        // enable

                           testing::Values(-1, 0, 1, 2),  // channel index

                           testing::Values(3),            // link group

                           testing::ValuesIn(kLimiterConfigTestAdditionalParam)),  // Additional

                           testing::Values(-1, 1),        // attackTime

                           testing::Values(-60, 60),      // releaseTime

                           testing::Values(-2.5, 2.5),    // ratio

                           testing::Values(-2, 2),        // thresh

                           testing::Values(-3.14, 3.14)   // postGain

                           ),

        [](const auto& info) {

            auto descriptor = std::get<LIMITER_INSTANCE_NAME>(info.param).second;

            DynamicsProcessing::LimiterConfig cfg;

            std::vector<DynamicsProcessing::LimiterConfig> cfg;

            fillLimiterConfig(cfg, info.param);

            std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +

                               descriptor.common.name + "_UUID_" +

                               toString(descriptor.common.id.uuid) + "_limiterConfig_" +

                               cfg.toString();

            std::string name =

                    "Implementer_" + getPrefix(descriptor) + "_limiterConfig_" + cfg[0].toString();

            std::replace_if(

                    name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');

            return name;

        });

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestLimiterConfig);



using LimiterConfigDataTestParams = std::pair<std::shared_ptr<IFactory>, Descriptor>;



class DynamicsProcessingLimiterConfigDataTest

    : public ::testing::TestWithParam<LimiterConfigDataTestParams>,

      public DynamicsProcessingTestHelper {

  public:

    DynamicsProcessingLimiterConfigDataTest()

        : DynamicsProcessingTestHelper(GetParam(), AudioChannelLayout::LAYOUT_MONO) {

        mBufferSize = kFrameCount * mChannelCount;

        mInput.resize(mBufferSize);

        generateSineWave(1000 /*Input Frequency*/, mInput);

        mInputDb = calculateDb(mInput);

    }



    void SetUp() override {

        SetUpDynamicsProcessingEffect();

        SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);

    }



    void TearDown() override { TearDownDynamicsProcessingEffect(); }



    float calculateDb(std::vector<float> input, size_t start = 0) {

        return audio_utils_compute_power_mono(input.data() + start, AUDIO_FORMAT_PCM_FLOAT,

                                              input.size() - start);

    }



    void computeThreshold(float ratio, float outputDb, float& threshold) {

        EXPECT_NE(ratio, 0);

        threshold = (mInputDb - (ratio * outputDb)) / (1 - ratio);

    }



    void computeRatio(float threshold, float outputDb, float& ratio) {

        float inputOverThreshold = mInputDb - threshold;

        float outputOverThreshold = outputDb - threshold;

        EXPECT_NE(outputOverThreshold, 0);

        ratio = inputOverThreshold / outputOverThreshold;

    }



    void setParamsAndProcess(std::vector<float>& output) {

        EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));

        EXPECT_NO_FATAL_FAILURE(addLimiterConfig(mLimiterConfigList));

        ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

        if (isAllParamsValid()) {

            ASSERT_NO_FATAL_FAILURE(

                    processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));

            EXPECT_GT(output.size(), kStartIndex);

        }

        cleanUpLimiterConfig();

    }



    void cleanUpLimiterConfig() {

        CleanUp();

        mLimiterConfigList.clear();

    }

    static constexpr float kDefaultLinkerGroup = 3;

    static constexpr float kDefaultAttackTime = 0;

    static constexpr float kDefaultReleaseTime = 0;

    static constexpr float kDefaultRatio = 4;

    static constexpr float kDefaultThreshold = 0;

    static constexpr float kDefaultPostGain = 0;

    static constexpr int kInputFrequency = 1000;

    static constexpr size_t kStartIndex = 15 * kSamplingFrequency / 1000;  // skip 15ms

    std::vector<DynamicsProcessing::LimiterConfig> mLimiterConfigList;

    std::vector<float> mInput;

    float mInputDb;

    int mBufferSize;

};



TEST_P(DynamicsProcessingLimiterConfigDataTest, IncreasingThresholdDb) {

    std::vector<float> thresholdValues = {-200, -150, -100, -50, -5, 0};

    std::vector<float> output(mInput.size());

    float previousThreshold = -FLT_MAX;

    for (float threshold : thresholdValues) {

        for (int i = 0; i < mChannelCount; i++) {

            fillLimiterConfig(mLimiterConfigList, i, true, kDefaultLinkerGroup, kDefaultAttackTime,

                              kDefaultReleaseTime, kDefaultRatio, threshold, kDefaultPostGain);

        }

        EXPECT_NO_FATAL_FAILURE(setParamsAndProcess(output));

        if (!isAllParamsValid()) {

            continue;

        }

        float outputDb = calculateDb(output, kStartIndex);

        if (threshold >= mInputDb || kDefaultRatio == 1) {

            EXPECT_EQ(std::round(mInputDb), std::round(outputDb));

        } else {

            float calculatedThreshold = 0;

            EXPECT_NO_FATAL_FAILURE(computeThreshold(kDefaultRatio, outputDb, calculatedThreshold));

            ASSERT_GT(calculatedThreshold, previousThreshold);

            previousThreshold = calculatedThreshold;

        }

    }

}



TEST_P(DynamicsProcessingLimiterConfigDataTest, IncreasingRatio) {

    std::vector<float> ratioValues = {1, 10, 20, 30, 40, 50};

    std::vector<float> output(mInput.size());

    float threshold = -10;

    float previousRatio = 0;

    for (float ratio : ratioValues) {

        for (int i = 0; i < mChannelCount; i++) {

            fillLimiterConfig(mLimiterConfigList, i, true, kDefaultLinkerGroup, kDefaultAttackTime,

                              kDefaultReleaseTime, ratio, threshold, kDefaultPostGain);

        }

        EXPECT_NO_FATAL_FAILURE(setParamsAndProcess(output));

        if (!isAllParamsValid()) {

            continue;

        }

        float outputDb = calculateDb(output, kStartIndex);



        if (threshold >= mInputDb) {

            EXPECT_EQ(std::round(mInputDb), std::round(outputDb));

        } else {

            float calculatedRatio = 0;

            EXPECT_NO_FATAL_FAILURE(computeRatio(threshold, outputDb, calculatedRatio));

            ASSERT_GT(calculatedRatio, previousRatio);

            previousRatio = calculatedRatio;

        }

    }

}



TEST_P(DynamicsProcessingLimiterConfigDataTest, LimiterEnableDisable) {

    std::vector<bool> limiterEnableValues = {false, true};

    std::vector<float> output(mInput.size());

    for (bool isEnabled : limiterEnableValues) {

        for (int i = 0; i < mChannelCount; i++) {

            // Set non-default values

            fillLimiterConfig(mLimiterConfigList, i, isEnabled, kDefaultLinkerGroup,

                              5 /*attack time*/, 5 /*release time*/, 10 /*ratio*/,

                              -10 /*threshold*/, 5 /*postgain*/);

        }

        EXPECT_NO_FATAL_FAILURE(setParamsAndProcess(output));

        if (!isAllParamsValid()) {

            continue;

        }

        if (isEnabled) {

            EXPECT_NE(mInputDb, calculateDb(output, kStartIndex));

        } else {

            EXPECT_NEAR(mInputDb, calculateDb(output, kStartIndex), 0.05);

        }

    }

}



INSTANTIATE_TEST_SUITE_P(DynamicsProcessingTest, DynamicsProcessingLimiterConfigDataTest,

                         testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                                 IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),

                         [](const auto& info) {

                             auto descriptor = info.param;

                             std::string name = getPrefix(descriptor.second);

                             std::replace_if(

                                     name.begin(), name.end(),

                                     [](const char c) { return !std::isalnum(c); }, '_');

                             return name;

                         });



/**

 * Test DynamicsProcessing ChannelConfig

 */
@@ -673,19 +847,19 @@ class DynamicsProcessingTestChannelConfig 
TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPreEqChannelConfig) {

    EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));

    EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mCfg));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPostEqChannelConfig) {

    EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));

    EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mCfg));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetMbcChannelConfig) {

    EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));

    EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mCfg));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



INSTANTIATE_TEST_SUITE_P(
@@ -715,12 +889,11 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestChannelConfi 
enum EqBandConfigTestParamName {

    EQ_BAND_INSTANCE_NAME,

    EQ_BAND_CHANNEL,

    EQ_BAND_ENABLE,

    EQ_BAND_CUT_OFF_FREQ,

    EQ_BAND_GAIN

};

using EqBandConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,

                                          bool, std::vector<std::pair<int, float>>, float>;

                                          std::vector<std::pair<int, float>>, float>;



void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs,

                      const EqBandConfigTestParams& params) {
@@ -730,7 +903,7 @@ void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs, 
    for (int i = 0; i < bandCount; i++) {

        cfgs[i].channel = std::get<EQ_BAND_CHANNEL>(params);

        cfgs[i].band = cutOffFreqs[i].first;

        cfgs[i].enable = std::get<EQ_BAND_ENABLE>(params);

        cfgs[i].enable = true /*Eqband Enable*/;

        cfgs[i].cutoffFrequencyHz = cutOffFreqs[i].second;

        cfgs[i].gainDb = std::get<EQ_BAND_GAIN>(params);

    }
@@ -761,7 +934,7 @@ TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) { 
    }

    EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(cfgs));

    EXPECT_NO_FATAL_FAILURE(addPreEqBandConfigs(mCfgs));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {
@@ -774,7 +947,7 @@ TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) { 
    }

    EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(cfgs));

    EXPECT_NO_FATAL_FAILURE(addPostEqBandConfigs(mCfgs));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



std::vector<std::vector<std::pair<int, float>>> kBands{
@@ -825,9 +998,8 @@ INSTANTIATE_TEST_SUITE_P( 
        DynamicsProcessingTest, DynamicsProcessingTestEqBandConfig,

        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                                   IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),

                           testing::Values(-1, 0, 10),     // channel ID

                           testing::Bool(),                // band enable

                           testing::ValuesIn(kBands),      // cut off frequencies

                           testing::Values(-1, 0, 10),     // channel index

                           testing::ValuesIn(kBands),      // band index, cut off frequencies

                           testing::Values(-3.14f, 3.14f)  // gain

                           ),

        [](const auto& info) {
@@ -851,7 +1023,6 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestEqBandConfig 
enum MbcBandConfigParamName {

    MBC_BAND_INSTANCE_NAME,

    MBC_BAND_CHANNEL,

    MBC_BAND_ENABLE,

    MBC_BAND_CUTOFF_FREQ,

    MBC_BAND_ADDITIONAL

};
@@ -877,7 +1048,7 @@ static constexpr std::array<TestParamsMbcBandConfigAdditional, 4> kMbcBandConfig 
         {3, 10, 2, -2, -5, 90, 2.5, 2, 2}}};



using TestParamsMbcBandConfig =

        std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool,

        std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,

                   std::vector<std::pair<int, float>>, TestParamsMbcBandConfigAdditional>;



void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs,
@@ -890,7 +1061,7 @@ void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs, 
        cfgs[i] = DynamicsProcessing::MbcBandConfig{

                .channel = std::get<MBC_BAND_CHANNEL>(params),

                .band = cutOffFreqs[i].first,

                .enable = std::get<MBC_BAND_ENABLE>(params),

                .enable = true /*Mbc Band Enable*/,

                .cutoffFrequencyHz = cutOffFreqs[i].second,

                .attackTimeMs = additional[MBC_ADD_ATTACK_TIME],

                .releaseTimeMs = additional[MBC_ADD_RELEASE_TIME],
@@ -930,16 +1101,15 @@ TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) { 
    }

    EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(cfgs));

    EXPECT_NO_FATAL_FAILURE(addMbcBandConfigs(mCfgs));

    SetAndGetDynamicsProcessingParameters();

    ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());

}



INSTANTIATE_TEST_SUITE_P(

        DynamicsProcessingTest, DynamicsProcessingTestMbcBandConfig,

        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                                   IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),

                           testing::Values(-1, 0, 10),  // channel count

                           testing::Bool(),             // enable

                           testing::ValuesIn(kBands),   // cut off frequencies

                           testing::Values(-1, 0, 10),  // channel index

                           testing::ValuesIn(kBands),   // band index, cut off frequencies

                           testing::ValuesIn(kMbcBandConfigAdditionalParam)),  // Additional

        [](const auto& info) {

            auto descriptor = std::get<MBC_BAND_INSTANCE_NAME>(info.param).second;