Merge "VisualizerTest: Add tests for visualizer effect parameters" into main (68246be0) · Commits · e / os / android_hardware_interfaces

audio/aidl/vts/EffectHelper.h

+15 −0

Original line number	Diff line number	Diff line
		@@ -83,6 +83,8 @@ static inline std::string getPrefix(Descriptor& descriptor) {
		return prefix;
		}

		static constexpr float kMaxAudioSampleValue = 1;

		class EffectHelper {
		public:
		void create(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect>& effect,
		@@ -413,6 +415,19 @@ class EffectHelper {
		}
		}

		// Fill inputBuffer with random values between -maxAudioSampleValue to maxAudioSampleValue
		void generateInputBuffer(std::vector<float>& inputBuffer, size_t startPosition, bool isStrip,
		size_t channelCount,
		float maxAudioSampleValue = kMaxAudioSampleValue) {
		size_t increment = isStrip ? 1 /Fill input at all the channels/
		: channelCount /Fill input at only one channel/;

		for (size_t i = startPosition; i < inputBuffer.size(); i += increment) {
		inputBuffer[i] =
		((static_cast<float>(std::rand()) / RAND_MAX) * 2 - 1) * maxAudioSampleValue;
		}
		}

		// Generate multitone input between -1 to +1 using testFrequencies
		void generateMultiTone(const std::vector<int>& testFrequencies, std::vector<float>& input,
		const int samplingFrequency) {

audio/aidl/vts/VtsHalDownmixTargetTest.cpp

+4 −18

Original line number	Diff line number	Diff line
		@@ -149,22 +149,6 @@ class DownmixEffectHelper : public EffectHelper {
		mOutputBuffer.resize(mOutputBufferSize);
		}

		// Generate mInputBuffer values between -kMaxDownmixSample to kMaxDownmixSample
		void generateInputBuffer(size_t position, bool isStrip) {
		size_t increment;
		if (isStrip)
		// Fill input at all the channels
		increment = 1;
		else
		// Fill input at only one channel
		increment = mInputChannelCount;

		for (size_t i = position; i < mInputBuffer.size(); i += increment) {
		mInputBuffer[i] =
		((static_cast<float>(std::rand()) / RAND_MAX) * 2 - 1) * kMaxDownmixSample;
		}
		}

		bool isLayoutValid(int32_t inputLayout) {
		if (inputLayout & kMaxChannelMask) {
		return false;
		@@ -365,7 +349,8 @@ TEST_P(DownmixFoldDataTest, DownmixProcessData) {

		for (int32_t channel : supportedChannels) {
		size_t position = std::distance(supportedChannels.begin(), supportedChannels.find(channel));
		generateInputBuffer(position, false /isStripe/);
		generateInputBuffer(mInputBuffer, position, false /isStripe/,
		mInputChannelCount /channelCount/, kMaxDownmixSample);
		ASSERT_NO_FATAL_FAILURE(
		processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect, &mOpenEffectReturn));
		validateOutput(channel, position);
		@@ -417,7 +402,8 @@ TEST_P(DownmixStripDataTest, DownmixProcessData) {
		ASSERT_NO_FATAL_FAILURE(setParameters(Downmix::Type::STRIP));

		// Generate input buffer, call process and compare outputs
		generateInputBuffer(0 /position/, true /isStripe/);
		generateInputBuffer(mInputBuffer, 0 /position/, true /isStripe/,
		mInputChannelCount /channelCount/, kMaxDownmixSample);
		ASSERT_NO_FATAL_FAILURE(
		processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect, &mOpenEffectReturn));
		validateOutput();

audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp

+12 −19

Original line number	Diff line number	Diff line
		@@ -32,7 +32,6 @@ using aidl::android::hardware::audio::effect::LoudnessEnhancer;
		using aidl::android::hardware::audio::effect::Parameter;
		using android::hardware::audio::common::testing::detail::TestExecutionTracer;

		static constexpr float kMaxAudioSample = 1;
		static constexpr int kZeroGain = 0;
		static constexpr int kMaxGain = std::numeric_limits<int>::max();
		static constexpr int kMinGain = std::numeric_limits<int>::min();
		@@ -154,12 +153,14 @@ class LoudnessEnhancerDataTest : public ::testing::TestWithParam<LoudnessEnhance
		public:
		LoudnessEnhancerDataTest() {
		std::tie(mFactory, mDescriptor) = GetParam();
		mBufferSize = kFrameCount *
		size_t channelCount =
		getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
		AudioChannelLayout::LAYOUT_STEREO));
		generateInputBuffer();
		mBufferSizeInFrames = kFrameCount * channelCount;
		mInputBuffer.resize(mBufferSizeInFrames);
		generateInputBuffer(mInputBuffer, 0, true, channelCount, kMaxAudioSampleValue);

		mOutputBuffer.resize(mBufferSize);
		mOutputBuffer.resize(mBufferSizeInFrames);
		}

		void SetUp() override {
		@@ -177,14 +178,6 @@ class LoudnessEnhancerDataTest : public ::testing::TestWithParam<LoudnessEnhance
		TearDownLoudnessEnhancer();
		}

		// Fill inputBuffer with random values between -kMaxAudioSample to kMaxAudioSample
		void generateInputBuffer() {
		for (size_t i = 0; i < mBufferSize; i++) {
		mInputBuffer.push_back(((static_cast<float>(std::rand()) / RAND_MAX) * 2 - 1) *
		kMaxAudioSample);
		}
		}

		// Add gains to the mInputBuffer and store processed output to mOutputBuffer
		void processAndWriteToOutput() {
		// Check AidlMessageQueues are not null
		@@ -220,7 +213,7 @@ class LoudnessEnhancerDataTest : public ::testing::TestWithParam<LoudnessEnhance
		}

		void assertSequentialGains(const std::vector<int>& gainValues, bool isIncreasing) {
		std::vector<float> baseOutput(mBufferSize);
		std::vector<float> baseOutput(mBufferSizeInFrames);

		// Process a reference output buffer with 0 gain which gives compressed input values
		binder_exception_t expected;
		@@ -257,7 +250,7 @@ class LoudnessEnhancerDataTest : public ::testing::TestWithParam<LoudnessEnhance

		std::vector<float> mInputBuffer;
		std::vector<float> mOutputBuffer;
		size_t mBufferSize;
		size_t mBufferSizeInFrames;
		};

		TEST_P(LoudnessEnhancerDataTest, IncreasingGains) {
		@@ -296,10 +289,10 @@ TEST_P(LoudnessEnhancerDataTest, MaximumGain) {
		setParameters(kMaxGain, expected);
		ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput());

		// Validate that mOutputBuffer reaches to kMaxAudioSample for INT_MAX gain
		// Validate that mOutputBuffer reaches to kMaxAudioSampleValue for INT_MAX gain
		for (size_t i = 0; i < mOutputBuffer.size(); i++) {
		if (mInputBuffer[i] != 0) {
		EXPECT_NEAR(kMaxAudioSample, abs(mOutputBuffer[i]), kAbsError);
		EXPECT_NEAR(kMaxAudioSampleValue, abs(mOutputBuffer[i]), kAbsError);
		} else {
		ASSERT_EQ(mOutputBuffer[i], mInputBuffer[i]);
		}

audio/aidl/vts/VtsHalVisualizerTargetTest.cpp

+54 −10

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@

		using namespace android;

		using aidl::android::hardware::audio::common::getChannelCount;
		using aidl::android::hardware::audio::effect::Descriptor;
		using aidl::android::hardware::audio::effect::getEffectTypeUuidVisualizer;
		using aidl::android::hardware::audio::effect::IEffect;
		@@ -56,6 +57,15 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		mMeasurementMode(std::get<PARAM_MEASUREMENT_MODE>(GetParam())),
		mLatency(std::get<PARAM_LATENCY>(GetParam())) {
		std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());

		size_t channelCount =
		getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
		AudioChannelLayout::LAYOUT_STEREO));
		mBufferSizeInFrames = kInputFrameCount * channelCount;
		mInputBuffer.resize(mBufferSizeInFrames);
		generateInputBuffer(mInputBuffer, 0, true, channelCount, kMaxAudioSampleValue);

		mOutputBuffer.resize(mBufferSizeInFrames);
		}

		void SetUp() override {
		@@ -65,14 +75,15 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		Parameter::Common common = createParamCommon(
		0 /* session /, 1 / ioHandle /, 44100 / iSampleRate /, 44100 / oSampleRate */,
		kInputFrameCount /* iFrameCount /, kOutputFrameCount / oFrameCount */);
		IEffect::OpenEffectReturn ret;
		ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &ret, EX_NONE));
		ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &mOpenEffectReturn, EX_NONE));
		ASSERT_NE(nullptr, mEffect);
		mVersion = EffectFactoryHelper::getHalVersion(mFactory);
		}

		void TearDown() override {
		ASSERT_NO_FATAL_FAILURE(close(mEffect));
		ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
		mOpenEffectReturn = IEffect::OpenEffectReturn{};
		}

		static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
		@@ -83,6 +94,12 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		Visualizer::ScalingMode mScalingMode = Visualizer::ScalingMode::NORMALIZED;
		Visualizer::MeasurementMode mMeasurementMode = Visualizer::MeasurementMode::NONE;
		int mLatency = 0;
		int mVersion = 0;
		std::vector<float> mInputBuffer;
		std::vector<float> mOutputBuffer;
		size_t mBufferSizeInFrames;
		IEffect::OpenEffectReturn mOpenEffectReturn;
		bool mAllParamsValid = true;

		void SetAndGetParameters() {
		for (auto& it : mCommonTags) {
		@@ -94,6 +111,7 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
		const bool valid = isParameterValid<Visualizer, Range::visualizer>(vs, desc);
		const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;
		if (expected == EX_ILLEGAL_ARGUMENT) mAllParamsValid = false;

		// set parameter
		Parameter expectParam;
		@@ -153,23 +171,49 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
		};

		TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {
		EXPECT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
		SetAndGetParameters();
		ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
		}

		TEST_P(VisualizerParamTest, SetAndGetScalingMode) {
		EXPECT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
		SetAndGetParameters();
		ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
		}

		TEST_P(VisualizerParamTest, SetAndGetMeasurementMode) {
		EXPECT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
		SetAndGetParameters();
		ASSERT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
		}

		TEST_P(VisualizerParamTest, SetAndGetLatency) {
		EXPECT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
		SetAndGetParameters();
		ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
		}

		TEST_P(VisualizerParamTest, testCaptureSampleBufferSizeAndOutput) {
		ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
		ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
		ASSERT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
		ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
		ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());

		Parameter getParam;
		Parameter::Id id;
		Visualizer::Id vsId;
		vsId.set<Visualizer::Id::commonTag>(Visualizer::captureSampleBuffer);
		id.set<Parameter::Id::visualizerTag>(vsId);
		EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam)) << " with: " << id.toString();

		ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect,
		&mOpenEffectReturn, mVersion));
		ASSERT_EQ(mInputBuffer, mOutputBuffer);

		if (mAllParamsValid) {
		std::vector<uint8_t> captureBuffer = getParam.get<Parameter::specific>()
		.get<Parameter::Specific::visualizer>()
		.get<Visualizer::captureSampleBuffer>();
		ASSERT_EQ((size_t)mCaptureSize, captureBuffer.size());
		}
		}

		std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;