Merge "VisualizerTest: Improve testing for visualizer effect parameters" into main (e499051d) · Commits · e / os / android_hardware_interfaces

audio/aidl/vts/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		@@ -166,6 +166,9 @@ cc_test {
		name: "VtsHalVisualizerTargetTest",
		defaults: ["VtsHalAudioEffectTargetTestDefaults"],
		srcs: ["VtsHalVisualizerTargetTest.cpp"],
		shared_libs: [
		"libaudioutils",
		],
		}

		cc_test {

audio/aidl/vts/EffectHelper.h

+8 −3

Original line number	Diff line number	Diff line
		@@ -375,7 +375,8 @@ class EffectHelper {
		std::vector<float>& outputBuffer,
		const std::shared_ptr<IEffect>& effect,
		IEffect::OpenEffectReturn* openEffectReturn,
		int version = -1, int times = 1) {
		int version = -1, int times = 1,
		bool callStopReset = true) {
		// Initialize AidlMessagequeues
		auto statusMQ = std::make_unique<EffectHelper::StatusMQ>(openEffectReturn->statusMQ);
		ASSERT_TRUE(statusMQ->isValid());
		@@ -401,11 +402,15 @@ class EffectHelper {
		}

		// Disable the process
		if (callStopReset) {
		ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::STOP));
		}
		EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 0, outputMQ, 0, outputBuffer));

		if (callStopReset) {
		ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET));
		}
		}

		// Find FFT bin indices for testFrequencies and get bin center frequencies
		void roundToFreqCenteredToFftBin(std::vector<int>& testFrequencies,

audio/aidl/vts/VtsHalVisualizerTargetTest.cpp

+116 −11

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#define LOG_TAG "VtsHalVisualizerTest"
		#include <android-base/logging.h>
		#include <android/binder_enums.h>
		#include <audio_utils/power.h>

		#include "EffectHelper.h"

		@@ -44,9 +45,8 @@ enum ParamName {
		PARAM_MEASUREMENT_MODE,
		PARAM_LATENCY,
		};
		using VisualizerParamTestParam =
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int, Visualizer::ScalingMode,
		Visualizer::MeasurementMode, int>;
		using VisualizerTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int,
		Visualizer::ScalingMode, Visualizer::MeasurementMode, int>;

		class VisualizerTestHelper : public EffectHelper {
		public:
		@@ -139,10 +139,15 @@ class VisualizerTestHelper : public EffectHelper {
		{Visualizer::latencyMs, Visualizer::make<Visualizer::latencyMs>(latency)});
		}

		static std::unordered_set<Visualizer::ScalingMode> getScalingModeValues() {
		return {ndk::enum_range<Visualizer::ScalingMode>().begin(),
		ndk::enum_range<Visualizer::ScalingMode>().end()};
		}

		static constexpr long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
		const size_t mChannelCount =
		getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
		AudioChannelLayout::LAYOUT_STEREO));
		AudioChannelLayout::LAYOUT_MONO));
		const size_t mBufferSizeInFrames = kInputFrameCount * mChannelCount;
		const int mCaptureSize;
		const int mLatency;
		@@ -161,7 +166,7 @@ class VisualizerTestHelper : public EffectHelper {
		void CleanUp() { mCommonTags.clear(); }
		};

		class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestParam>,
		class VisualizerParamTest : public ::testing::TestWithParam<VisualizerTestParam>,
		public VisualizerTestHelper {
		public:
		VisualizerParamTest()
		@@ -181,11 +186,6 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		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()};
		}
		};

		TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {
		@@ -237,6 +237,82 @@ TEST_P(VisualizerParamTest, testCaptureSampleBufferSizeAndOutput) {
		}
		}

		class VisualizerDataTest : public ::testing::TestWithParam<VisualizerTestParam>,
		public VisualizerTestHelper {
		public:
		VisualizerDataTest()
		: VisualizerTestHelper(std::get<PARAM_INSTANCE_NAME>(GetParam()),
		std::get<PARAM_CAPTURE_SIZE>(GetParam()),
		std::get<PARAM_LATENCY>(GetParam()),
		std::get<PARAM_SCALING_MODE>(GetParam()),
		std::get<PARAM_MEASUREMENT_MODE>(GetParam())) {}

		void SetUp() override { SetUpVisualizer(); }

		void TearDown() override { TearDownVisualizer(); }
		};

		TEST_P(VisualizerDataTest, testScalingModeParameters) {
		SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);

		// This test holds true for the following range
		static_assert(kMaxAudioSampleValue <= 1.0 && kMaxAudioSampleValue > 0.0,
		"Valid range of kMaxAudioSample value for the test: (0.0, 1.0]");

		constexpr float kPowerToleranceDb = 0.5;

		generateSineWave(std::vector<int>{1000}, mInputBuffer, 1.0, mBufferSizeInFrames);
		const float expectedPowerNormalized = audio_utils_compute_power_mono(
		mInputBuffer.data(), AUDIO_FORMAT_PCM_FLOAT, mInputBuffer.size());

		const std::vector<float> testMaxAudioSampleValueList = {
		0.25 * kMaxAudioSampleValue, 0.5 * kMaxAudioSampleValue, 0.75 * kMaxAudioSampleValue,
		kMaxAudioSampleValue};

		Parameter::Id idCsb;
		Visualizer::Id vsIdCsb;
		vsIdCsb.set<Visualizer::Id::commonTag>(Visualizer::captureSampleBuffer);
		idCsb.set<Parameter::Id::visualizerTag>(vsIdCsb);

		for (float maxAudioSampleValue : testMaxAudioSampleValueList) {
		bool allParamsValid = true;
		ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
		ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
		ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters(&allParamsValid));

		generateSineWave(std::vector<int>{1000}, mInputBuffer, maxAudioSampleValue,
		mBufferSizeInFrames);

		// The stop and reset calls to the effect are made towards the end in order to fetch the
		// captureSampleBuffer values
		ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect,
		&mOpenEffectReturn, mVersion, 1, false));
		if (allParamsValid) {
		Parameter getParam;
		EXPECT_STATUS(EX_NONE, mEffect->getParameter(idCsb, &getParam))
		<< " with: " << idCsb.toString();
		std::vector<uint8_t> captureBuffer = getParam.get<Parameter::specific>()
		.get<Parameter::Specific::visualizer>()
		.get<Visualizer::captureSampleBuffer>();
		ASSERT_EQ((size_t)mCaptureSize, captureBuffer.size());

		float currPowerCsb = audio_utils_compute_power_mono(
		captureBuffer.data(), AUDIO_FORMAT_PCM_8_BIT, mCaptureSize);

		if (mScalingMode == Visualizer::ScalingMode::NORMALIZED) {
		EXPECT_NEAR(currPowerCsb, expectedPowerNormalized, kPowerToleranceDb);
		} else {
		float powerI = audio_utils_compute_power_mono(
		mInputBuffer.data(), AUDIO_FORMAT_PCM_FLOAT, mInputBuffer.size());
		EXPECT_NEAR(currPowerCsb, powerI, kPowerToleranceDb);
		}
		}
		ASSERT_NO_FATAL_FAILURE(command(mEffect, CommandId::STOP));
		ASSERT_NO_FATAL_FAILURE(command(mEffect, CommandId::RESET));
		}
		}

		std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
		INSTANTIATE_TEST_SUITE_P(
		VisualizerParamTest, VisualizerParamTest,
		@@ -246,7 +322,7 @@ INSTANTIATE_TEST_SUITE_P(
		testing::ValuesIn(EffectHelper::getTestValueSet<Visualizer, int, Range::visualizer,
		Visualizer::captureSamples>(
		kDescPair, EffectHelper::expandTestValueBasic<int>)),
		testing::ValuesIn(VisualizerParamTest::getScalingModeValues()),
		testing::ValuesIn(VisualizerTestHelper::getScalingModeValues()),
		testing::ValuesIn(VisualizerParamTest::getMeasurementModeValues()),
		testing::ValuesIn(EffectHelper::getTestValueSet<Visualizer, int, Range::visualizer,
		Visualizer::latencyMs>(
		@@ -270,6 +346,35 @@ INSTANTIATE_TEST_SUITE_P(

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VisualizerParamTest);

		INSTANTIATE_TEST_SUITE_P(
		VisualizerDataTest, VisualizerDataTest,
		::testing::Combine(
		testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, getEffectTypeUuidVisualizer())),
		testing::Values(128), // captureSize
		testing::ValuesIn(VisualizerTestHelper::getScalingModeValues()),
		testing::Values(Visualizer::MeasurementMode::PEAK_RMS),
		testing::Values(0) // latency
		),
		[](const testing::TestParamInfo<VisualizerDataTest::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 = 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 = getPrefix(descriptor) + "_captureSize" + captureSize +
		"_scalingMode" + scalingMode + "_measurementMode" + measurementMode +
		"_latency" + latency;
		std::replace_if(
		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
		return name;
		});

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VisualizerDataTest);

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);
		::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());