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

Commit 883d75b6 authored by Shunkai Yao's avatar Shunkai Yao
Browse files

Effect AIDL Refine effect test parameter combination list 

Add effects implementation shared lib dependency.

Bug: 258124419
Test: atest VtsHalVisualizerTargetTest
Test: atest VtsHalAECTargetTest
Test: atest VtsHalAGCTargetTest
Test: atest VtsHalNSTargetTest
Change-Id: I58be0b789b08c9211a6bc79e8fc3c21d9658dd4a
parent d7c6f32d

audio/aidl/default/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -149,6 +149,8 @@ cc_binary { 
    vintf_fragments: ["android.hardware.audio.effect.service-aidl.xml"],

    defaults: ["aidlaudioeffectservice_defaults"],

    shared_libs: [

        "libaecsw",

        "libagcsw",

        "libbassboostsw",

        "libbundleaidl",

        "libdownmixaidl",
@@ -157,6 +159,7 @@ cc_binary { 
        "libequalizersw",

        "libhapticgeneratoraidl",

        "libloudnessenhanceraidl",

        "libnssw",

        "libpresetreverbsw",

        "libtinyxml2",

        "libvirtualizersw",

audio/aidl/vts/VtsHalAECTargetTest.cpp

+24 −27
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <Utils.h>

#include <aidl/Vintf.h>

#include <algorithm>

#include <string>

#include <unordered_set>



#define LOG_TAG "VtsHalAECParamTest"
@@ -70,10 +71,6 @@ class AECParamTest : public ::testing::TestWithParam<AECParamTestParam>, public 
        return specific;

    }



    static const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList;

    static const std::unordered_set<int> kEchoDelayValues;

    static const std::unordered_set<bool> kMobileModeValues;



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

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;
@@ -157,8 +154,10 @@ class AECParamTest : public ::testing::TestWithParam<AECParamTestParam>, public 
    }



    static std::unordered_set<int> getEchoDelayTestValues() {

        auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                                     kAcousticEchoCancelerTypeUUID);

        const auto max = std::max_element(

                kFactoryDescList.begin(), kFactoryDescList.end(),

                descList.begin(), descList.end(),

                [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a,

                   const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) {

                    return a.second.capability.get<Capability::acousticEchoCanceler>()
@@ -166,26 +165,20 @@ class AECParamTest : public ::testing::TestWithParam<AECParamTestParam>, public 
                           b.second.capability.get<Capability::acousticEchoCanceler>()

                                   .maxEchoDelayUs;

                });

        if (max == kFactoryDescList.end()) {

        if (max == descList.end()) {

            return {0};

        }

        int maxDelay =

                max->second.capability.get<Capability::acousticEchoCanceler>().maxEchoDelayUs;

        return {-1, 0, maxDelay - 1, maxDelay, maxDelay + 1};

    }

    static std::unordered_set<bool> getMobileModeValues() { return {true, false}; }



  private:

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

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

};



const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> AECParamTest::kFactoryDescList =

        EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                     kAcousticEchoCancelerTypeUUID);

const std::unordered_set<int> AECParamTest::kEchoDelayValues =

        AECParamTest::getEchoDelayTestValues();

const std::unordered_set<bool> AECParamTest::kMobileModeValues = {true, false};



TEST_P(AECParamTest, SetAndGetEchoDelay) {

    EXPECT_NO_FATAL_FAILURE(addEchoDelayParam(mEchoDelay));

    SetAndGetParameters();
@@ -196,18 +189,22 @@ TEST_P(AECParamTest, SetAndGetMobileMode) { 
    SetAndGetParameters();

}



INSTANTIATE_TEST_SUITE_P(AECParamTest, AECParamTest,

                         ::testing::Combine(testing::ValuesIn(AECParamTest::kFactoryDescList),

                                            testing::ValuesIn(AECParamTest::kEchoDelayValues),

                                            testing::ValuesIn(AECParamTest::kMobileModeValues)),

INSTANTIATE_TEST_SUITE_P(

        AECParamTest, AECParamTest,

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

                                   IFactory::descriptor, kAcousticEchoCancelerTypeUUID)),

                           testing::ValuesIn(AECParamTest::getEchoDelayTestValues()),

                           testing::ValuesIn(AECParamTest::getMobileModeValues())),

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

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

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

                                                "_name_" + descriptor.common.name + "_UUID_" +

                                                descriptor.common.id.uuid.toString();

            std::string echoDelay = std::to_string(std::get<PARAM_ECHO_DELAY>(info.param));

            std::string mobileMode = std::get<PARAM_MOBILE_MODE>(info.param) ? "true" : "false";

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

                               descriptor.common.name + "_UUID_" +

                               descriptor.common.id.uuid.toString() + "_EchoDelay_" + echoDelay +

                               "_MobileMode_" + mobileMode;

            std::replace_if(

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

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

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

            return name;

        });

audio/aidl/vts/VtsHalAGCTargetTest.cpp

+15 −23
Original line number Diff line number Diff line
@@ -79,11 +79,6 @@ class AGCParamTest : public ::testing::TestWithParam<AGCParamTestParam>, public 
    }



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

    static const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList;

    static const std::unordered_set<int> kDigitalGainValues;

    static const std::unordered_set<int> kSaturationMarginValues;

    static const std::unordered_set<AutomaticGainControl::LevelEstimator> kLevelEstimatorValues;



    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;
@@ -161,8 +156,10 @@ class AGCParamTest : public ::testing::TestWithParam<AGCParamTestParam>, public 
        }

    }

    static std::unordered_set<int> getDigitalGainValues() {

        auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                                     kAutomaticGainControlTypeUUID);

        const auto max = std::max_element(

                kFactoryDescList.begin(), kFactoryDescList.end(),

                descList.begin(), descList.end(),

                [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a,

                   const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) {

                    return a.second.capability.get<Capability::automaticGainControl>()
@@ -170,7 +167,7 @@ class AGCParamTest : public ::testing::TestWithParam<AGCParamTestParam>, public 
                           b.second.capability.get<Capability::automaticGainControl>()

                                   .maxFixedDigitalGainMb;

                });

        if (max == kFactoryDescList.end()) {

        if (max == descList.end()) {

            return {0};

        }

        int maxGain = max->second.capability.get<Capability::automaticGainControl>()
@@ -178,8 +175,10 @@ class AGCParamTest : public ::testing::TestWithParam<AGCParamTestParam>, public 
        return {-1, 0, maxGain - 1, maxGain, maxGain + 1};

    }

    static std::unordered_set<int> getSaturationMarginValues() {

        auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                                     kAutomaticGainControlTypeUUID);

        const auto max = std::max_element(

                kFactoryDescList.begin(), kFactoryDescList.end(),

                descList.begin(), descList.end(),

                [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a,

                   const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) {

                    return a.second.capability.get<Capability::automaticGainControl>()
@@ -187,30 +186,23 @@ class AGCParamTest : public ::testing::TestWithParam<AGCParamTestParam>, public 
                           b.second.capability.get<Capability::automaticGainControl>()

                                   .maxSaturationMarginMb;

                });

        if (max == kFactoryDescList.end()) {

        if (max == descList.end()) {

            return {0};

        }

        int maxMargin = max->second.capability.get<Capability::automaticGainControl>()

                                .maxSaturationMarginMb;

        return {-1, 0, maxMargin - 1, maxMargin, maxMargin + 1};

    }

    static std::unordered_set<AutomaticGainControl::LevelEstimator> getLevelEstimatorValues() {

        return {ndk::enum_range<AutomaticGainControl::LevelEstimator>().begin(),

                ndk::enum_range<AutomaticGainControl::LevelEstimator>().end()};

    }



  private:

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

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

};



const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> AGCParamTest::kFactoryDescList =

        EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                     kAutomaticGainControlTypeUUID);

const std::unordered_set<int> AGCParamTest::kDigitalGainValues =

        AGCParamTest::getDigitalGainValues();

const std::unordered_set<int> AGCParamTest::kSaturationMarginValues =

        AGCParamTest::getSaturationMarginValues();

const std::unordered_set<AutomaticGainControl::LevelEstimator> AGCParamTest::kLevelEstimatorValues =

        {ndk::enum_range<AutomaticGainControl::LevelEstimator>().begin(),

         ndk::enum_range<AutomaticGainControl::LevelEstimator>().end()};



TEST_P(AGCParamTest, SetAndGetDigitalGainParam) {

    EXPECT_NO_FATAL_FAILURE(addDigitalGainParam(mGain));

    SetAndGetParameters();
@@ -230,9 +222,9 @@ INSTANTIATE_TEST_SUITE_P( 
        AGCParamTest, AGCParamTest,

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

                                   IFactory::descriptor, kAutomaticGainControlTypeUUID)),

                           testing::ValuesIn(AGCParamTest::kDigitalGainValues),

                           testing::ValuesIn(AGCParamTest::kSaturationMarginValues),

                           testing::ValuesIn(AGCParamTest::kLevelEstimatorValues)),

                           testing::ValuesIn(AGCParamTest::getDigitalGainValues()),

                           testing::ValuesIn(AGCParamTest::getSaturationMarginValues()),

                           testing::ValuesIn(AGCParamTest::getLevelEstimatorValues())),

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

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

            std::string gain = std::to_string(std::get<PARAM_DIGITAL_GAIN>(info.param));

audio/aidl/vts/VtsHalNSTargetTest.cpp

+9 −13
Original line number Diff line number Diff line
@@ -14,12 +14,14 @@ 
 * limitations under the License.

 */



#include <Utils.h>

#include <aidl/Vintf.h>

#include <android/binder_enums.h>

#include <unordered_set>



#define LOG_TAG "VtsHalNSParamTest"



#include <Utils.h>

#include <unordered_set>

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

#include "EffectHelper.h"



using namespace android;
@@ -69,9 +71,6 @@ class NSParamTest : public ::testing::TestWithParam<NSParamTestParam>, public Ef 
    }



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

    static const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList;

    static const std::unordered_set<NoiseSuppression::Level> kLevelValues;



    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;
@@ -114,19 +113,16 @@ class NSParamTest : public ::testing::TestWithParam<NSParamTestParam>, public Ef 
        ns.set<NoiseSuppression::level>(level);

        mTags.push_back({NoiseSuppression::level, ns});

    }

    static std::unordered_set<NoiseSuppression::Level> getLevelValues() {

        return {ndk::enum_range<NoiseSuppression::Level>().begin(),

                ndk::enum_range<NoiseSuppression::Level>().end()};

    }



  private:

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

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

};



const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList =

        EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                     kNoiseSuppressionTypeUUID);

const std::unordered_set<NoiseSuppression::Level> NSParamTest::kLevelValues = {

        ndk::enum_range<NoiseSuppression::Level>().begin(),

        ndk::enum_range<NoiseSuppression::Level>().end()};



TEST_P(NSParamTest, SetAndGetLevel) {

    EXPECT_NO_FATAL_FAILURE(addLevelParam(mLevel));

    SetAndGetParameters();
@@ -136,7 +132,7 @@ INSTANTIATE_TEST_SUITE_P( 
        NSParamTest, NSParamTest,

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

                                   IFactory::descriptor, kNoiseSuppressionTypeUUID)),

                           testing::ValuesIn(NSParamTest::kLevelValues)),

                           testing::ValuesIn(NSParamTest::getLevelValues())),

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

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

            std::string level = aidl::android::hardware::audio::effect::toString(

audio/aidl/vts/VtsHalVisualizerTargetTest.cpp

+35 −40
Original line number Diff line number Diff line
@@ -85,12 +85,6 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
        return specific;

    }



    static const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList;

    static const std::unordered_set<Visualizer::ScalingMode> kScalingModeValues;

    static const std::unordered_set<Visualizer::MeasurementMode> kMeasurementModeValues;

    static const std::unordered_set<int> kLatencyValues;

    static const std::unordered_set<int> kCaptureSizeValues;



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

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;
@@ -141,7 +135,7 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
            // validate parameter

            Descriptor desc;

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

            const bool valid = isSetOnlyParamTagInRange(tag, vs, desc);

            const bool valid = isSetOnlyParamTagInRange(vs, desc);

            const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;



            // set parameter
@@ -219,18 +213,26 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
        switch (tag) {

            case Visualizer::captureSamples: {

                int captureSize = vs.get<Visualizer::captureSamples>();

                return isCaptureSizeInRange(vsCap, captureSize);

                return captureSize >= vsCap.captureSampleRange.min &&

                       captureSize <= vsCap.captureSampleRange.max;

            }

            case Visualizer::scalingMode:

            case Visualizer::measurementMode:

                return true;

            case Visualizer::setOnlyParameters: {

                auto setOnly = vs.get<Visualizer::setOnlyParameters>();

                if (setOnly.getTag() != Visualizer::SetOnlyParameters::latencyMs) {

                    return false;

                }

                auto latencyMs = setOnly.get<Visualizer::SetOnlyParameters::latencyMs>();

                return latencyMs >= 0 && latencyMs <= vsCap.maxLatencyMs;

            }

            default:

                return false;

        }

    }



    bool isSetOnlyParamTagInRange(Visualizer::SetOnlyParameters::Tag, const Visualizer& vs,

                                  const Descriptor& desc) const {

    bool isSetOnlyParamTagInRange(const Visualizer& vs, const Descriptor& desc) const {

        const Visualizer::Capability& vsCap = desc.capability.get<Capability::visualizer>();

        if (vs.getTag() != Visualizer::setOnlyParameters) return false;

        Visualizer::SetOnlyParameters setOnlyParam = vs.get<Visualizer::setOnlyParameters>();
@@ -239,19 +241,16 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
        return isLatencyInRange(vsCap, latency);

    }



    bool isCaptureSizeInRange(const Visualizer::Capability& cap, int captureSize) const {

        return (captureSize >= cap.captureSampleRange.min &&

                captureSize <= cap.captureSampleRange.max);

    }



    bool isLatencyInRange(const Visualizer::Capability& cap, int latency) const {

        return (latency >= 0 && latency <= cap.maxLatencyMs);

    }



    static std::unordered_set<int> getCaptureSizeValues() {

        auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                                     kVisualizerTypeUUID);

        int minCaptureSize = std::numeric_limits<int>::max();

        int maxCaptureSize = std::numeric_limits<int>::min();

        for (const auto& it : kFactoryDescList) {

        for (const auto& it : descList) {

            maxCaptureSize = std::max(

                    it.second.capability.get<Capability::visualizer>().captureSampleRange.max,

                    maxCaptureSize);
@@ -265,19 +264,29 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
    }



    static std::unordered_set<int> getLatencyValues() {

        auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor,

                                                                     kVisualizerTypeUUID);

        const auto max = std::max_element(

                kFactoryDescList.begin(), kFactoryDescList.end(),

                descList.begin(), descList.end(),

                [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a,

                   const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) {

                    return a.second.capability.get<Capability::visualizer>().maxLatencyMs <

                           b.second.capability.get<Capability::visualizer>().maxLatencyMs;

                });

        if (max == kFactoryDescList.end()) {

        if (max == descList.end()) {

            return {0};

        }

        int maxDelay = max->second.capability.get<Capability::visualizer>().maxLatencyMs;

        return {-1, 0, maxDelay >> 1, maxDelay - 1, maxDelay, maxDelay + 1};

    }

    static std::unordered_set<Visualizer::MeasurementMode> getMeasurementModeValues() {

        return {ndk::enum_range<Visualizer::MeasurementMode>().begin(),

                ndk::enum_range<Visualizer::MeasurementMode>().end()};

    }

    static std::unordered_set<Visualizer::ScalingMode> getScalingModeValues() {

        return {ndk::enum_range<Visualizer::ScalingMode>().begin(),

                ndk::enum_range<Visualizer::ScalingMode>().end()};

    }



  private:

    std::vector<std::pair<Visualizer::Tag, Visualizer>> mCommonTags;
@@ -290,20 +299,6 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP 
    }

};



const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>>

        VisualizerParamTest::kFactoryDescList = EffectFactoryHelper::getAllEffectDescriptors(

                IFactory::descriptor, kVisualizerTypeUUID);

const std::unordered_set<int> VisualizerParamTest::kCaptureSizeValues =

        VisualizerParamTest::getCaptureSizeValues();

const std::unordered_set<Visualizer::MeasurementMode> VisualizerParamTest::kMeasurementModeValues(

        ndk::enum_range<Visualizer::MeasurementMode>().begin(),

        ndk::enum_range<Visualizer::MeasurementMode>().end());

const std::unordered_set<Visualizer::ScalingMode> VisualizerParamTest::kScalingModeValues(

        ndk::enum_range<Visualizer::ScalingMode>().begin(),

        ndk::enum_range<Visualizer::ScalingMode>().end());

const std::unordered_set<int> VisualizerParamTest::kLatencyValues =

        VisualizerParamTest::getLatencyValues();



TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {

    EXPECT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));

    SetAndGetCommonParameters();
@@ -338,17 +333,17 @@ INSTANTIATE_TEST_SUITE_P( 
        VisualizerParamTest, VisualizerParamTest,

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

                                   IFactory::descriptor, kVisualizerTypeUUID)),

                           testing::ValuesIn(VisualizerParamTest::kCaptureSizeValues),

                           testing::ValuesIn(VisualizerParamTest::kScalingModeValues),

                           testing::ValuesIn(VisualizerParamTest::kMeasurementModeValues),

                           testing::ValuesIn(VisualizerParamTest::kLatencyValues)),

                           testing::ValuesIn(VisualizerParamTest::getCaptureSizeValues()),

                           testing::ValuesIn(VisualizerParamTest::getScalingModeValues()),

                           testing::ValuesIn(VisualizerParamTest::getMeasurementModeValues()),

                           testing::ValuesIn(VisualizerParamTest::getLatencyValues())),

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

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

            std::string captureSize = std::to_string(std::get<PARAM_CAPTURE_SIZE>(info.param));

            std::string scalingMode =

                    std::to_string(static_cast<int>(std::get<PARAM_SCALING_MODE>(info.param)));

            std::string measurementMode =

                    std::to_string(static_cast<int>(std::get<PARAM_MEASUREMENT_MODE>(info.param)));

            std::string scalingMode = aidl::android::hardware::audio::effect::toString(

                    std::get<PARAM_SCALING_MODE>(info.param));

            std::string measurementMode = aidl::android::hardware::audio::effect::toString(

                    std::get<PARAM_MEASUREMENT_MODE>(info.param));

            std::string latency = std::to_string(std::get<PARAM_LATENCY>(info.param));



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