1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "VtsHalEnvironmentalReverbTest"
18 #include <android-base/logging.h>
19 #include <audio_utils/power.h>
20 #include <audio_utils/primitives.h>
21 #include <system/audio.h>
22 #include <numeric>
23
24 #include "EffectHelper.h"
25
26 using namespace android;
27 using namespace aidl::android::hardware::audio::effect;
28 using aidl::android::hardware::audio::common::getChannelCount;
29 using android::hardware::audio::common::testing::detail::TestExecutionTracer;
30 using TagVectorPair = std::pair<EnvironmentalReverb::Tag, std::vector<int>>;
31 using TagValuePair = std::pair<EnvironmentalReverb::Tag, int>;
32
33 static constexpr int kMaxRoomLevel = 0;
34 static constexpr int kMinRoomLevel = -6000;
35 static constexpr int kMinRoomHfLevel = -4000;
36 static constexpr int kMinDecayTime = 0;
37 static constexpr int kMinHfRatio = 100;
38 static constexpr int kMinLevel = -6000;
39 static constexpr int kMinDensity = 0;
40 static constexpr int kMinDiffusion = 0;
41 static constexpr int kMinDelay = 0;
42
43 static const std::vector<TagVectorPair> kParamsIncreasingVector = {
44 {EnvironmentalReverb::roomLevelMb, {-3500, -2800, -2100, -1400, -700, 0}},
45 {EnvironmentalReverb::roomHfLevelMb, {-4000, -3200, -2400, -1600, -800, 0}},
46 {EnvironmentalReverb::decayTimeMs, {400, 800, 1200, 1600, 2000}},
47 {EnvironmentalReverb::decayHfRatioPm, {1000, 900, 800, 700}},
48 {EnvironmentalReverb::levelMb, {-3500, -2800, -2100, -1400, -700, 0}},
49 };
50
51 static const TagVectorPair kDiffusionParam = {EnvironmentalReverb::diffusionPm,
52 {100, 300, 500, 700, 900}};
53 static const TagVectorPair kDensityParam = {EnvironmentalReverb::densityPm,
54 {0, 200, 400, 600, 800, 1000}};
55
56 static const std::vector<TagValuePair> kParamsMinimumValue = {
57 {EnvironmentalReverb::roomLevelMb, kMinRoomLevel},
58 {EnvironmentalReverb::decayTimeMs, kMinDecayTime},
59 {EnvironmentalReverb::levelMb, kMinLevel}};
60
61 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
62
63 using Maker = std::set<int> (*)();
64 static const std::array<Maker, static_cast<int>(EnvironmentalReverb::bypass) + 1>
65 kTestValueSetMaker = {
66 nullptr,
__anonae0125ed0102() 67 []() -> std::set<int> {
68 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
69 Range::environmentalReverb,
70 EnvironmentalReverb::roomLevelMb>(
71 kDescPair, EffectHelper::expandTestValueBasic<int>);
72 },
__anonae0125ed0202() 73 []() -> std::set<int> {
74 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
75 Range::environmentalReverb,
76 EnvironmentalReverb::roomHfLevelMb>(
77 kDescPair, EffectHelper::expandTestValueBasic<int>);
78 },
__anonae0125ed0302() 79 []() -> std::set<int> {
80 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
81 Range::environmentalReverb,
82 EnvironmentalReverb::decayTimeMs>(
83 kDescPair, EffectHelper::expandTestValueBasic<int>);
84 },
__anonae0125ed0402() 85 []() -> std::set<int> {
86 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
87 Range::environmentalReverb,
88 EnvironmentalReverb::decayHfRatioPm>(
89 kDescPair, EffectHelper::expandTestValueBasic<int>);
90 },
91 nullptr,
92 nullptr,
__anonae0125ed0502() 93 []() -> std::set<int> {
94 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
95 Range::environmentalReverb,
96 EnvironmentalReverb::levelMb>(
97 kDescPair, EffectHelper::expandTestValueBasic<int>);
98 },
__anonae0125ed0602() 99 []() -> std::set<int> {
100 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
101 Range::environmentalReverb,
102 EnvironmentalReverb::delayMs>(
103 kDescPair, EffectHelper::expandTestValueBasic<int>);
104 },
__anonae0125ed0702() 105 []() -> std::set<int> {
106 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
107 Range::environmentalReverb,
108 EnvironmentalReverb::diffusionPm>(
109 kDescPair, EffectHelper::expandTestValueBasic<int>);
110 },
__anonae0125ed0802() 111 []() -> std::set<int> {
112 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
113 Range::environmentalReverb,
114 EnvironmentalReverb::densityPm>(
115 kDescPair, EffectHelper::expandTestValueBasic<int>);
116 },
__anonae0125ed0902() 117 []() -> std::set<int> {
118 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
119 Range::environmentalReverb,
120 EnvironmentalReverb::bypass>(
121 kDescPair, EffectHelper::expandTestValueBasic<int>);
122 },
123 };
124
buildSetAndGetTestParams()125 static std::vector<TagValuePair> buildSetAndGetTestParams() {
126 std::vector<TagValuePair> valueTag;
127 for (EnvironmentalReverb::Tag tag : ndk::enum_range<EnvironmentalReverb::Tag>()) {
128 std::set<int> values;
129 int intTag = static_cast<int>(tag);
130 if (intTag <= static_cast<int>(EnvironmentalReverb::bypass) &&
131 kTestValueSetMaker[intTag] != nullptr) {
132 values = kTestValueSetMaker[intTag]();
133 }
134
135 for (const auto& value : values) {
136 valueTag.push_back(std::make_pair(tag, value));
137 }
138 }
139
140 return valueTag;
141 }
142
143 /**
144 * Tests do the following:
145 * - Testing parameter range supported by the effect. Range is verified with IEffect.getDescriptor()
146 * and range defined in the documentation.
147 * - Validating the effect by comparing the outputs of the supported parameters.
148 */
149
150 enum ParamName { DESCRIPTOR_INDEX, TAG_VALUE_PAIR };
151
152 class EnvironmentalReverbHelper : public EffectHelper {
153 public:
EnvironmentalReverbHelper(std::pair<std::shared_ptr<IFactory>,Descriptor> pair)154 EnvironmentalReverbHelper(std::pair<std::shared_ptr<IFactory>, Descriptor> pair) {
155 std::tie(mFactory, mDescriptor) = pair;
156 }
157
SetUpReverb()158 void SetUpReverb() {
159 ASSERT_NE(nullptr, mFactory);
160 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
161
162 Parameter::Specific specific = getDefaultParamSpecific();
163 Parameter::Common common = createParamCommon(
164 0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,
165 mFrameCount /* iFrameCount */, mFrameCount /* oFrameCount */);
166 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));
167 ASSERT_NE(nullptr, mEffect);
168 }
169
TearDownReverb()170 void TearDownReverb() {
171 ASSERT_NO_FATAL_FAILURE(close(mEffect));
172 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
173 }
174
getDefaultParamSpecific()175 Parameter::Specific getDefaultParamSpecific() {
176 EnvironmentalReverb er =
177 EnvironmentalReverb::make<EnvironmentalReverb::roomLevelMb>(kMaxRoomLevel);
178 Parameter::Specific specific =
179 Parameter::Specific::make<Parameter::Specific::environmentalReverb>(er);
180 return specific;
181 }
182
isParamValid(EnvironmentalReverb env)183 bool isParamValid(EnvironmentalReverb env) {
184 return isParameterValid<EnvironmentalReverb, Range::environmentalReverb>(env, mDescriptor);
185 }
186
createParam(EnvironmentalReverb env)187 Parameter createParam(EnvironmentalReverb env) {
188 return Parameter::make<Parameter::specific>(
189 Parameter::Specific::make<Parameter::Specific::environmentalReverb>(env));
190 }
191
setAndVerifyParam(binder_exception_t expected,EnvironmentalReverb env,EnvironmentalReverb::Tag tag)192 void setAndVerifyParam(binder_exception_t expected, EnvironmentalReverb env,
193 EnvironmentalReverb::Tag tag) {
194 auto expectedParam = createParam(env);
195
196 EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();
197
198 if (expected == EX_NONE) {
199 auto erId = EnvironmentalReverb::Id::make<EnvironmentalReverb::Id::commonTag>(
200 EnvironmentalReverb::Tag(tag));
201
202 auto id = Parameter::Id::make<Parameter::Id::environmentalReverbTag>(erId);
203
204 // get parameter
205 Parameter getParam;
206 EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));
207 EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()
208 << "\ngetParam:" << getParam.toString();
209 }
210 }
211
isAuxiliary()212 bool isAuxiliary() {
213 return mDescriptor.common.flags.type ==
214 aidl::android::hardware::audio::effect::Flags::Type::AUXILIARY;
215 }
216
computeOutputEnergy(const std::vector<float> & input,std::vector<float> output)217 float computeOutputEnergy(const std::vector<float>& input, std::vector<float> output) {
218 if (!isAuxiliary()) {
219 // Extract auxiliary output
220 for (size_t i = 0; i < output.size(); i++) {
221 output[i] -= input[i];
222 }
223 }
224 return audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT,
225 output.size());
226 }
227
228 using Maker = EnvironmentalReverb (*)(int);
229
230 static constexpr std::array<Maker, static_cast<int>(EnvironmentalReverb::bypass) + 1>
231 kEnvironmentalReverbParamMaker = {
232 nullptr,
__anonae0125ed0a02() 233 [](int value) -> EnvironmentalReverb {
234 return EnvironmentalReverb::make<EnvironmentalReverb::roomLevelMb>(value);
235 },
__anonae0125ed0b02() 236 [](int value) -> EnvironmentalReverb {
237 return EnvironmentalReverb::make<EnvironmentalReverb::roomHfLevelMb>(value);
238 },
__anonae0125ed0c02() 239 [](int value) -> EnvironmentalReverb {
240 return EnvironmentalReverb::make<EnvironmentalReverb::decayTimeMs>(value);
241 },
__anonae0125ed0d02() 242 [](int value) -> EnvironmentalReverb {
243 return EnvironmentalReverb::make<EnvironmentalReverb::decayHfRatioPm>(
244 value);
245 },
246 nullptr,
247 nullptr,
__anonae0125ed0e02() 248 [](int value) -> EnvironmentalReverb {
249 return EnvironmentalReverb::make<EnvironmentalReverb::levelMb>(value);
250 },
__anonae0125ed0f02() 251 [](int value) -> EnvironmentalReverb {
252 return EnvironmentalReverb::make<EnvironmentalReverb::delayMs>(value);
253 },
__anonae0125ed1002() 254 [](int value) -> EnvironmentalReverb {
255 return EnvironmentalReverb::make<EnvironmentalReverb::diffusionPm>(value);
256 },
__anonae0125ed1102() 257 [](int value) -> EnvironmentalReverb {
258 return EnvironmentalReverb::make<EnvironmentalReverb::densityPm>(value);
259 },
__anonae0125ed1202() 260 [](int value) -> EnvironmentalReverb {
261 return EnvironmentalReverb::make<EnvironmentalReverb::bypass>(value);
262 }};
263
createEnvParam(EnvironmentalReverb::Tag tag,int paramValue)264 void createEnvParam(EnvironmentalReverb::Tag tag, int paramValue) {
265 int intTag = static_cast<int>(tag);
266 if (intTag <= static_cast<int>(EnvironmentalReverb::bypass) &&
267 kEnvironmentalReverbParamMaker[intTag] != NULL) {
268 mEnvParam = kEnvironmentalReverbParamMaker[intTag](paramValue);
269 } else {
270 GTEST_SKIP() << "Invalid parameter, skipping the test\n";
271 }
272 }
273
setParameterAndProcess(std::vector<float> & input,std::vector<float> & output,int val,EnvironmentalReverb::Tag tag)274 void setParameterAndProcess(std::vector<float>& input, std::vector<float>& output, int val,
275 EnvironmentalReverb::Tag tag) {
276 createEnvParam(tag, val);
277 if (isParamValid(mEnvParam)) {
278 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, tag));
279 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(input, output, mEffect, &ret));
280 }
281 }
282
283 static constexpr int kDurationMilliSec = 500;
284 static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;
285 static constexpr int kInputFrequency = 2000;
286 static constexpr int mChannelLayout = AudioChannelLayout::LAYOUT_STEREO;
287
288 int mStereoChannelCount = getChannelCount(
289 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout));
290 int mFrameCount = kBufferSize / mStereoChannelCount;
291
292 std::shared_ptr<IFactory> mFactory;
293 std::shared_ptr<IEffect> mEffect;
294 IEffect::OpenEffectReturn ret;
295 Descriptor mDescriptor;
296 EnvironmentalReverb mEnvParam;
297 };
298
299 class EnvironmentalReverbParamTest
300 : public ::testing::TestWithParam<
301 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagValuePair>>,
302 public EnvironmentalReverbHelper {
303 public:
EnvironmentalReverbParamTest()304 EnvironmentalReverbParamTest()
305 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
306 std::tie(mTag, mParamValue) = std::get<TAG_VALUE_PAIR>(GetParam());
307 }
SetUp()308 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpReverb()); }
TearDown()309 void TearDown() override { TearDownReverb(); }
310
311 EnvironmentalReverb::Tag mTag;
312 int mParamValue;
313 };
314
TEST_P(EnvironmentalReverbParamTest,SetAndGetParameter)315 TEST_P(EnvironmentalReverbParamTest, SetAndGetParameter) {
316 createEnvParam(mTag, mParamValue);
317 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(
318 isParamValid(mEnvParam) ? EX_NONE : EX_ILLEGAL_ARGUMENT, mEnvParam, mTag));
319 }
320
321 INSTANTIATE_TEST_SUITE_P(
322 EnvironmentalReverbTest, EnvironmentalReverbParamTest,
323 ::testing::Combine(
324 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
325 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
326 testing::ValuesIn(buildSetAndGetTestParams())),
__anonae0125ed1302(const testing::TestParamInfo<EnvironmentalReverbParamTest::ParamType>& info) 327 [](const testing::TestParamInfo<EnvironmentalReverbParamTest::ParamType>& info) {
328 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
329 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
330 auto val = std::get<TAG_VALUE_PAIR>(info.param).second;
331 std::string name =
332 getPrefix(descriptor) + "_Tag_" + toString(tag) + std::to_string(val);
333 std::replace_if(
334 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
335 return name;
336 });
337 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbParamTest);
338
339 class EnvironmentalReverbDataTest
340 : public ::testing::TestWithParam<
341 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagVectorPair>>,
342 public EnvironmentalReverbHelper {
343 public:
EnvironmentalReverbDataTest()344 EnvironmentalReverbDataTest()
345 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
346 std::tie(mTag, mParamValues) = std::get<TAG_VALUE_PAIR>(GetParam());
347 mInput.resize(kBufferSize);
348 }
SetUp()349 void SetUp() override {
350 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
351 ASSERT_NO_FATAL_FAILURE(
352 generateSineWave(kInputFrequency, mInput, 1.0, kSamplingFrequency, mChannelLayout));
353 ASSERT_NO_FATAL_FAILURE(SetUpReverb());
354 }
TearDown()355 void TearDown() override {
356 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
357 TearDownReverb();
358 }
359
assertEnergyIncreasingWithParameter(bool bypass)360 void assertEnergyIncreasingWithParameter(bool bypass) {
361 createEnvParam(EnvironmentalReverb::bypass, bypass);
362 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::bypass));
363 float baseEnergy = 0;
364 for (int val : mParamValues) {
365 std::vector<float> output(kBufferSize);
366 setParameterAndProcess(mInput, output, val, mTag);
367 float energy = computeOutputEnergy(mInput, output);
368 ASSERT_GT(energy, baseEnergy);
369 baseEnergy = energy;
370 }
371 }
372
assertZeroEnergyWithBypass(bool bypass)373 void assertZeroEnergyWithBypass(bool bypass) {
374 createEnvParam(EnvironmentalReverb::bypass, bypass);
375 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::bypass));
376 for (int val : mParamValues) {
377 std::vector<float> output(kBufferSize);
378 setParameterAndProcess(mInput, output, val, mTag);
379 float energy = computeOutputEnergy(mInput, output);
380 ASSERT_EQ(energy, 0);
381 }
382 }
383
384 EnvironmentalReverb::Tag mTag;
385 std::vector<int> mParamValues;
386 std::vector<float> mInput;
387 };
388
TEST_P(EnvironmentalReverbDataTest,IncreasingParamValue)389 TEST_P(EnvironmentalReverbDataTest, IncreasingParamValue) {
390 ASSERT_NO_FATAL_FAILURE(assertEnergyIncreasingWithParameter(false));
391 }
392
TEST_P(EnvironmentalReverbDataTest,WithBypassEnabled)393 TEST_P(EnvironmentalReverbDataTest, WithBypassEnabled) {
394 ASSERT_NO_FATAL_FAILURE(assertZeroEnergyWithBypass(true));
395 }
396
397 INSTANTIATE_TEST_SUITE_P(
398 EnvironmentalReverbTest, EnvironmentalReverbDataTest,
399 ::testing::Combine(
400 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
401 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
402 testing::ValuesIn(kParamsIncreasingVector)),
__anonae0125ed1502(const testing::TestParamInfo<EnvironmentalReverbDataTest::ParamType>& info) 403 [](const testing::TestParamInfo<EnvironmentalReverbDataTest::ParamType>& info) {
404 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
405 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
406 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag);
407 return name;
408 });
409
410 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDataTest);
411
412 class EnvironmentalReverbMinimumParamTest
413 : public ::testing::TestWithParam<
414 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagValuePair>>,
415 public EnvironmentalReverbHelper {
416 public:
EnvironmentalReverbMinimumParamTest()417 EnvironmentalReverbMinimumParamTest()
418 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
419 std::tie(mTag, mValue) = std::get<TAG_VALUE_PAIR>(GetParam());
420 }
SetUp()421 void SetUp() override {
422 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
423 ASSERT_NO_FATAL_FAILURE(SetUpReverb());
424 createEnvParam(EnvironmentalReverb::roomLevelMb, kMinRoomLevel);
425 ASSERT_NO_FATAL_FAILURE(
426 setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::roomLevelMb));
427 }
TearDown()428 void TearDown() override {
429 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
430 TearDownReverb();
431 }
432
433 EnvironmentalReverb::Tag mTag;
434 int mValue;
435 };
436
TEST_P(EnvironmentalReverbMinimumParamTest,MinimumValueTest)437 TEST_P(EnvironmentalReverbMinimumParamTest, MinimumValueTest) {
438 std::vector<float> input(kBufferSize);
439 ASSERT_NO_FATAL_FAILURE(
440 generateSineWave(kInputFrequency, input, 1.0, kSamplingFrequency, mChannelLayout));
441 std::vector<float> output(kBufferSize);
442 setParameterAndProcess(input, output, mValue, mTag);
443 float energy = computeOutputEnergy(input, output);
444 // No Auxiliary output for minimum param values
445 ASSERT_EQ(energy, 0);
446 }
447
448 INSTANTIATE_TEST_SUITE_P(
449 EnvironmentalReverbTest, EnvironmentalReverbMinimumParamTest,
450 ::testing::Combine(
451 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
452 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
453 testing::ValuesIn(kParamsMinimumValue)),
__anonae0125ed1602(const testing::TestParamInfo<EnvironmentalReverbMinimumParamTest::ParamType>& info) 454 [](const testing::TestParamInfo<EnvironmentalReverbMinimumParamTest::ParamType>& info) {
455 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
456 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
457 auto val = std::get<TAG_VALUE_PAIR>(info.param).second;
458 std::string name =
459 getPrefix(descriptor) + "_Tag_" + toString(tag) + std::to_string(val);
460 std::replace_if(
461 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
462 return name;
463 });
464
465 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbMinimumParamTest);
466
467 class EnvironmentalReverbDiffusionTest
468 : public ::testing::TestWithParam<
469 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagVectorPair>>,
470 public EnvironmentalReverbHelper {
471 public:
EnvironmentalReverbDiffusionTest()472 EnvironmentalReverbDiffusionTest()
473 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
474 std::tie(mTag, mParamValues) = std::get<TAG_VALUE_PAIR>(GetParam());
475 mInput.resize(kBufferSize);
476 }
SetUp()477 void SetUp() override {
478 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
479 ASSERT_NO_FATAL_FAILURE(
480 generateSineWave(kInputFrequency, mInput, 1.0, kSamplingFrequency, mChannelLayout));
481 ASSERT_NO_FATAL_FAILURE(SetUpReverb());
482 }
TearDown()483 void TearDown() override {
484 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
485 TearDownReverb();
486 }
487
getMean(std::vector<float> & buffer)488 float getMean(std::vector<float>& buffer) {
489 return std::accumulate(buffer.begin(), buffer.end(), 0.0) / buffer.size();
490 }
491
getVariance(std::vector<float> & buffer)492 float getVariance(std::vector<float>& buffer) {
493 if (isAuxiliary()) {
494 accumulate_float(buffer.data(), mInput.data(), buffer.size());
495 }
496 float mean = getMean(buffer);
497 float squaredDeltas =
498 std::accumulate(buffer.begin(), buffer.end(), 0.0,
499 [mean](float a, float b) { return a + pow(b - mean, 2); });
500
501 return squaredDeltas / buffer.size();
502 }
503
504 EnvironmentalReverb::Tag mTag;
505 std::vector<int> mParamValues;
506 std::vector<float> mInput;
507 };
508
TEST_P(EnvironmentalReverbDiffusionTest,DecreasingVarianceTest)509 TEST_P(EnvironmentalReverbDiffusionTest, DecreasingVarianceTest) {
510 std::vector<float> baseOutput(kBufferSize);
511 setParameterAndProcess(mInput, baseOutput, kMinDiffusion, mTag);
512 ASSERT_EQ(baseOutput.size(),
513 static_cast<size_t>(mFrameCount) * static_cast<size_t>(mStereoChannelCount));
514 float baseVariance = getVariance(baseOutput);
515 for (int value : mParamValues) {
516 std::vector<float> output(kBufferSize);
517 setParameterAndProcess(mInput, output, value, mTag);
518 ASSERT_EQ(output.size(),
519 static_cast<size_t>(mFrameCount) * static_cast<size_t>(mStereoChannelCount));
520 float variance = getVariance(output);
521 ASSERT_LT(variance, baseVariance);
522 baseVariance = variance;
523 }
524 }
525
526 INSTANTIATE_TEST_SUITE_P(
527 EnvironmentalReverbTest, EnvironmentalReverbDiffusionTest,
528 ::testing::Combine(
529 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
530 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
531 testing::Values(kDiffusionParam)),
__anonae0125ed1902(const testing::TestParamInfo<EnvironmentalReverbDiffusionTest::ParamType>& info) 532 [](const testing::TestParamInfo<EnvironmentalReverbDiffusionTest::ParamType>& info) {
533 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
534 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
535 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag);
536 return name;
537 });
538
539 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDiffusionTest);
540
541 enum ParamDensityTest { DESCRIPTOR, TAG_DENSITY_VALUE, PARAM_DENSITY_VALUE, IS_INPUT_MUTE };
542
543 class EnvironmentalReverbDensityTest
544 : public ::testing::TestWithParam<std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,
545 EnvironmentalReverb::Tag, int, bool>>,
546 public EnvironmentalReverbHelper {
547 public:
EnvironmentalReverbDensityTest()548 EnvironmentalReverbDensityTest() : EnvironmentalReverbHelper(std::get<DESCRIPTOR>(GetParam())) {
549 mTag = std::get<TAG_DENSITY_VALUE>(GetParam());
550 mParamValues = std::get<PARAM_DENSITY_VALUE>(GetParam());
551 mIsInputMute = (std::get<IS_INPUT_MUTE>(GetParam()));
552 mInput.resize(kBufferSize);
553 }
SetUp()554 void SetUp() override {
555 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
556 if (mIsInputMute) {
557 std::fill(mInput.begin(), mInput.end(), 0);
558 } else {
559 ASSERT_NO_FATAL_FAILURE(generateSineWave(kInputFrequency, mInput, 1.0,
560 kSamplingFrequency, mChannelLayout));
561 }
562 ASSERT_NO_FATAL_FAILURE(SetUpReverb());
563 }
TearDown()564 void TearDown() override {
565 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
566 TearDownReverb();
567 }
568
569 EnvironmentalReverb::Tag mTag;
570 int mParamValues;
571 std::vector<float> mInput;
572 bool mIsInputMute;
573 };
574
TEST_P(EnvironmentalReverbDensityTest,DensityOutput)575 TEST_P(EnvironmentalReverbDensityTest, DensityOutput) {
576 float inputRmse =
577 audio_utils_compute_energy_mono(mInput.data(), AUDIO_FORMAT_PCM_FLOAT, mInput.size());
578
579 std::vector<float> output(kBufferSize);
580 setParameterAndProcess(mInput, output, mParamValues, mTag);
581
582 if (isAuxiliary() && !mIsInputMute) {
583 accumulate_float(output.data(), mInput.data(), output.size());
584 }
585
586 float outputRmse =
587 audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT, output.size());
588 if (inputRmse != 0) {
589 EXPECT_GT(outputRmse, 0);
590 } else {
591 EXPECT_EQ(outputRmse, inputRmse);
592 }
593 }
594
595 INSTANTIATE_TEST_SUITE_P(
596 EnvironmentalReverbTest, EnvironmentalReverbDensityTest,
597 ::testing::Combine(
598 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
599 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
600 testing::Values(kDensityParam.first), testing::ValuesIn(kDensityParam.second),
601 testing::Bool()),
__anonae0125ed1a02(const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) 602 [](const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) {
603 auto descriptor = std::get<DESCRIPTOR>(info.param).second;
604 auto tag = std::get<TAG_DENSITY_VALUE>(info.param);
605 auto value = std::get<PARAM_DENSITY_VALUE>(info.param);
606 std::string isInputMute = std::to_string(std::get<IS_INPUT_MUTE>(info.param));
607 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag) + "_Value_" +
608 std::to_string(value) + "_isInputMute_" + isInputMute;
609 return name;
610 });
611
612 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDensityTest);
613
main(int argc,char ** argv)614 int main(int argc, char** argv) {
615 ::testing::InitGoogleTest(&argc, argv);
616 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
617 ABinderProcess_setThreadPoolMaxThreadCount(1);
618 ABinderProcess_startThreadPool();
619 return RUN_ALL_TESTS();
620 }
621