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

VisualizerTest: Add tests for visualizer effect parameters

Browse Source 
Bug: 305866207

Test: atest VtsHalVisualizerTargetTest

Change-Id: I07faeabe1fc468fb0ba480266ba68e8882c3801e
This commit is contained in:
Aayush Soni
2024-09-11 13:51:14 +00:00
parent 394cfc601a
commit bb001fbca6
4 changed files with 84 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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) {

22
audio/aidl/vts/VtsHalDownmixTargetTest.cpp
View File

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

29
audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp
View File

@@ -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 *
getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
AudioChannelLayout::LAYOUT_STEREO));
generateInputBuffer();
size_t channelCount =
getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
AudioChannelLayout::LAYOUT_STEREO));
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]);
}

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

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