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, {800, 1600, 2400, 3200, 4000}},
47 {EnvironmentalReverb::decayHfRatioPm, {100, 600, 1100, 1600, 2000}},
48 {EnvironmentalReverb::levelMb, {-3500, -2800, -2100, -1400, -700, 0}},
49 };
50
51 static const TagVectorPair kDiffusionParam = {EnvironmentalReverb::diffusionPm,
52 {200, 400, 600, 800, 1000}};
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,
__anon415eeb6d0102() 67 []() -> std::set<int> {
68 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
69 Range::environmentalReverb,
70 EnvironmentalReverb::roomLevelMb>(
71 kDescPair, EffectHelper::expandTestValueBasic<int>);
72 },
__anon415eeb6d0202() 73 []() -> std::set<int> {
74 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
75 Range::environmentalReverb,
76 EnvironmentalReverb::roomHfLevelMb>(
77 kDescPair, EffectHelper::expandTestValueBasic<int>);
78 },
__anon415eeb6d0302() 79 []() -> std::set<int> {
80 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
81 Range::environmentalReverb,
82 EnvironmentalReverb::decayTimeMs>(
83 kDescPair, EffectHelper::expandTestValueBasic<int>);
84 },
__anon415eeb6d0402() 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,
__anon415eeb6d0502() 93 []() -> std::set<int> {
94 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
95 Range::environmentalReverb,
96 EnvironmentalReverb::levelMb>(
97 kDescPair, EffectHelper::expandTestValueBasic<int>);
98 },
__anon415eeb6d0602() 99 []() -> std::set<int> {
100 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
101 Range::environmentalReverb,
102 EnvironmentalReverb::delayMs>(
103 kDescPair, EffectHelper::expandTestValueBasic<int>);
104 },
__anon415eeb6d0702() 105 []() -> std::set<int> {
106 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
107 Range::environmentalReverb,
108 EnvironmentalReverb::diffusionPm>(
109 kDescPair, EffectHelper::expandTestValueBasic<int>);
110 },
__anon415eeb6d0802() 111 []() -> std::set<int> {
112 return EffectHelper::getTestValueSet<EnvironmentalReverb, int,
113 Range::environmentalReverb,
114 EnvironmentalReverb::densityPm>(
115 kDescPair, EffectHelper::expandTestValueBasic<int>);
116 },
__anon415eeb6d0902() 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 * Tests do the following:
144 * - Testing parameter range supported by the effect. Range is verified with IEffect.getDescriptor()
145 * and range defined in the documentation.
146 * - Validating the effect by comparing the outputs of the supported parameters.
147 */
148
149 enum ParamName { DESCRIPTOR_INDEX, TAG_VALUE_PAIR };
150
151 class EnvironmentalReverbHelper : public EffectHelper {
152 public:
EnvironmentalReverbHelper(std::pair<std::shared_ptr<IFactory>,Descriptor> pair)153 EnvironmentalReverbHelper(std::pair<std::shared_ptr<IFactory>, Descriptor> pair) {
154 std::tie(mFactory, mDescriptor) = pair;
155 }
156
SetUpReverb()157 void SetUpReverb() {
158 ASSERT_NE(nullptr, mFactory);
159 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
160
161 Parameter::Specific specific = getDefaultParamSpecific();
162 Parameter::Common common = createParamCommon(
163 0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,
164 mFrameCount /* iFrameCount */, mFrameCount /* oFrameCount */);
165 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));
166 ASSERT_NE(nullptr, mEffect);
167 }
168
TearDownReverb()169 void TearDownReverb() {
170 ASSERT_NO_FATAL_FAILURE(close(mEffect));
171 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
172 }
173
getDefaultParamSpecific()174 Parameter::Specific getDefaultParamSpecific() {
175 EnvironmentalReverb er =
176 EnvironmentalReverb::make<EnvironmentalReverb::roomLevelMb>(kMaxRoomLevel);
177 Parameter::Specific specific =
178 Parameter::Specific::make<Parameter::Specific::environmentalReverb>(er);
179 return specific;
180 }
181
isParamValid(EnvironmentalReverb env)182 bool isParamValid(EnvironmentalReverb env) {
183 return isParameterValid<EnvironmentalReverb, Range::environmentalReverb>(env, mDescriptor);
184 }
185
createParam(EnvironmentalReverb env)186 Parameter createParam(EnvironmentalReverb env) {
187 return Parameter::make<Parameter::specific>(
188 Parameter::Specific::make<Parameter::Specific::environmentalReverb>(env));
189 }
190
setAndVerifyParam(binder_exception_t expected,EnvironmentalReverb env,EnvironmentalReverb::Tag tag)191 void setAndVerifyParam(binder_exception_t expected, EnvironmentalReverb env,
192 EnvironmentalReverb::Tag tag) {
193 auto expectedParam = createParam(env);
194
195 EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();
196
197 if (expected == EX_NONE) {
198 auto erId = EnvironmentalReverb::Id::make<EnvironmentalReverb::Id::commonTag>(
199 EnvironmentalReverb::Tag(tag));
200
201 auto id = Parameter::Id::make<Parameter::Id::environmentalReverbTag>(erId);
202
203 // get parameter
204 Parameter getParam;
205 EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));
206 EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()
207 << "\ngetParam:" << getParam.toString();
208 }
209 }
210
isAuxiliary()211 bool isAuxiliary() {
212 return mDescriptor.common.flags.type ==
213 aidl::android::hardware::audio::effect::Flags::Type::AUXILIARY;
214 }
215
computeOutputEnergy(const std::vector<float> & input,std::vector<float> output)216 float computeOutputEnergy(const std::vector<float>& input, std::vector<float> output) {
217 if (!isAuxiliary()) {
218 // Extract auxiliary output
219 for (size_t i = 0; i < output.size(); i++) {
220 output[i] -= input[i];
221 }
222 }
223 return audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT,
224 output.size());
225 }
226
227 using Maker = EnvironmentalReverb (*)(int);
228
229 static constexpr std::array<Maker, static_cast<int>(EnvironmentalReverb::bypass) + 1>
230 kEnvironmentalReverbParamMaker = {
231 nullptr,
__anon415eeb6d0a02() 232 [](int value) -> EnvironmentalReverb {
233 return EnvironmentalReverb::make<EnvironmentalReverb::roomLevelMb>(value);
234 },
__anon415eeb6d0b02() 235 [](int value) -> EnvironmentalReverb {
236 return EnvironmentalReverb::make<EnvironmentalReverb::roomHfLevelMb>(value);
237 },
__anon415eeb6d0c02() 238 [](int value) -> EnvironmentalReverb {
239 return EnvironmentalReverb::make<EnvironmentalReverb::decayTimeMs>(value);
240 },
__anon415eeb6d0d02() 241 [](int value) -> EnvironmentalReverb {
242 return EnvironmentalReverb::make<EnvironmentalReverb::decayHfRatioPm>(
243 value);
244 },
245 nullptr,
246 nullptr,
__anon415eeb6d0e02() 247 [](int value) -> EnvironmentalReverb {
248 return EnvironmentalReverb::make<EnvironmentalReverb::levelMb>(value);
249 },
__anon415eeb6d0f02() 250 [](int value) -> EnvironmentalReverb {
251 return EnvironmentalReverb::make<EnvironmentalReverb::delayMs>(value);
252 },
__anon415eeb6d1002() 253 [](int value) -> EnvironmentalReverb {
254 return EnvironmentalReverb::make<EnvironmentalReverb::diffusionPm>(value);
255 },
__anon415eeb6d1102() 256 [](int value) -> EnvironmentalReverb {
257 return EnvironmentalReverb::make<EnvironmentalReverb::densityPm>(value);
258 },
__anon415eeb6d1202() 259 [](int value) -> EnvironmentalReverb {
260 return EnvironmentalReverb::make<EnvironmentalReverb::bypass>(value);
261 }};
262
createEnvParam(EnvironmentalReverb::Tag tag,int paramValue)263 void createEnvParam(EnvironmentalReverb::Tag tag, int paramValue) {
264 int intTag = static_cast<int>(tag);
265 if (intTag <= static_cast<int>(EnvironmentalReverb::bypass) &&
266 kEnvironmentalReverbParamMaker[intTag] != NULL) {
267 mEnvParam = kEnvironmentalReverbParamMaker[intTag](paramValue);
268 } else {
269 GTEST_SKIP() << "Invalid parameter, skipping the test\n";
270 }
271 }
272
setParameterAndProcess(std::vector<float> & input,std::vector<float> & output,int val,EnvironmentalReverb::Tag tag)273 void setParameterAndProcess(std::vector<float>& input, std::vector<float>& output, int val,
274 EnvironmentalReverb::Tag tag) {
275 createEnvParam(tag, val);
276 if (isParamValid(mEnvParam)) {
277 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, tag));
278 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(input, output, mEffect, &ret));
279 }
280 }
281
282 static constexpr int kDurationMilliSec = 500;
283 static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;
284 static constexpr int kInputFrequency = 1000;
285
286 int mStereoChannelCount =
287 getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
288 AudioChannelLayout::LAYOUT_STEREO));
289 int mFrameCount = kBufferSize / mStereoChannelCount;
290
291 std::shared_ptr<IFactory> mFactory;
292 std::shared_ptr<IEffect> mEffect;
293 IEffect::OpenEffectReturn ret;
294 Descriptor mDescriptor;
295 EnvironmentalReverb mEnvParam;
296 };
297
298 class EnvironmentalReverbParamTest
299 : public ::testing::TestWithParam<
300 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagValuePair>>,
301 public EnvironmentalReverbHelper {
302 public:
EnvironmentalReverbParamTest()303 EnvironmentalReverbParamTest()
304 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
305 std::tie(mTag, mParamValue) = std::get<TAG_VALUE_PAIR>(GetParam());
306 }
SetUp()307 void SetUp() override { SetUpReverb(); }
TearDown()308 void TearDown() override { TearDownReverb(); }
309
310 EnvironmentalReverb::Tag mTag;
311 int mParamValue;
312 };
313
TEST_P(EnvironmentalReverbParamTest,SetAndGetParameter)314 TEST_P(EnvironmentalReverbParamTest, SetAndGetParameter) {
315 createEnvParam(mTag, mParamValue);
316 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(
317 isParamValid(mEnvParam) ? EX_NONE : EX_ILLEGAL_ARGUMENT, mEnvParam, mTag));
318 }
319
320 INSTANTIATE_TEST_SUITE_P(
321 EnvironmentalReverbTest, EnvironmentalReverbParamTest,
322 ::testing::Combine(
323 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
324 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
325 testing::ValuesIn(buildSetAndGetTestParams())),
__anon415eeb6d1302(const testing::TestParamInfo<EnvironmentalReverbParamTest::ParamType>& info) 326 [](const testing::TestParamInfo<EnvironmentalReverbParamTest::ParamType>& info) {
327 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
328 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
329 auto val = std::get<TAG_VALUE_PAIR>(info.param).second;
330 std::string name =
331 getPrefix(descriptor) + "_Tag_" + toString(tag) + std::to_string(val);
332 std::replace_if(
333 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
334 return name;
335 });
336 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbParamTest);
337
338 class EnvironmentalReverbDataTest
339 : public ::testing::TestWithParam<
340 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagVectorPair>>,
341 public EnvironmentalReverbHelper {
342 public:
EnvironmentalReverbDataTest()343 EnvironmentalReverbDataTest()
344 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
345 std::tie(mTag, mParamValues) = std::get<TAG_VALUE_PAIR>(GetParam());
346 mInput.resize(kBufferSize);
347 generateSineWave(kInputFrequency, mInput);
348 }
SetUp()349 void SetUp() override {
350 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
351 SetUpReverb();
352 }
TearDown()353 void TearDown() override {
354 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
355 TearDownReverb();
356 }
357
assertEnergyIncreasingWithParameter(bool bypass)358 void assertEnergyIncreasingWithParameter(bool bypass) {
359 createEnvParam(EnvironmentalReverb::bypass, bypass);
360 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::bypass));
361 float baseEnergy = 0;
362 for (int val : mParamValues) {
363 std::vector<float> output(kBufferSize);
364 setParameterAndProcess(mInput, output, val, mTag);
365 float energy = computeOutputEnergy(mInput, output);
366 ASSERT_GT(energy, baseEnergy);
367 baseEnergy = energy;
368 }
369 }
370
assertZeroEnergyWithBypass(bool bypass)371 void assertZeroEnergyWithBypass(bool bypass) {
372 createEnvParam(EnvironmentalReverb::bypass, bypass);
373 ASSERT_NO_FATAL_FAILURE(setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::bypass));
374 for (int val : mParamValues) {
375 std::vector<float> output(kBufferSize);
376 setParameterAndProcess(mInput, output, val, mTag);
377 float energy = computeOutputEnergy(mInput, output);
378 ASSERT_EQ(energy, 0);
379 }
380 }
381
382 EnvironmentalReverb::Tag mTag;
383 std::vector<int> mParamValues;
384 std::vector<float> mInput;
385 };
386
TEST_P(EnvironmentalReverbDataTest,IncreasingParamValue)387 TEST_P(EnvironmentalReverbDataTest, IncreasingParamValue) {
388 assertEnergyIncreasingWithParameter(false);
389 }
390
TEST_P(EnvironmentalReverbDataTest,WithBypassEnabled)391 TEST_P(EnvironmentalReverbDataTest, WithBypassEnabled) {
392 assertZeroEnergyWithBypass(true);
393 }
394
395 INSTANTIATE_TEST_SUITE_P(
396 EnvironmentalReverbTest, EnvironmentalReverbDataTest,
397 ::testing::Combine(
398 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
399 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
400 testing::ValuesIn(kParamsIncreasingVector)),
__anon415eeb6d1502(const testing::TestParamInfo<EnvironmentalReverbDataTest::ParamType>& info) 401 [](const testing::TestParamInfo<EnvironmentalReverbDataTest::ParamType>& info) {
402 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
403 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
404 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag);
405 return name;
406 });
407
408 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDataTest);
409
410 class EnvironmentalReverbMinimumParamTest
411 : public ::testing::TestWithParam<
412 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagValuePair>>,
413 public EnvironmentalReverbHelper {
414 public:
EnvironmentalReverbMinimumParamTest()415 EnvironmentalReverbMinimumParamTest()
416 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
417 std::tie(mTag, mValue) = std::get<TAG_VALUE_PAIR>(GetParam());
418 }
SetUp()419 void SetUp() override {
420 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
421 SetUpReverb();
422 createEnvParam(EnvironmentalReverb::roomLevelMb, kMinRoomLevel);
423 ASSERT_NO_FATAL_FAILURE(
424 setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::roomLevelMb));
425 }
TearDown()426 void TearDown() override {
427 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
428 TearDownReverb();
429 }
430
431 EnvironmentalReverb::Tag mTag;
432 int mValue;
433 };
434
TEST_P(EnvironmentalReverbMinimumParamTest,MinimumValueTest)435 TEST_P(EnvironmentalReverbMinimumParamTest, MinimumValueTest) {
436 std::vector<float> input(kBufferSize);
437 generateSineWave(kInputFrequency, input);
438 std::vector<float> output(kBufferSize);
439 setParameterAndProcess(input, output, mValue, mTag);
440 float energy = computeOutputEnergy(input, output);
441 // No Auxiliary output for minimum param values
442 ASSERT_EQ(energy, 0);
443 }
444
445 INSTANTIATE_TEST_SUITE_P(
446 EnvironmentalReverbTest, EnvironmentalReverbMinimumParamTest,
447 ::testing::Combine(
448 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
449 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
450 testing::ValuesIn(kParamsMinimumValue)),
__anon415eeb6d1602(const testing::TestParamInfo<EnvironmentalReverbMinimumParamTest::ParamType>& info) 451 [](const testing::TestParamInfo<EnvironmentalReverbMinimumParamTest::ParamType>& info) {
452 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
453 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
454 auto val = std::get<TAG_VALUE_PAIR>(info.param).second;
455 std::string name =
456 getPrefix(descriptor) + "_Tag_" + toString(tag) + std::to_string(val);
457 std::replace_if(
458 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
459 return name;
460 });
461
462 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbMinimumParamTest);
463
464 class EnvironmentalReverbDiffusionTest
465 : public ::testing::TestWithParam<
466 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, TagVectorPair>>,
467 public EnvironmentalReverbHelper {
468 public:
EnvironmentalReverbDiffusionTest()469 EnvironmentalReverbDiffusionTest()
470 : EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
471 std::tie(mTag, mParamValues) = std::get<TAG_VALUE_PAIR>(GetParam());
472 mInput.resize(kBufferSize);
473 generateSineWave(kInputFrequency, mInput);
474 }
SetUp()475 void SetUp() override {
476 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
477 SetUpReverb();
478 }
TearDown()479 void TearDown() override {
480 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
481 TearDownReverb();
482 }
483
getMean(std::vector<float> & buffer)484 float getMean(std::vector<float>& buffer) {
485 return std::accumulate(buffer.begin(), buffer.end(), 0.0) / buffer.size();
486 }
487
getVariance(std::vector<float> & buffer)488 float getVariance(std::vector<float>& buffer) {
489 if (isAuxiliary()) {
490 accumulate_float(buffer.data(), mInput.data(), buffer.size());
491 }
492 float mean = getMean(buffer);
493 float squaredDeltas =
494 std::accumulate(buffer.begin(), buffer.end(), 0.0,
495 [mean](float a, float b) { return a + pow(b - mean, 2); });
496
497 return squaredDeltas / buffer.size();
498 }
499
500 EnvironmentalReverb::Tag mTag;
501 std::vector<int> mParamValues;
502 std::vector<float> mInput;
503 };
504
TEST_P(EnvironmentalReverbDiffusionTest,DecreasingVarianceTest)505 TEST_P(EnvironmentalReverbDiffusionTest, DecreasingVarianceTest) {
506 std::vector<float> baseOutput(kBufferSize);
507 setParameterAndProcess(mInput, baseOutput, kMinDiffusion, mTag);
508 ASSERT_EQ(baseOutput.size(),
509 static_cast<size_t>(mFrameCount) * static_cast<size_t>(mStereoChannelCount));
510 float baseVariance = getVariance(baseOutput);
511 for (int value : mParamValues) {
512 std::vector<float> output(kBufferSize);
513 setParameterAndProcess(mInput, output, value, mTag);
514 ASSERT_EQ(output.size(),
515 static_cast<size_t>(mFrameCount) * static_cast<size_t>(mStereoChannelCount));
516 float variance = getVariance(output);
517 ASSERT_LT(variance, baseVariance);
518 baseVariance = variance;
519 }
520 }
521
522 INSTANTIATE_TEST_SUITE_P(
523 EnvironmentalReverbTest, EnvironmentalReverbDiffusionTest,
524 ::testing::Combine(
525 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
526 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
527 testing::Values(kDiffusionParam)),
__anon415eeb6d1902(const testing::TestParamInfo<EnvironmentalReverbDiffusionTest::ParamType>& info) 528 [](const testing::TestParamInfo<EnvironmentalReverbDiffusionTest::ParamType>& info) {
529 auto descriptor = std::get<DESCRIPTOR_INDEX>(info.param).second;
530 auto tag = std::get<TAG_VALUE_PAIR>(info.param).first;
531 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag);
532 return name;
533 });
534
535 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDiffusionTest);
536
537 enum ParamDensityTest { DESCRIPTOR, TAG_DENSITY_VALUE, PARAM_DENSITY_VALUE, IS_INPUT_MUTE };
538
539 class EnvironmentalReverbDensityTest
540 : public ::testing::TestWithParam<std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,
541 EnvironmentalReverb::Tag, int, bool>>,
542 public EnvironmentalReverbHelper {
543 public:
EnvironmentalReverbDensityTest()544 EnvironmentalReverbDensityTest() : EnvironmentalReverbHelper(std::get<DESCRIPTOR>(GetParam())) {
545 mTag = std::get<TAG_DENSITY_VALUE>(GetParam());
546 mParamValues = std::get<PARAM_DENSITY_VALUE>(GetParam());
547 mIsInputMute = (std::get<IS_INPUT_MUTE>(GetParam()));
548 mInput.resize(kBufferSize);
549 if (mIsInputMute) {
550 std::fill(mInput.begin(), mInput.end(), 0);
551 } else {
552 generateSineWave(kInputFrequency, mInput);
553 }
554 }
SetUp()555 void SetUp() override {
556 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
557 SetUpReverb();
558 }
TearDown()559 void TearDown() override {
560 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
561 TearDownReverb();
562 }
563
564 EnvironmentalReverb::Tag mTag;
565 int mParamValues;
566 std::vector<float> mInput;
567 bool mIsInputMute;
568 };
569
TEST_P(EnvironmentalReverbDensityTest,DensityOutput)570 TEST_P(EnvironmentalReverbDensityTest, DensityOutput) {
571 float inputRmse =
572 audio_utils_compute_energy_mono(mInput.data(), AUDIO_FORMAT_PCM_FLOAT, mInput.size());
573
574 std::vector<float> output(kBufferSize);
575 setParameterAndProcess(mInput, output, mParamValues, mTag);
576
577 if (isAuxiliary() && !mIsInputMute) {
578 accumulate_float(output.data(), mInput.data(), output.size());
579 }
580
581 float outputRmse =
582 audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT, output.size());
583 if (inputRmse != 0) {
584 EXPECT_GT(outputRmse, 0);
585 } else {
586 EXPECT_EQ(outputRmse, inputRmse);
587 }
588 }
589
590 INSTANTIATE_TEST_SUITE_P(
591 EnvironmentalReverbTest, EnvironmentalReverbDensityTest,
592 ::testing::Combine(
593 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
594 IFactory::descriptor, getEffectTypeUuidEnvReverb())),
595 testing::Values(kDensityParam.first), testing::ValuesIn(kDensityParam.second),
596 testing::Bool()),
__anon415eeb6d1a02(const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) 597 [](const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) {
598 auto descriptor = std::get<DESCRIPTOR>(info.param).second;
599 auto tag = std::get<TAG_DENSITY_VALUE>(info.param);
600 auto value = std::get<PARAM_DENSITY_VALUE>(info.param);
601 std::string isInputMute = std::to_string(std::get<IS_INPUT_MUTE>(info.param));
602 std::string name = getPrefix(descriptor) + "_Tag_" + toString(tag) + "_Value_" +
603 std::to_string(value) + "_isInputMute_" + isInputMute;
604 return name;
605 });
606
607 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDensityTest);
608
main(int argc,char ** argv)609 int main(int argc, char** argv) {
610 ::testing::InitGoogleTest(&argc, argv);
611 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
612 ABinderProcess_setThreadPoolMaxThreadCount(1);
613 ABinderProcess_startThreadPool();
614 return RUN_ALL_TESTS();
615 }
616