Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-02 17:31:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "VisualizerTest: Improve testing for visualizer effect parameters" into main

Browse Source
This commit is contained in:
Treehugger Robot
2024-11-19 18:08:46 +00:00
committed by Gerrit Code Review
parent 2962de54a1 9eb548c0ee
commit e499051d98
3 changed files with 127 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
audio/aidl/vts/Android.bp
View File

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

11
audio/aidl/vts/EffectHelper.h
View File

@@ -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,10 +402,14 @@ class EffectHelper {
}
// Disable the process
ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::STOP));
if (callStopReset) {
ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::STOP));
}
EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 0, outputMQ, 0, outputBuffer));
ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET));
if (callStopReset) {
ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET));
}
}
// Find FFT bin indices for testFrequencies and get bin center frequencies

127
audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
View File

@@ -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());