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

Merge "Volume Control: Add tests to validate Volume Control Effect" into main am: 4fbb997e17

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/2968207

Change-Id: I9fe1b948ec1f168816258c443b0fc3a5c11e6d35
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Mikhail Naganov
2024-02-22 02:50:03 +00:00
committed by Automerger Merge Worker
parent dbe3ce37e9 4fbb997e17
commit 9970dadaa9
3 changed files with 289 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -26,6 +26,7 @@ cc_defaults {
"android.hardware.common.fmq-V1-ndk",
"libaudioaidlcommon",
"libaidlcommonsupport",
"libpffft",
],
header_libs: [
"libaudioaidl_headers",
@@ -36,6 +37,7 @@ cc_defaults {
"-Wextra",
"-Werror",
"-Wthread-safety",
"-Wno-error=unused-parameter",
],
test_config_template: "VtsHalAudioTargetTestTemplate.xml",
test_suites: [

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

@@ -37,6 +37,7 @@
#include "EffectFactoryHelper.h"
#include "TestUtils.h"
#include "pffft.hpp"
using namespace android;
using aidl::android::hardware::audio::effect::CommandId;
@@ -329,4 +330,45 @@ class EffectHelper {
ASSERT_NO_FATAL_FAILURE(command(mEffect, CommandId::RESET));
ASSERT_NO_FATAL_FAILURE(expectState(mEffect, State::IDLE));
}
// Find FFT bin indices for testFrequencies and get bin center frequencies
void roundToFreqCenteredToFftBin(std::vector<int>& testFrequencies,
std::vector<int>& binOffsets, const float kBinWidth) {
for (size_t i = 0; i < testFrequencies.size(); i++) {
binOffsets[i] = std::round(testFrequencies[i] / kBinWidth);
testFrequencies[i] = std::round(binOffsets[i] * kBinWidth);
}
}
// Generate multitone input between -1 to +1 using testFrequencies
void generateMultiTone(const std::vector<int>& testFrequencies, std::vector<float>& input,
const int samplingFrequency) {
for (size_t i = 0; i < input.size(); i++) {
input[i] = 0;
for (size_t j = 0; j < testFrequencies.size(); j++) {
input[i] += sin(2 * M_PI * testFrequencies[j] * i / samplingFrequency);
}
input[i] /= testFrequencies.size();
}
}
// Use FFT transform to convert the buffer to frequency domain
// Compute its magnitude at binOffsets
std::vector<float> calculateMagnitude(const std::vector<float>& buffer,
const std::vector<int>& binOffsets, const int nPointFFT) {
std::vector<float> fftInput(nPointFFT);
PFFFT_Setup* inputHandle = pffft_new_setup(nPointFFT, PFFFT_REAL);
pffft_transform_ordered(inputHandle, buffer.data(), fftInput.data(), nullptr,
PFFFT_FORWARD);
pffft_destroy_setup(inputHandle);
std::vector<float> bufferMag(binOffsets.size());
for (size_t i = 0; i < binOffsets.size(); i++) {
size_t k = binOffsets[i];
bufferMag[i] = sqrt((fftInput[k * 2] * fftInput[k * 2]) +
(fftInput[k * 2 + 1] * fftInput[k * 2 + 1]));
}
return bufferMag;
}
};

327
audio/aidl/vts/VtsHalVolumeTargetTest.cpp
View File

@@ -21,6 +21,7 @@
using namespace android;
using aidl::android::hardware::audio::common::getChannelCount;
using aidl::android::hardware::audio::effect::Descriptor;
using aidl::android::hardware::audio::effect::getEffectTypeUuidVolume;
using aidl::android::hardware::audio::effect::IEffect;
@@ -29,6 +30,80 @@ using aidl::android::hardware::audio::effect::Parameter;
using aidl::android::hardware::audio::effect::Volume;
using android::hardware::audio::common::testing::detail::TestExecutionTracer;
class VolumeControlHelper : public EffectHelper {
public:
void SetUpVolumeControl() {
ASSERT_NE(nullptr, mFactory);
ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
initFrameCount();
Parameter::Specific specific = getDefaultParamSpecific();
Parameter::Common common = EffectHelper::createParamCommon(
0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,
kSamplingFrequency /* oSampleRate */, mInputFrameCount /* iFrameCount */,
mInputFrameCount /* oFrameCount */);
ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE));
ASSERT_NE(nullptr, mEffect);
}
void TearDownVolumeControl() {
ASSERT_NO_FATAL_FAILURE(close(mEffect));
ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
mOpenEffectReturn = IEffect::OpenEffectReturn{};
}
Parameter::Specific getDefaultParamSpecific() {
Volume vol = Volume::make<Volume::levelDb>(kMinLevel);
Parameter::Specific specific = Parameter::Specific::make<Parameter::Specific::volume>(vol);
return specific;
}
Parameter createVolumeParam(int param, Volume::Tag volTag) {
return Parameter::make<Parameter::specific>(
Parameter::Specific::make<Parameter::Specific::volume>(
(volTag == Volume::mute) ? Volume::make<Volume::mute>(param)
: Volume::make<Volume::levelDb>(param)));
}
void initFrameCount() {
int channelCount = getChannelCount(
AudioChannelLayout::make<AudioChannelLayout::layoutMask>(kDefaultChannelLayout));
mInputFrameCount = kBufferSize / channelCount;
mOutputFrameCount = kBufferSize / channelCount;
}
bool isLevelValid(int level) {
auto vol = Volume::make<Volume::levelDb>(level);
return isParameterValid<Volume, Range::volume>(vol, mDescriptor);
}
void setAndVerifyParameters(Volume::Tag volTag, int param, binder_exception_t expected) {
auto expectedParam = createVolumeParam(param, volTag);
EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();
if (expected == EX_NONE) {
Volume::Id volId = Volume::Id::make<Volume::Id::commonTag>(volTag);
auto id = Parameter::Id::make<Parameter::Id::volumeTag>(volId);
// get parameter
Parameter getParam;
// if set success, then get should match
EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));
EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()
<< "\ngetParam:" << getParam.toString();
}
}
static constexpr int kSamplingFrequency = 44100;
static constexpr int kDurationMilliSec = 2000;
static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;
static constexpr int kMinLevel = -96;
static constexpr int kDefaultChannelLayout = AudioChannelLayout::LAYOUT_STEREO;
long mInputFrameCount, mOutputFrameCount;
std::shared_ptr<IFactory> mFactory;
std::shared_ptr<IEffect> mEffect;
IEffect::OpenEffectReturn mOpenEffectReturn;
Descriptor mDescriptor;
};
/**
* Here we focus on specific parameter checking, general IEffect interfaces testing performed in
* VtsAudioEffectTargetTest.
@@ -37,7 +112,8 @@ enum ParamName { PARAM_INSTANCE_NAME, PARAM_LEVEL, PARAM_MUTE };
using VolumeParamTestParam =
std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int, bool>;
class VolumeParamTest : public ::testing::TestWithParam<VolumeParamTestParam>, public EffectHelper {
class VolumeParamTest : public ::testing::TestWithParam<VolumeParamTestParam>,
public VolumeControlHelper {
public:
VolumeParamTest()
: mParamLevel(std::get<PARAM_LEVEL>(GetParam())),
@@ -45,94 +121,167 @@ class VolumeParamTest : public ::testing::TestWithParam<VolumeParamTestParam>, p
std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
}
void SetUp() override {
ASSERT_NE(nullptr, mFactory);
ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl()); }
void TearDown() override { TearDownVolumeControl(); }
Parameter::Specific specific = getDefaultParamSpecific();
Parameter::Common common = EffectHelper::createParamCommon(
0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,
kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);
IEffect::OpenEffectReturn ret;
ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));
ASSERT_NE(nullptr, mEffect);
}
void TearDown() override {
ASSERT_NO_FATAL_FAILURE(close(mEffect));
ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
}
Parameter::Specific getDefaultParamSpecific() {
Volume vol = Volume::make<Volume::levelDb>(-9600);
Parameter::Specific specific = Parameter::Specific::make<Parameter::Specific::volume>(vol);
return specific;
}
static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
std::shared_ptr<IFactory> mFactory;
std::shared_ptr<IEffect> mEffect;
Descriptor mDescriptor;
int mParamLevel = 0;
bool mParamMute = false;
void SetAndGetParameters() {
for (auto& it : mTags) {
auto& tag = it.first;
auto& vol = it.second;
// validate parameter
Descriptor desc;
ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
const bool valid = isParameterValid<Volume, Range::volume>(it.second, desc);
const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;
// set parameter
Parameter expectParam;
Parameter::Specific specific;
specific.set<Parameter::Specific::volume>(vol);
expectParam.set<Parameter::specific>(specific);
EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();
// only get if parameter is in range and set success
if (expected == EX_NONE) {
Parameter getParam;
Parameter::Id id;
Volume::Id volId;
volId.set<Volume::Id::commonTag>(tag);
id.set<Parameter::Id::volumeTag>(volId);
EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));
EXPECT_EQ(expectParam, getParam) << "\nexpect:" << expectParam.toString()
<< "\ngetParam:" << getParam.toString();
}
}
}
void addLevelParam(int level) {
Volume vol;
vol.set<Volume::levelDb>(level);
mTags.push_back({Volume::levelDb, vol});
}
void addMuteParam(bool mute) {
Volume vol;
vol.set<Volume::mute>(mute);
mTags.push_back({Volume::mute, vol});
}
private:
std::vector<std::pair<Volume::Tag, Volume>> mTags;
void CleanUp() { mTags.clear(); }
};
TEST_P(VolumeParamTest, SetAndGetLevel) {
EXPECT_NO_FATAL_FAILURE(addLevelParam(mParamLevel));
SetAndGetParameters();
TEST_P(VolumeParamTest, SetAndGetParams) {
ASSERT_NO_FATAL_FAILURE(
setAndVerifyParameters(Volume::levelDb, mParamLevel,
isLevelValid(mParamLevel) ? EX_NONE : EX_ILLEGAL_ARGUMENT));
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, mParamMute, EX_NONE));
}
TEST_P(VolumeParamTest, SetAndGetMute) {
EXPECT_NO_FATAL_FAILURE(addMuteParam(mParamMute));
SetAndGetParameters();
using VolumeDataTestParam = std::pair<std::shared_ptr<IFactory>, Descriptor>;
class VolumeDataTest : public ::testing::TestWithParam<VolumeDataTestParam>,
public VolumeControlHelper {
public:
VolumeDataTest() {
std::tie(mFactory, mDescriptor) = GetParam();
mInput.resize(kBufferSize);
mInputMag.resize(mTestFrequencies.size());
mBinOffsets.resize(mTestFrequencies.size());
roundToFreqCenteredToFftBin(mTestFrequencies, mBinOffsets, kBinWidth);
generateMultiTone(mTestFrequencies, mInput, kSamplingFrequency);
mInputMag = calculateMagnitude(mInput, mBinOffsets, kNPointFFT);
}
std::vector<int> calculatePercentageDiff(const std::vector<float>& outputMag) {
std::vector<int> percentages(mTestFrequencies.size());
for (size_t i = 0; i < mInputMag.size(); i++) {
float diff = mInputMag[i] - outputMag[i];
percentages[i] = std::round(diff / mInputMag[i] * 100);
}
return percentages;
}
// Convert Decibel value to Percentage
int percentageDb(float level) { return std::round((1 - (pow(10, level / 20))) * 100); }
void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl()); }
void TearDown() override { TearDownVolumeControl(); }
static constexpr int kMaxAudioSample = 1;
static constexpr int kTransitionDuration = 300;
static constexpr int kNPointFFT = 32768;
static constexpr float kBinWidth = (float)kSamplingFrequency / kNPointFFT;
static constexpr size_t offset = kSamplingFrequency * kTransitionDuration / 1000;
static constexpr float kBaseLevel = 0;
std::vector<int> mTestFrequencies = {100, 1000};
std::vector<float> mInput;
std::vector<float> mInputMag;
std::vector<int> mBinOffsets;
};
TEST_P(VolumeDataTest, ApplyLevelMuteUnmute) {
std::vector<float> output(kBufferSize);
std::vector<int> diffs(mTestFrequencies.size());
std::vector<float> outputMag(mTestFrequencies.size());
if (!isLevelValid(kBaseLevel)) {
GTEST_SKIP() << "Volume Level not supported, skipping the test\n";
}
// Apply Volume Level
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, kBaseLevel, EX_NONE));
ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
outputMag = calculateMagnitude(output, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_EQ(diffs[i], percentageDb(kBaseLevel));
}
// Apply Mute
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, true /*mute*/, EX_NONE));
ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
std::vector<float> subOutputMute(output.begin() + offset, output.end());
outputMag = calculateMagnitude(subOutputMute, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_EQ(diffs[i], percentageDb(kMinLevel /*Mute*/));
}
// Verifying Fade out
outputMag = calculateMagnitude(output, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_LT(diffs[i], percentageDb(kMinLevel /*Mute*/));
}
// Apply Unmute
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, false /*unmute*/, EX_NONE));
ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
std::vector<float> subOutputUnmute(output.begin() + offset, output.end());
outputMag = calculateMagnitude(subOutputUnmute, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_EQ(diffs[i], percentageDb(kBaseLevel));
}
// Verifying Fade in
outputMag = calculateMagnitude(output, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_GT(diffs[i], percentageDb(kBaseLevel));
}
}
TEST_P(VolumeDataTest, DecreasingLevels) {
std::vector<int> decreasingLevels = {-24, -48, -96};
std::vector<float> baseOutput(kBufferSize);
std::vector<int> baseDiffs(mTestFrequencies.size());
std::vector<float> outputMag(mTestFrequencies.size());
if (!isLevelValid(kBaseLevel)) {
GTEST_SKIP() << "Volume Level not supported, skipping the test\n";
}
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, kBaseLevel, EX_NONE));
ASSERT_NO_FATAL_FAILURE(
processAndWriteToOutput(mInput, baseOutput, mEffect, &mOpenEffectReturn));
outputMag = calculateMagnitude(baseOutput, mBinOffsets, kNPointFFT);
baseDiffs = calculatePercentageDiff(outputMag);
for (int level : decreasingLevels) {
std::vector<float> output(kBufferSize);
std::vector<int> diffs(mTestFrequencies.size());
// Skipping the further steps for unnsupported level values
if (!isLevelValid(level)) {
continue;
}
ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, level, EX_NONE));
ASSERT_NO_FATAL_FAILURE(
processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
outputMag = calculateMagnitude(output, mBinOffsets, kNPointFFT);
diffs = calculatePercentageDiff(outputMag);
// Decrease in volume level results in greater magnitude difference
for (size_t i = 0; i < diffs.size(); i++) {
ASSERT_GT(diffs[i], baseDiffs[i]);
}
baseDiffs = diffs;
}
}
std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
@@ -157,6 +306,20 @@ INSTANTIATE_TEST_SUITE_P(
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VolumeParamTest);
INSTANTIATE_TEST_SUITE_P(VolumeTest, VolumeDataTest,
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidVolume())),
[](const testing::TestParamInfo<VolumeDataTest::ParamType>& info) {
auto descriptor = info.param;
std::string name = getPrefix(descriptor.second);
std::replace_if(
name.begin(), name.end(),
[](const char c) { return !std::isalnum(c); }, '_');
return name;
});
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VolumeDataTest);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());