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

Merge "DynamicsProcessing: Validate config params based on ranges advertised" am: d14815472d

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

Change-Id: I9bbb0fe1d5303f4abd6453c107463143d56d7a2b
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Treehugger Robot
2023-03-30 16:36:43 +00:00
committed by Automerger Merge Worker
parent a635a84622 d14815472d
commit 7449c3da5b
2 changed files with 129 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -84,6 +84,7 @@ cc_test {
cc_test {
name: "VtsHalDynamicsProcessingTargetTest",
defaults: ["VtsHalAudioTargetTestDefaults"],
static_libs: ["libaudioaidlranges"],
srcs: ["VtsHalDynamicsProcessingTest.cpp"],
}

186
audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
View File

@@ -25,8 +25,10 @@
#include <Utils.h>
#include "EffectHelper.h"
#include "EffectRangeSpecific.h"
using namespace android;
using namespace aidl::android::hardware::audio::effect::DynamicsProcessingRanges;
using aidl::android::hardware::audio::effect::Descriptor;
using aidl::android::hardware::audio::effect::DynamicsProcessing;
@@ -95,6 +97,19 @@ class DynamicsProcessingTestHelper : public EffectHelper {
template <typename T>
bool isAidlVectorEqual(const std::vector<T>& source, const std::vector<T>& target);
template <typename T>
bool isChannelConfigValid(const std::vector<T>& cfgs) {
auto& channelCount = mChannelCount;
return std::all_of(cfgs.cbegin(), cfgs.cend(), [channelCount](const T& cfg) {
return (cfg.channel >= 0 && cfg.channel < channelCount);
});
}
template <typename T>
bool isBandConfigValid(const std::vector<T>& cfgs, int bandCount);
bool isParamValid(const DynamicsProcessing::Tag& tag, const DynamicsProcessing& dp);
// get set params and validate
void SetAndGetDynamicsProcessingParameters();
@@ -133,9 +148,11 @@ class DynamicsProcessingTestHelper : public EffectHelper {
static const std::set<DynamicsProcessing::StageEnablement> kStageEnablementTestSet;
static const std::set<std::vector<DynamicsProcessing::InputGain>> kInputGainTestSet;
protected:
int mChannelCount;
private:
int32_t mChannelLayout;
int mChannelCount;
std::vector<std::pair<DynamicsProcessing::Tag, DynamicsProcessing>> mTags;
void CleanUp() {
mTags.clear();
@@ -152,6 +169,8 @@ const std::set<DynamicsProcessing::StageEnablement>
{.inUse = true, .bandCount = DynamicsProcessingTestHelper::kBandCount},
{.inUse = true, .bandCount = 0},
{.inUse = true, .bandCount = -1},
{.inUse = false, .bandCount = 0},
{.inUse = false, .bandCount = -1},
{.inUse = false, .bandCount = DynamicsProcessingTestHelper::kBandCount}};
// test value set for DynamicsProcessing::ChannelConfig
@@ -161,9 +180,7 @@ const std::set<std::vector<DynamicsProcessing::ChannelConfig>>
{.channel = 0, .enable = true},
{.channel = 1, .enable = false},
{.channel = 2, .enable = true}},
{{.channel = -1, .enable = false}, {.channel = 2, .enable = true}},
{{.channel = 0, .enable = true}, {.channel = 1, .enable = true}}};
// test value set for DynamicsProcessing::InputGain
@@ -172,10 +189,65 @@ const std::set<std::vector<DynamicsProcessing::InputGain>>
{{.channel = 0, .gainDb = 10.f},
{.channel = 1, .gainDb = 0.f},
{.channel = 2, .gainDb = -10.f}},
{{.channel = -1, .gainDb = -10.f}, {.channel = -2, .gainDb = 10.f}},
{{.channel = -1, .gainDb = 10.f}, {.channel = 0, .gainDb = -10.f}},
{{.channel = 0, .gainDb = 10.f}, {.channel = 1, .gainDb = -10.f}}};
{{.channel = -1, .gainDb = 10.f}, {.channel = 0, .gainDb = -10.f}}};
template <typename T>
bool DynamicsProcessingTestHelper::isBandConfigValid(const std::vector<T>& cfgs, int bandCount) {
std::vector<float> freqs(cfgs.size(), -1);
for (auto cfg : cfgs) {
if (cfg.channel < 0 || cfg.channel >= mChannelCount) return false;
if (cfg.band < 0 || cfg.band >= bandCount) return false;
freqs[cfg.band] = cfg.cutoffFrequencyHz;
}
if (std::count(freqs.begin(), freqs.end(), -1)) return false;
return std::is_sorted(freqs.begin(), freqs.end());
}
bool DynamicsProcessingTestHelper::isParamValid(const DynamicsProcessing::Tag& tag,
const DynamicsProcessing& dp) {
switch (tag) {
case DynamicsProcessing::preEq: {
if (!mEngineConfigApplied.preEqStage.inUse) return false;
return isChannelConfigValid(dp.get<DynamicsProcessing::preEq>());
}
case DynamicsProcessing::postEq: {
if (!mEngineConfigApplied.postEqStage.inUse) return false;
return isChannelConfigValid(dp.get<DynamicsProcessing::postEq>());
}
case DynamicsProcessing::mbc: {
if (!mEngineConfigApplied.mbcStage.inUse) return false;
return isChannelConfigValid(dp.get<DynamicsProcessing::mbc>());
}
case DynamicsProcessing::preEqBand: {
if (!mEngineConfigApplied.preEqStage.inUse) return false;
return isBandConfigValid(dp.get<DynamicsProcessing::preEqBand>(),
mEngineConfigApplied.preEqStage.bandCount);
}
case DynamicsProcessing::postEqBand: {
if (!mEngineConfigApplied.postEqStage.inUse) return false;
return isBandConfigValid(dp.get<DynamicsProcessing::postEqBand>(),
mEngineConfigApplied.postEqStage.bandCount);
}
case DynamicsProcessing::mbcBand: {
if (!mEngineConfigApplied.mbcStage.inUse) return false;
return isBandConfigValid(dp.get<DynamicsProcessing::mbcBand>(),
mEngineConfigApplied.mbcStage.bandCount);
}
case DynamicsProcessing::limiter: {
if (!mEngineConfigApplied.limiterInUse) return false;
return isChannelConfigValid(dp.get<DynamicsProcessing::limiter>());
}
case DynamicsProcessing::inputGain: {
return isChannelConfigValid(dp.get<DynamicsProcessing::inputGain>());
}
default: {
return true;
}
}
return true;
}
bool DynamicsProcessingTestHelper::isParamEqual(const DynamicsProcessing::Tag& tag,
const DynamicsProcessing& dpRef,
@@ -270,8 +342,8 @@ void DynamicsProcessingTestHelper::SetAndGetDynamicsProcessingParameters() {
// validate parameter
Descriptor desc;
ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
const bool valid =
isParameterValid<DynamicsProcessing, Range::dynamicsProcessing>(dp, desc);
bool valid = isParamInRange(dp, desc.capability.range.get<Range::dynamicsProcessing>());
if (valid) valid = isParamValid(tag, dp);
const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;
// set parameter
@@ -429,10 +501,11 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Combine(
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
testing::Values(DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
DynamicsProcessing::ResolutionPreference::
FAVOR_FREQUENCY_RESOLUTION), // variant
testing::Values(-10.f, 0.f, 10.f), // processing duration
testing::Values(
DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
static_cast<DynamicsProcessing::ResolutionPreference>(-1)), // variant
testing::Values(-10.f, 0.f, 10.f), // processing duration
testing::ValuesIn(
DynamicsProcessingTestHelper::kStageEnablementTestSet), // preEQ/postEQ/mbc
testing::Bool()), // limiter enable
@@ -515,12 +588,12 @@ enum LimiterConfigTestAdditionalParam {
LIMITER_MAX_NUM,
};
using LimiterConfigTestAdditional = std::array<float, LIMITER_MAX_NUM>;
// attachTime, releaseTime, ratio, thresh, postGain
// attackTime, releaseTime, ratio, thresh, postGain
static constexpr std::array<LimiterConfigTestAdditional, 4> kLimiterConfigTestAdditionalParam = {
{{-1, -60, -2.5, -2, -3.14},
{-1, 60, -2.5, 2, -3.14},
{1, -60, 2.5, -2, 3.14},
{1, 60, 2.5, 2, 3.14}}};
{1, 60, 2.5, -2, 3.14}}};
using LimiterConfigTestParams =
std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool, int32_t, bool,
@@ -669,15 +742,13 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestChannelConfi
enum EqBandConfigTestParamName {
EQ_BAND_INSTANCE_NAME,
EQ_BAND_CHANNEL,
EQ_BAND_CHANNEL_ENABLE,
EQ_BAND_ENABLE,
EQ_BAND_CUT_OFF_FREQ,
EQ_BAND_GAIN,
EQ_BAND_STAGE_IN_USE
};
using EqBandConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,
std::vector<DynamicsProcessing::ChannelConfig>, bool,
std::vector<std::pair<int, float>>, float, bool>;
bool, std::vector<std::pair<int, float>>, float, bool>;
void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs,
const EqBandConfigTestParams& params) {
@@ -698,8 +769,7 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan
public:
DynamicsProcessingTestEqBandConfig()
: DynamicsProcessingTestHelper(std::get<EQ_BAND_INSTANCE_NAME>(GetParam())),
mStageInUse(std::get<EQ_BAND_STAGE_IN_USE>(GetParam())),
mChannelConfig(std::get<EQ_BAND_CHANNEL_ENABLE>(GetParam())) {
mStageInUse(std::get<EQ_BAND_STAGE_IN_USE>(GetParam())) {
fillEqBandConfig(mCfgs, GetParam());
}
@@ -709,14 +779,18 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan
std::vector<DynamicsProcessing::EqBandConfig> mCfgs;
const bool mStageInUse;
const std::vector<DynamicsProcessing::ChannelConfig> mChannelConfig;
};
TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {
mEngineConfigPreset.preEqStage.inUse = mStageInUse;
mEngineConfigPreset.preEqStage.bandCount = mCfgs.size();
EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mChannelConfig));
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(cfgs));
EXPECT_NO_FATAL_FAILURE(addPreEqBandConfigs(mCfgs));
SetAndGetDynamicsProcessingParameters();
}
@@ -725,7 +799,12 @@ TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {
mEngineConfigPreset.postEqStage.inUse = mStageInUse;
mEngineConfigPreset.postEqStage.bandCount = mCfgs.size();
EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mChannelConfig));
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(cfgs));
EXPECT_NO_FATAL_FAILURE(addPostEqBandConfigs(mCfgs));
SetAndGetDynamicsProcessingParameters();
}
@@ -776,28 +855,23 @@ std::vector<std::vector<std::pair<int, float>>> kBands{
INSTANTIATE_TEST_SUITE_P(
DynamicsProcessingTest, DynamicsProcessingTestEqBandConfig,
::testing::Combine(
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
testing::Values(-1, 0, 10), // channel ID
testing::ValuesIn(
DynamicsProcessingTestHelper::kChannelConfigTestSet), // channel enable
testing::Bool(), // band enable
testing::ValuesIn(kBands), // cut off frequencies
testing::Values(-3.14f, 3.14f), // gain
testing::Bool()), // stage in use
::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
testing::Values(-1, 0, 10), // channel ID
testing::Bool(), // band enable
testing::ValuesIn(kBands), // cut off frequencies
testing::Values(-3.14f, 3.14f), // gain
testing::Values(true)), // stage in use
[](const auto& info) {
auto descriptor = std::get<EQ_BAND_INSTANCE_NAME>(info.param).second;
std::vector<DynamicsProcessing::EqBandConfig> cfgs;
fillEqBandConfig(cfgs, info.param);
std::string enable =
::android::internal::ToString(std::get<EQ_BAND_CHANNEL_ENABLE>(info.param));
std::string bands = ::android::internal::ToString(cfgs);
std::string stageInUse = std::to_string(std::get<EQ_BAND_STAGE_IN_USE>(info.param));
std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
descriptor.common.name + "_UUID_" +
descriptor.common.id.uuid.toString() + "_" + enable + "_bands_" +
bands + "_stageInUse_" + stageInUse;
descriptor.common.id.uuid.toString() + "_bands_" + bands +
"_stageInUse_" + stageInUse;
std::replace_if(
name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
return name;
@@ -811,7 +885,6 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestEqBandConfig
enum MbcBandConfigParamName {
MBC_BAND_INSTANCE_NAME,
MBC_BAND_CHANNEL,
MBC_BAND_CHANNEL_CONFIG,
MBC_BAND_ENABLE,
MBC_BAND_CUTOFF_FREQ,
MBC_BAND_STAGE_IN_USE,
@@ -831,16 +904,15 @@ enum MbcBandConfigAdditional {
};
using TestParamsMbcBandConfigAdditional = std::array<float, MBC_ADD_MAX_NUM>;
// attachTime, releaseTime, ratio, thresh, kneeWidth, noise, expander, preGain, postGain
// attackTime, releaseTime, ratio, thresh, kneeWidth, noise, expander, preGain, postGain
static constexpr std::array<TestParamsMbcBandConfigAdditional, 4> kMbcBandConfigAdditionalParam = {
{{-3, -10, -2, -2, -5, -90, -2.5, -2, -2},
{0, 0, 0, 0, 0, 0, 0, 0, 0},
{-3, 10, -2, 2, -5, 90, -2.5, 2, -2},
{3, 10, 2, 2, 5, 90, 2.5, 2, 2}}};
{3, 10, 2, -2, -5, 90, 2.5, 2, 2}}};
using TestParamsMbcBandConfig =
std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,
std::vector<DynamicsProcessing::ChannelConfig>, bool,
std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool,
std::vector<std::pair<int, float>>, bool, TestParamsMbcBandConfigAdditional>;
void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs,
@@ -873,8 +945,7 @@ class DynamicsProcessingTestMbcBandConfig
public:
DynamicsProcessingTestMbcBandConfig()
: DynamicsProcessingTestHelper(std::get<MBC_BAND_INSTANCE_NAME>(GetParam())),
mStageInUse(std::get<MBC_BAND_STAGE_IN_USE>(GetParam())),
mChannelConfig(std::get<MBC_BAND_CHANNEL_CONFIG>(GetParam())) {
mStageInUse(std::get<MBC_BAND_STAGE_IN_USE>(GetParam())) {
fillMbcBandConfig(mCfgs, GetParam());
}
@@ -884,42 +955,41 @@ class DynamicsProcessingTestMbcBandConfig
std::vector<DynamicsProcessing::MbcBandConfig> mCfgs;
const bool mStageInUse;
const std::vector<DynamicsProcessing::ChannelConfig> mChannelConfig;
};
TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) {
mEngineConfigPreset.mbcStage.inUse = mStageInUse;
mEngineConfigPreset.mbcStage.bandCount = mCfgs.size();
EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mChannelConfig));
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(cfgs));
EXPECT_NO_FATAL_FAILURE(addMbcBandConfigs(mCfgs));
SetAndGetDynamicsProcessingParameters();
}
INSTANTIATE_TEST_SUITE_P(
DynamicsProcessingTest, DynamicsProcessingTestMbcBandConfig,
::testing::Combine(
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
testing::Values(-1, 0, 10), // channel count
testing::ValuesIn(
DynamicsProcessingTestHelper::kChannelConfigTestSet), // channel config
testing::Bool(), // enable
testing::ValuesIn(kBands), // cut off frequencies
testing::Bool(), // stage in use
testing::ValuesIn(kMbcBandConfigAdditionalParam)), // Additional
::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
testing::Values(-1, 0, 10), // channel count
testing::Bool(), // enable
testing::ValuesIn(kBands), // cut off frequencies
testing::Bool(), // stage in use
testing::ValuesIn(kMbcBandConfigAdditionalParam)), // Additional
[](const auto& info) {
auto descriptor = std::get<MBC_BAND_INSTANCE_NAME>(info.param).second;
std::vector<DynamicsProcessing::MbcBandConfig> cfgs;
fillMbcBandConfig(cfgs, info.param);
std::string enable =
::android::internal::ToString(std::get<MBC_BAND_CHANNEL_CONFIG>(info.param));
std::string mbcBands = ::android::internal::ToString(cfgs);
std::string stageInUse = std::to_string(std::get<MBC_BAND_STAGE_IN_USE>(info.param));
std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
descriptor.common.name + "_UUID_" +
descriptor.common.id.uuid.toString() + "_enable_" + enable +
"_bands_" + mbcBands + "_stageInUse_" + stageInUse;
descriptor.common.id.uuid.toString() + "_bands_" + mbcBands +
"_stageInUse_" + stageInUse;
std::replace_if(
name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
return name;