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

Commit 5c95e334 authored by Sneha Patil's avatar Sneha Patil
Browse files

Virtualizer: Add Test to Validate Virtualizer Effect 

Added test to verify increasing Virtualizer Strength values.

Bug: 305866207
Test: atest VtsHalVirtualizerTargetTest
Change-Id: Ieb9faf63ccd77e9fec61e3fcfaa04f722aaf26ea
parent 5c7dd08f

audio/aidl/vts/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -151,6 +151,9 @@ cc_test { 
    name: "VtsHalVirtualizerTargetTest",

    defaults: ["VtsHalAudioEffectTargetTestDefaults"],

    srcs: ["VtsHalVirtualizerTargetTest.cpp"],

    shared_libs: [

        "libaudioutils",

    ],

}



cc_test {

audio/aidl/vts/VtsHalVirtualizerTargetTest.cpp

+154 −66
Original line number Diff line number Diff line
@@ -16,11 +16,14 @@ 


#define LOG_TAG "VtsHalVirtualizerTest"

#include <android-base/logging.h>

#include <audio_utils/power.h>

#include <system/audio.h>



#include "EffectHelper.h"



using namespace android;



using aidl::android::hardware::audio::common::getChannelCount;

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

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

using aidl::android::hardware::audio::effect::IEffect;
@@ -29,6 +32,82 @@ using aidl::android::hardware::audio::effect::Parameter; 
using aidl::android::hardware::audio::effect::Virtualizer;

using android::hardware::audio::common::testing::detail::TestExecutionTracer;



class VirtualizerHelper : public EffectHelper {

  public:

    void SetUpVirtualizer() {

        ASSERT_NE(nullptr, mFactory);

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

        initFrameCount();

        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = EffectHelper::createParamCommon(

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

                kSamplingFrequency /* oSampleRate */, mInputFrameCount /* iFrameCount */,

                mInputFrameCount /* oFrameCount */);

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

        ASSERT_NE(nullptr, mEffect);

    }



    void TearDownVirtualizer() {

        ASSERT_NO_FATAL_FAILURE(close(mEffect));

        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

        mOpenEffectReturn = IEffect::OpenEffectReturn{};

    }



    Parameter::Specific getDefaultParamSpecific() {

        Virtualizer vr = Virtualizer::make<Virtualizer::strengthPm>(0);

        Parameter::Specific specific =

                Parameter::Specific::make<Parameter::Specific::virtualizer>(vr);

        return specific;

    }



    Parameter createVirtualizerStrengthParam(int param) {

        return Parameter::make<Parameter::specific>(

                Parameter::Specific::make<Parameter::Specific::virtualizer>(

                        Virtualizer::make<Virtualizer::strengthPm>(param)));

    }



    void initFrameCount() {

        mInputFrameCount = kBufferSize / kChannelCount;

        mOutputFrameCount = kBufferSize / kChannelCount;

    }



    bool isStrengthValid(int level) {

        auto vir = Virtualizer::make<Virtualizer::strengthPm>(level);

        return isParameterValid<Virtualizer, Range::virtualizer>(vir, mDescriptor);

    }



    void setAndVerifyStrength(int param, binder_exception_t expected) {

        auto expectedParam = createVirtualizerStrengthParam(param);

        EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();



        if (expected == EX_NONE) {

            Virtualizer::Id vrlId =

                    Virtualizer::Id::make<Virtualizer::Id::commonTag>(Virtualizer::strengthPm);



            auto id = Parameter::Id::make<Parameter::Id::virtualizerTag>(vrlId);

            // get parameter

            Parameter getParam;

            // if set success, then get should match

            EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));

            EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()

                                               << "\ngetParam:" << getParam.toString();

        }

    }



    static constexpr int kSamplingFrequency = 44100;

    static constexpr int kDefaultChannelLayout = AudioChannelLayout::LAYOUT_STEREO;

    static constexpr int kDurationMilliSec = 2000;

    static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;

    int kChannelCount = getChannelCount(

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

    long mInputFrameCount;

    long mOutputFrameCount;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    IEffect::OpenEffectReturn mOpenEffectReturn;

    Descriptor mDescriptor;

};



/**

 * Here we focus on specific parameter checking, general IEffect interfaces testing performed in

 * VtsAudioEffectTargetTest.
@@ -44,89 +123,82 @@ using VirtualizerParamTestParam = std::tuple<std::pair<std::shared_ptr<IFactory> 
 */



class VirtualizerParamTest : public ::testing::TestWithParam<VirtualizerParamTestParam>,

                             public EffectHelper {

                             public VirtualizerHelper {

  public:

    VirtualizerParamTest() : mParamStrength(std::get<PARAM_STRENGTH>(GetParam())) {

        std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());

    }

    void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVirtualizer()); }

    void TearDown() override { TearDownVirtualizer(); }



    void SetUp() override {

        ASSERT_NE(nullptr, mFactory);

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

    int mParamStrength = 0;

};



        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = EffectHelper::createParamCommon(

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

                kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);

        IEffect::OpenEffectReturn ret;

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

        ASSERT_NE(nullptr, mEffect);

TEST_P(VirtualizerParamTest, SetAndGetStrength) {

    ASSERT_NO_FATAL_FAILURE(setAndVerifyStrength(

            mParamStrength, isStrengthValid(mParamStrength) ? EX_NONE : EX_ILLEGAL_ARGUMENT));

}



    void TearDown() override {

        ASSERT_NO_FATAL_FAILURE(close(mEffect));

        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

    }

enum ProcessTestParam { PROCESS_INSTANCE_NAME, PROCESS_ZERO_INPUT };

using VirtualizerProcessTestParam =

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



    Parameter::Specific getDefaultParamSpecific() {

        Virtualizer vr = Virtualizer::make<Virtualizer::strengthPm>(0);

        Parameter::Specific specific =

                Parameter::Specific::make<Parameter::Specific::virtualizer>(vr);

        return specific;

class VirtualizerProcessTest : public ::testing::TestWithParam<VirtualizerProcessTestParam>,

                               public VirtualizerHelper {

  public:

    VirtualizerProcessTest() : mZeroInput(std::get<PROCESS_ZERO_INPUT>(GetParam())) {

        std::tie(mFactory, mDescriptor) = std::get<PROCESS_INSTANCE_NAME>(GetParam());

    }



    static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;

    int mParamStrength = 0;

    void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVirtualizer()); }

    void TearDown() override { TearDownVirtualizer(); }



    void SetAndGetVirtualizerParameters() {

        for (auto& it : mTags) {

            auto& tag = it.first;

            auto& vr = it.second;



            // validate parameter

            Descriptor desc;

            ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));

            const bool valid = isParameterValid<Virtualizer, Range::virtualizer>(it.second, desc);

            const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;



            // set parameter

            Parameter expectParam;

            Parameter::Specific specific;

            specific.set<Parameter::Specific::virtualizer>(vr);

            expectParam.set<Parameter::specific>(specific);

            EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();



            // only get if parameter in range and set success

            if (expected == EX_NONE) {

                Parameter getParam;

                Parameter::Id id;

                Virtualizer::Id vrId;

                vrId.set<Virtualizer::Id::commonTag>(tag);

                id.set<Parameter::Id::virtualizerTag>(vrId);

                // if set success, then get should match

                EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));

                EXPECT_EQ(expectParam, getParam);

    void generateInput(std::vector<float>& buffer) {

        if (mZeroInput) {

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

        } else {

            int frequency = 100;

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

                buffer[i] = sin(2 * M_PI * frequency * i / kSamplingFrequency);

            }

        }

    }



    void addStrengthParam(int strength) {

        Virtualizer vr;

        vr.set<Virtualizer::strengthPm>(strength);

        mTags.push_back({Virtualizer::strengthPm, vr});

    static constexpr float kAbsError = 0.00001;

    bool mZeroInput;

};



TEST_P(VirtualizerProcessTest, IncreasingStrength) {

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

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

    std::vector<int> strengths = {250, 500, 750, 1000};



    generateInput(input);



    const float inputRmse =

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



    for (int strength : strengths) {

        // Skipping the further steps for unnsupported Strength values

        if (!isStrengthValid(strength)) {

            continue;

        }

        setAndVerifyStrength(strength, EX_NONE);

        ASSERT_NO_FATAL_FAILURE(

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



  private:

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

    void CleanUp() { mTags.clear(); }

};

        const float outputRmse = audio_utils_compute_energy_mono(

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



TEST_P(VirtualizerParamTest, SetAndGetStrength) {

    EXPECT_NO_FATAL_FAILURE(addStrengthParam(mParamStrength));

    SetAndGetVirtualizerParameters();

        if (inputRmse != 0) {

            EXPECT_NE(outputRmse, 0);

            if (strength != 0) {

                EXPECT_GT(abs(outputRmse - inputRmse), kAbsError);

            }

        } else {

            EXPECT_NEAR(outputRmse, inputRmse, kAbsError);

        }

    }

}



std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
@@ -149,6 +221,22 @@ INSTANTIATE_TEST_SUITE_P( 


GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VirtualizerParamTest);



INSTANTIATE_TEST_SUITE_P(

        VirtualizerTest, VirtualizerProcessTest,

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

                                   IFactory::descriptor, getEffectTypeUuidVirtualizer())),

                           testing::Bool()),

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

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

            std::string isInputZero = std::to_string(std::get<PROCESS_ZERO_INPUT>(info.param));

            std::string name = getPrefix(descriptor) + "_isInputZero_" + isInputZero;

            std::replace_if(

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

            return name;

        });



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VirtualizerProcessTest);



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

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

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