Merge "DynamicsProcessing: Validate config params based on ranges advertised" (d1481547) · Commits · e / os / android_hardware_interfaces

audio/aidl/vts/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -84,6 +84,7 @@ cc_test {
		cc_test {
		name: "VtsHalDynamicsProcessingTargetTest",
		defaults: ["VtsHalAudioTargetTestDefaults"],
		static_libs: ["libaudioaidlranges"],
		srcs: ["VtsHalDynamicsProcessingTest.cpp"],
		}

audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp

+128 −58

Original line number	Diff line number	Diff line
		@@ -25,8 +25,10 @@
		#include <Utils.h>

		#include "EffectHelper.h"
		#include "EffectRangeSpecific.h"

		using namespace android;
		using namespace aidl::android::hardware::audio::effect::DynamicsProcessingRanges;

		using aidl::android::hardware::audio::effect::Descriptor;
		using aidl::android::hardware::audio::effect::DynamicsProcessing;
		@@ -95,6 +97,19 @@ class DynamicsProcessingTestHelper : public EffectHelper {
		template <typename T>
		bool isAidlVectorEqual(const std::vector<T>& source, const std::vector<T>& target);

		template <typename T>
		bool isChannelConfigValid(const std::vector<T>& cfgs) {
		auto& channelCount = mChannelCount;
		return std::all_of(cfgs.cbegin(), cfgs.cend(), [channelCount](const T& cfg) {
		return (cfg.channel >= 0 && cfg.channel < channelCount);
		});
		}

		template <typename T>
		bool isBandConfigValid(const std::vector<T>& cfgs, int bandCount);

		bool isParamValid(const DynamicsProcessing::Tag& tag, const DynamicsProcessing& dp);

		// get set params and validate
		void SetAndGetDynamicsProcessingParameters();

		@@ -133,9 +148,11 @@ 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;
		int mChannelCount;
		std::vector<std::pair<DynamicsProcessing::Tag, DynamicsProcessing>> mTags;
		void CleanUp() {
		mTags.clear();
		@@ -152,6 +169,8 @@ const std::set<DynamicsProcessing::StageEnablement>
		{.inUse = true, .bandCount = DynamicsProcessingTestHelper::kBandCount},
		{.inUse = true, .bandCount = 0},
		{.inUse = true, .bandCount = -1},
		{.inUse = false, .bandCount = 0},
		{.inUse = false, .bandCount = -1},
		{.inUse = false, .bandCount = DynamicsProcessingTestHelper::kBandCount}};

		// test value set for DynamicsProcessing::ChannelConfig
		@@ -161,9 +180,7 @@ const std::set<std::vector<DynamicsProcessing::ChannelConfig>>
		{.channel = 0, .enable = true},
		{.channel = 1, .enable = false},
		{.channel = 2, .enable = true}},

		{{.channel = -1, .enable = false}, {.channel = 2, .enable = true}},

		{{.channel = 0, .enable = true}, {.channel = 1, .enable = true}}};

		// test value set for DynamicsProcessing::InputGain
		@@ -172,10 +189,65 @@ const std::set<std::vector<DynamicsProcessing::InputGain>>
		{{.channel = 0, .gainDb = 10.f},
		{.channel = 1, .gainDb = 0.f},
		{.channel = 2, .gainDb = -10.f}},

		{{.channel = -1, .gainDb = -10.f}, {.channel = -2, .gainDb = 10.f}},
		{{.channel = -1, .gainDb = 10.f}, {.channel = 0, .gainDb = -10.f}},
		{{.channel = 0, .gainDb = 10.f}, {.channel = 1, .gainDb = -10.f}}};

		{{.channel = -1, .gainDb = 10.f}, {.channel = 0, .gainDb = -10.f}}};
		template <typename T>
		bool DynamicsProcessingTestHelper::isBandConfigValid(const std::vector<T>& cfgs, int bandCount) {
		std::vector<float> freqs(cfgs.size(), -1);
		for (auto cfg : cfgs) {
		if (cfg.channel < 0 \|\| cfg.channel >= mChannelCount) return false;
		if (cfg.band < 0 \|\| cfg.band >= bandCount) return false;
		freqs[cfg.band] = cfg.cutoffFrequencyHz;
		}
		if (std::count(freqs.begin(), freqs.end(), -1)) return false;
		return std::is_sorted(freqs.begin(), freqs.end());
		}

		bool DynamicsProcessingTestHelper::isParamValid(const DynamicsProcessing::Tag& tag,
		const DynamicsProcessing& dp) {
		switch (tag) {
		case DynamicsProcessing::preEq: {
		if (!mEngineConfigApplied.preEqStage.inUse) return false;
		return isChannelConfigValid(dp.get<DynamicsProcessing::preEq>());
		}
		case DynamicsProcessing::postEq: {
		if (!mEngineConfigApplied.postEqStage.inUse) return false;
		return isChannelConfigValid(dp.get<DynamicsProcessing::postEq>());
		}
		case DynamicsProcessing::mbc: {
		if (!mEngineConfigApplied.mbcStage.inUse) return false;
		return isChannelConfigValid(dp.get<DynamicsProcessing::mbc>());
		}
		case DynamicsProcessing::preEqBand: {
		if (!mEngineConfigApplied.preEqStage.inUse) return false;
		return isBandConfigValid(dp.get<DynamicsProcessing::preEqBand>(),
		mEngineConfigApplied.preEqStage.bandCount);
		}
		case DynamicsProcessing::postEqBand: {
		if (!mEngineConfigApplied.postEqStage.inUse) return false;
		return isBandConfigValid(dp.get<DynamicsProcessing::postEqBand>(),
		mEngineConfigApplied.postEqStage.bandCount);
		}
		case DynamicsProcessing::mbcBand: {
		if (!mEngineConfigApplied.mbcStage.inUse) return false;
		return isBandConfigValid(dp.get<DynamicsProcessing::mbcBand>(),
		mEngineConfigApplied.mbcStage.bandCount);
		}
		case DynamicsProcessing::limiter: {
		if (!mEngineConfigApplied.limiterInUse) return false;
		return isChannelConfigValid(dp.get<DynamicsProcessing::limiter>());
		}
		case DynamicsProcessing::inputGain: {
		return isChannelConfigValid(dp.get<DynamicsProcessing::inputGain>());
		}
		default: {
		return true;
		}
		}
		return true;
		}

		bool DynamicsProcessingTestHelper::isParamEqual(const DynamicsProcessing::Tag& tag,
		const DynamicsProcessing& dpRef,
		@@ -270,8 +342,8 @@ void DynamicsProcessingTestHelper::SetAndGetDynamicsProcessingParameters() {
		// validate parameter
		Descriptor desc;
		ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
		const bool valid =
		isParameterValid<DynamicsProcessing, Range::dynamicsProcessing>(dp, desc);
		bool valid = isParamInRange(dp, desc.capability.range.get<Range::dynamicsProcessing>());
		if (valid) valid = isParamValid(tag, dp);
		const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;

		// set parameter
		@@ -429,9 +501,10 @@ INSTANTIATE_TEST_SUITE_P(
		::testing::Combine(
		testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
		testing::Values(DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
		DynamicsProcessing::ResolutionPreference::
		FAVOR_FREQUENCY_RESOLUTION), // variant
		testing::Values(
		DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
		DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
		static_cast<DynamicsProcessing::ResolutionPreference>(-1)), // variant
		testing::Values(-10.f, 0.f, 10.f), // processing duration
		testing::ValuesIn(
		DynamicsProcessingTestHelper::kStageEnablementTestSet), // preEQ/postEQ/mbc
		@@ -515,12 +588,12 @@ enum LimiterConfigTestAdditionalParam {
		LIMITER_MAX_NUM,
		};
		using LimiterConfigTestAdditional = std::array<float, LIMITER_MAX_NUM>;
		// attachTime, releaseTime, ratio, thresh, postGain
		// 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}}};
		{1, 60, 2.5, -2, 3.14}}};

		using LimiterConfigTestParams =
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool, int32_t, bool,
		@@ -669,15 +742,13 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestChannelConfi
		enum EqBandConfigTestParamName {
		EQ_BAND_INSTANCE_NAME,
		EQ_BAND_CHANNEL,
		EQ_BAND_CHANNEL_ENABLE,
		EQ_BAND_ENABLE,
		EQ_BAND_CUT_OFF_FREQ,
		EQ_BAND_GAIN,
		EQ_BAND_STAGE_IN_USE
		};
		using EqBandConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,
		std::vector<DynamicsProcessing::ChannelConfig>, bool,
		std::vector<std::pair<int, float>>, float, bool>;
		bool, std::vector<std::pair<int, float>>, float, bool>;

		void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs,
		const EqBandConfigTestParams& params) {
		@@ -698,8 +769,7 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan
		public:
		DynamicsProcessingTestEqBandConfig()
		: DynamicsProcessingTestHelper(std::get<EQ_BAND_INSTANCE_NAME>(GetParam())),
		mStageInUse(std::get<EQ_BAND_STAGE_IN_USE>(GetParam())),
		mChannelConfig(std::get<EQ_BAND_CHANNEL_ENABLE>(GetParam())) {
		mStageInUse(std::get<EQ_BAND_STAGE_IN_USE>(GetParam())) {
		fillEqBandConfig(mCfgs, GetParam());
		}

		@@ -709,14 +779,18 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan

		std::vector<DynamicsProcessing::EqBandConfig> mCfgs;
		const bool mStageInUse;
		const std::vector<DynamicsProcessing::ChannelConfig> mChannelConfig;
		};

		TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {
		mEngineConfigPreset.preEqStage.inUse = mStageInUse;
		mEngineConfigPreset.preEqStage.bandCount = mCfgs.size();
		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
		EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mChannelConfig));
		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
		for (int i = 0; i < mChannelCount; i++) {
		cfgs[i].channel = i;
		cfgs[i].enable = true;
		}
		EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(cfgs));
		EXPECT_NO_FATAL_FAILURE(addPreEqBandConfigs(mCfgs));
		SetAndGetDynamicsProcessingParameters();
		}
		@@ -725,7 +799,12 @@ TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {
		mEngineConfigPreset.postEqStage.inUse = mStageInUse;
		mEngineConfigPreset.postEqStage.bandCount = mCfgs.size();
		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
		EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mChannelConfig));
		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
		for (int i = 0; i < mChannelCount; i++) {
		cfgs[i].channel = i;
		cfgs[i].enable = true;
		}
		EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(cfgs));
		EXPECT_NO_FATAL_FAILURE(addPostEqBandConfigs(mCfgs));
		SetAndGetDynamicsProcessingParameters();
		}
		@@ -776,28 +855,23 @@ std::vector<std::vector<std::pair<int, float>>> kBands{

		INSTANTIATE_TEST_SUITE_P(
		DynamicsProcessingTest, DynamicsProcessingTestEqBandConfig,
		::testing::Combine(
		testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
		testing::Values(-1, 0, 10), // channel ID
		testing::ValuesIn(
		DynamicsProcessingTestHelper::kChannelConfigTestSet), // channel enable
		testing::Bool(), // band enable
		testing::ValuesIn(kBands), // cut off frequencies
		testing::Values(-3.14f, 3.14f), // gain
		testing::Bool()), // stage in use
		testing::Values(true)), // stage in use
		[](const auto& info) {
		auto descriptor = std::get<EQ_BAND_INSTANCE_NAME>(info.param).second;
		std::vector<DynamicsProcessing::EqBandConfig> cfgs;
		fillEqBandConfig(cfgs, info.param);
		std::string enable =
		::android::internal::ToString(std::get<EQ_BAND_CHANNEL_ENABLE>(info.param));
		std::string bands = ::android::internal::ToString(cfgs);
		std::string stageInUse = std::to_string(std::get<EQ_BAND_STAGE_IN_USE>(info.param));
		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
		descriptor.common.name + "_UUID_" +
		descriptor.common.id.uuid.toString() + "_" + enable + "_bands_" +
		bands + "_stageInUse_" + stageInUse;
		descriptor.common.id.uuid.toString() + "_bands_" + bands +
		"_stageInUse_" + stageInUse;
		std::replace_if(
		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
		return name;
		@@ -811,7 +885,6 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestEqBandConfig
		enum MbcBandConfigParamName {
		MBC_BAND_INSTANCE_NAME,
		MBC_BAND_CHANNEL,
		MBC_BAND_CHANNEL_CONFIG,
		MBC_BAND_ENABLE,
		MBC_BAND_CUTOFF_FREQ,
		MBC_BAND_STAGE_IN_USE,
		@@ -831,16 +904,15 @@ enum MbcBandConfigAdditional {
		};
		using TestParamsMbcBandConfigAdditional = std::array<float, MBC_ADD_MAX_NUM>;

		// attachTime, releaseTime, ratio, thresh, kneeWidth, noise, expander, preGain, postGain
		// attackTime, releaseTime, ratio, thresh, kneeWidth, noise, expander, preGain, postGain
		static constexpr std::array<TestParamsMbcBandConfigAdditional, 4> kMbcBandConfigAdditionalParam = {
		{{-3, -10, -2, -2, -5, -90, -2.5, -2, -2},
		{0, 0, 0, 0, 0, 0, 0, 0, 0},
		{-3, 10, -2, 2, -5, 90, -2.5, 2, -2},
		{3, 10, 2, 2, 5, 90, 2.5, 2, 2}}};
		{3, 10, 2, -2, -5, 90, 2.5, 2, 2}}};

		using TestParamsMbcBandConfig =
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,
		std::vector<DynamicsProcessing::ChannelConfig>, bool,
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool,
		std::vector<std::pair<int, float>>, bool, TestParamsMbcBandConfigAdditional>;

		void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs,
		@@ -873,8 +945,7 @@ class DynamicsProcessingTestMbcBandConfig
		public:
		DynamicsProcessingTestMbcBandConfig()
		: DynamicsProcessingTestHelper(std::get<MBC_BAND_INSTANCE_NAME>(GetParam())),
		mStageInUse(std::get<MBC_BAND_STAGE_IN_USE>(GetParam())),
		mChannelConfig(std::get<MBC_BAND_CHANNEL_CONFIG>(GetParam())) {
		mStageInUse(std::get<MBC_BAND_STAGE_IN_USE>(GetParam())) {
		fillMbcBandConfig(mCfgs, GetParam());
		}

		@@ -884,26 +955,27 @@ class DynamicsProcessingTestMbcBandConfig

		std::vector<DynamicsProcessing::MbcBandConfig> mCfgs;
		const bool mStageInUse;
		const std::vector<DynamicsProcessing::ChannelConfig> mChannelConfig;
		};

		TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) {
		mEngineConfigPreset.mbcStage.inUse = mStageInUse;
		mEngineConfigPreset.mbcStage.bandCount = mCfgs.size();
		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
		EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mChannelConfig));
		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
		for (int i = 0; i < mChannelCount; i++) {
		cfgs[i].channel = i;
		cfgs[i].enable = true;
		}
		EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(cfgs));
		EXPECT_NO_FATAL_FAILURE(addMbcBandConfigs(mCfgs));
		SetAndGetDynamicsProcessingParameters();
		}

		INSTANTIATE_TEST_SUITE_P(
		DynamicsProcessingTest, DynamicsProcessingTestMbcBandConfig,
		::testing::Combine(
		testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
		testing::Values(-1, 0, 10), // channel count
		testing::ValuesIn(
		DynamicsProcessingTestHelper::kChannelConfigTestSet), // channel config
		testing::Bool(), // enable
		testing::ValuesIn(kBands), // cut off frequencies
		testing::Bool(), // stage in use
		@@ -912,14 +984,12 @@ INSTANTIATE_TEST_SUITE_P(
		auto descriptor = std::get<MBC_BAND_INSTANCE_NAME>(info.param).second;
		std::vector<DynamicsProcessing::MbcBandConfig> cfgs;
		fillMbcBandConfig(cfgs, info.param);
		std::string enable =
		::android::internal::ToString(std::get<MBC_BAND_CHANNEL_CONFIG>(info.param));
		std::string mbcBands = ::android::internal::ToString(cfgs);
		std::string stageInUse = std::to_string(std::get<MBC_BAND_STAGE_IN_USE>(info.param));
		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
		descriptor.common.name + "_UUID_" +
		descriptor.common.id.uuid.toString() + "_enable_" + enable +
		"_bands_" + mbcBands + "_stageInUse_" + stageInUse;
		descriptor.common.id.uuid.toString() + "_bands_" + mbcBands +
		"_stageInUse_" + stageInUse;
		std::replace_if(
		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
		return name;