Merge "Effect AIDL Refine effect test parameter combination list" (c6d1c384) · Commits · e / os / android_hardware_interfaces

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_" +