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

Commit 8f116e72 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "EnvironmentalReverb: Add Basic Validation for Density Parameter" into main am: 062d1ecc 

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



Change-Id: I446e5acd8d36e93bcd613722f31a2e0b0253a0f5
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 29ee4dbf 062d1ecc

audio/aidl/vts/VtsHalEnvironmentalReverbTargetTest.cpp

+70 −3
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#define LOG_TAG "VtsHalEnvironmentalReverbTest"

#include <android-base/logging.h>

#include <audio_utils/power.h>

#include <audio_utils/primitives.h>

#include <system/audio.h>

#include <numeric>
@@ -49,6 +50,8 @@ static const std::vector<TagVectorPair> kParamsIncreasingVector = { 


static const TagVectorPair kDiffusionParam = {EnvironmentalReverb::diffusionPm,

                                              {200, 400, 600, 800, 1000}};

static const TagVectorPair kDensityParam = {EnvironmentalReverb::densityPm,

                                            {0, 200, 400, 600, 800, 1000}};



static const std::vector<TagValuePair> kParamsMinimumValue = {

        {EnvironmentalReverb::roomLevelMb, kMinRoomLevel},
@@ -475,9 +478,7 @@ class EnvironmentalReverbDiffusionTest 


    float getVariance(std::vector<float>& buffer) {

        if (isAuxiliary()) {

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

                buffer[i] += mInput[i];

            }

            accumulate_float(buffer.data(), mInput.data(), buffer.size());

        }

        float mean = getMean(buffer);

        float squaredDeltas =
@@ -524,6 +525,72 @@ INSTANTIATE_TEST_SUITE_P( 


GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDiffusionTest);



enum ParamDensityTest { DESCRIPTOR, TAG_DENSITY_VALUE, PARAM_DENSITY_VALUE, IS_INPUT_MUTE };



class EnvironmentalReverbDensityTest

    : public ::testing::TestWithParam<std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,

                                                 EnvironmentalReverb::Tag, int, bool>>,

      public EnvironmentalReverbHelper {

  public:

    EnvironmentalReverbDensityTest() : EnvironmentalReverbHelper(std::get<DESCRIPTOR>(GetParam())) {

        mTag = std::get<TAG_DENSITY_VALUE>(GetParam());

        mParamValues = std::get<PARAM_DENSITY_VALUE>(GetParam());

        mIsInputMute = (std::get<IS_INPUT_MUTE>(GetParam()));

        mInput.resize(kBufferSize);

        if (mIsInputMute) {

            std::fill(mInput.begin(), mInput.end(), 0);

        } else {

            generateSineWaveInput(mInput);

        }

    }

    void SetUp() override { SetUpReverb(); }

    void TearDown() override { TearDownReverb(); }



    EnvironmentalReverb::Tag mTag;

    int mParamValues;

    std::vector<float> mInput;

    bool mIsInputMute;

};



TEST_P(EnvironmentalReverbDensityTest, DensityOutput) {

    float inputRmse =

            audio_utils_compute_energy_mono(mInput.data(), AUDIO_FORMAT_PCM_FLOAT, mInput.size());



    std::vector<float> output(kBufferSize);

    setParameterAndProcess(mInput, output, mParamValues, mTag);



    if (isAuxiliary() && !mIsInputMute) {

        accumulate_float(output.data(), mInput.data(), output.size());

    }



    float outputRmse =

            audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT, output.size());

    if (inputRmse != 0) {

        EXPECT_GT(outputRmse, 0);

    } else {

        EXPECT_EQ(outputRmse, inputRmse);

    }

}



INSTANTIATE_TEST_SUITE_P(

        EnvironmentalReverbTest, EnvironmentalReverbDensityTest,

        ::testing::Combine(

                testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(

                                          IFactory::descriptor, getEffectTypeUuidEnvReverb())),

                testing::Values(kDensityParam.first), testing::ValuesIn(kDensityParam.second),

                testing::Bool()),

        [](const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) {

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

            auto tag = std::get<TAG_DENSITY_VALUE>(info.param);

            auto value = std::get<PARAM_DENSITY_VALUE>(info.param);

            std::string isInputMute = std::to_string(std::get<IS_INPUT_MUTE>(info.param));

            std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag) + "_Value_" +

                               std::to_string(value) + "_isInputMute_" + isInputMute;

            return name;

        });



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDensityTest);



int main(int argc, char** argv) {

    ::testing::InitGoogleTest(&argc, argv);

    ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());