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 #include <limits.h>
18
19 #define LOG_TAG "VtsHalBassBoostTest"
20 #include <aidl/Vintf.h>
21 #include <android-base/logging.h>
22 #include "EffectHelper.h"
23 #include "pffft.hpp"
24
25 using namespace android;
26
27 using aidl::android::hardware::audio::common::getChannelCount;
28 using aidl::android::hardware::audio::effect::BassBoost;
29 using aidl::android::hardware::audio::effect::Capability;
30 using aidl::android::hardware::audio::effect::Descriptor;
31 using aidl::android::hardware::audio::effect::getEffectTypeUuidBassBoost;
32 using aidl::android::hardware::audio::effect::IEffect;
33 using aidl::android::hardware::audio::effect::IFactory;
34 using aidl::android::hardware::audio::effect::Parameter;
35 using aidl::android::hardware::audio::effect::Range;
36 using android::hardware::audio::common::testing::detail::TestExecutionTracer;
37
38 // minimal HAL interface version to run bassboost data path test
39 constexpr int32_t kMinDataTestHalVersion = 2;
40 static const std::vector<int32_t> kLayouts = {AudioChannelLayout::LAYOUT_STEREO,
41 AudioChannelLayout::LAYOUT_MONO};
42 /*
43 * Testing parameter range, assuming the parameter supported by effect is in this range.
44 * Parameter should be within the valid range defined in the documentation,
45 * for any supported value test expects EX_NONE from IEffect.setParameter(),
46 * otherwise expect EX_ILLEGAL_ARGUMENT.
47 */
48
49 class BassBoostEffectHelper : public EffectHelper {
50 public:
SetUpBassBoost(int32_t layout=AudioChannelLayout::LAYOUT_STEREO)51 void SetUpBassBoost(int32_t layout = AudioChannelLayout::LAYOUT_STEREO) {
52 ASSERT_NE(nullptr, mFactory);
53 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
54 setFrameCounts(layout);
55
56 AudioChannelLayout channelLayout =
57 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(layout);
58
59 Parameter::Specific specific = getDefaultParamSpecific();
60 Parameter::Common common = createParamCommon(
61 0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,
62 kSamplingFrequency /* oSampleRate */, mInputFrameCount /* iFrameCount */,
63 mOutputFrameCount /* oFrameCount */, channelLayout, channelLayout);
64 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE));
65 ASSERT_NE(nullptr, mEffect);
66 }
67
TearDownBassBoost()68 void TearDownBassBoost() {
69 ASSERT_NO_FATAL_FAILURE(close(mEffect));
70 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
71 mOpenEffectReturn = IEffect::OpenEffectReturn{};
72 }
73
getDefaultParamSpecific()74 Parameter::Specific getDefaultParamSpecific() {
75 BassBoost bb = BassBoost::make<BassBoost::strengthPm>(0);
76 Parameter::Specific specific =
77 Parameter::Specific::make<Parameter::Specific::bassBoost>(bb);
78 return specific;
79 }
80
setFrameCounts(int32_t inputBufferLayout)81 void setFrameCounts(int32_t inputBufferLayout) {
82 int channelCount = getChannelCount(
83 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(inputBufferLayout));
84 mInputFrameCount = kInputSize / channelCount;
85 mOutputFrameCount = kInputSize / channelCount;
86 }
87
createBassBoostParam(int strength)88 Parameter createBassBoostParam(int strength) {
89 return Parameter::make<Parameter::specific>(
90 Parameter::Specific::make<Parameter::Specific::bassBoost>(
91 BassBoost::make<BassBoost::strengthPm>(strength)));
92 }
93
isStrengthValid(int strength)94 bool isStrengthValid(int strength) {
95 auto bb = BassBoost::make<BassBoost::strengthPm>(strength);
96 return isParameterValid<BassBoost, Range::bassBoost>(bb, mDescriptor);
97 }
98
setAndVerifyParameters(int strength,binder_exception_t expected)99 void setAndVerifyParameters(int strength, binder_exception_t expected) {
100 auto expectedParam = createBassBoostParam(strength);
101 EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();
102
103 if (expected == EX_NONE) {
104 auto bbId = BassBoost::Id::make<BassBoost::Id::commonTag>(
105 BassBoost::Tag(BassBoost::strengthPm));
106 auto id = Parameter::Id::make<Parameter::Id::bassBoostTag>(bbId);
107 // get parameter
108 Parameter getParam;
109 // if set success, then get should match
110 EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));
111 EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()
112 << "\ngetParam:" << getParam.toString();
113 }
114 }
115
116 static constexpr int kDurationMilliSec = 720;
117 static constexpr int kInputSize = kSamplingFrequency * kDurationMilliSec / 1000;
118 long mInputFrameCount, mOutputFrameCount;
119 std::shared_ptr<IFactory> mFactory;
120 Descriptor mDescriptor;
121 std::shared_ptr<IEffect> mEffect;
122 IEffect::OpenEffectReturn mOpenEffectReturn;
123 };
124
125 /**
126 * Here we focus on specific parameter checking, general IEffect interfaces testing performed in
127 * VtsAudioEffectTargetTest.
128 */
129 enum ParamName { PARAM_INSTANCE_NAME, PARAM_STRENGTH };
130 using BassBoostParamTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>;
131
132 class BassBoostParamTest : public ::testing::TestWithParam<BassBoostParamTestParam>,
133 public BassBoostEffectHelper {
134 public:
BassBoostParamTest()135 BassBoostParamTest() : mParamStrength(std::get<PARAM_STRENGTH>(GetParam())) {
136 std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
137 }
138
SetUp()139 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpBassBoost()); }
TearDown()140 void TearDown() override { TearDownBassBoost(); }
141
142 int mParamStrength = 0;
143 };
144
TEST_P(BassBoostParamTest,SetAndGetStrength)145 TEST_P(BassBoostParamTest, SetAndGetStrength) {
146 if (isStrengthValid(mParamStrength)) {
147 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(mParamStrength, EX_NONE));
148 } else {
149 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(mParamStrength, EX_ILLEGAL_ARGUMENT));
150 }
151 }
152
153 enum DataParamName { DATA_INSTANCE_NAME, DATA_LAYOUT };
154
155 using BassBoostDataTestParam =
156 std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t>;
157
158 class BassBoostDataTest : public ::testing::TestWithParam<BassBoostDataTestParam>,
159 public BassBoostEffectHelper {
160 public:
BassBoostDataTest()161 BassBoostDataTest() : mChannelLayout(std::get<DATA_LAYOUT>(GetParam())) {
162 std::tie(mFactory, mDescriptor) = std::get<DATA_INSTANCE_NAME>(GetParam());
163 mStrengthValues = getTestValueSet<BassBoost, int, Range::bassBoost, BassBoost::strengthPm>(
164 {std::get<DATA_INSTANCE_NAME>(GetParam())}, expandTestValueBasic<int>);
165 }
166
SetUp()167 void SetUp() override {
168 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
169 ASSERT_NO_FATAL_FAILURE(SetUpBassBoost(mChannelLayout));
170 if (int32_t version;
171 mEffect->getInterfaceVersion(&version).isOk() && version < kMinDataTestHalVersion) {
172 GTEST_SKIP() << "Skipping the data test for version: " << version << "\n";
173 }
174 }
175
TearDown()176 void TearDown() override {
177 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
178 TearDownBassBoost();
179 }
180
181 // Find FFT bin indices for testFrequencies and get bin center frequencies
roundToFreqCenteredToFftBin(std::vector<int> & testFrequencies,std::vector<int> & binOffsets)182 void roundToFreqCenteredToFftBin(std::vector<int>& testFrequencies,
183 std::vector<int>& binOffsets) {
184 for (size_t i = 0; i < testFrequencies.size(); i++) {
185 binOffsets[i] = std::round(testFrequencies[i] / kBinWidth);
186 testFrequencies[i] = std::round(binOffsets[i] * kBinWidth);
187 }
188 }
189
190 // Use FFT transform to convert the buffer to frequency domain
191 // Compute its magnitude at binOffsets
calculateMagnitude(const std::vector<float> & buffer,const std::vector<int> & binOffsets)192 std::vector<float> calculateMagnitude(const std::vector<float>& buffer,
193 const std::vector<int>& binOffsets) {
194 std::vector<float> fftInput(kNPointFFT);
195 PFFFT_Setup* inputHandle = pffft_new_setup(kNPointFFT, PFFFT_REAL);
196 pffft_transform_ordered(inputHandle, buffer.data(), fftInput.data(), nullptr,
197 PFFFT_FORWARD);
198 pffft_destroy_setup(inputHandle);
199 std::vector<float> bufferMag(binOffsets.size());
200 for (size_t i = 0; i < binOffsets.size(); i++) {
201 size_t k = binOffsets[i];
202 bufferMag[i] = sqrt((fftInput[k * 2] * fftInput[k * 2]) +
203 (fftInput[k * 2 + 1] * fftInput[k * 2 + 1]));
204 }
205
206 return bufferMag;
207 }
208
209 // Calculate gain difference between low frequency and high frequency magnitude
calculateGainDiff(const std::vector<float> & inputMag,const std::vector<float> & outputMag)210 float calculateGainDiff(const std::vector<float>& inputMag,
211 const std::vector<float>& outputMag) {
212 std::vector<float> gains(inputMag.size());
213
214 for (size_t i = 0; i < inputMag.size(); i++) {
215 gains[i] = 20 * log10(outputMag[i] / inputMag[i]);
216 }
217
218 return gains[0] - gains[1];
219 }
220
221 static constexpr int kNPointFFT = 16384;
222 static constexpr float kBinWidth = (float)kSamplingFrequency / kNPointFFT;
223 std::set<int> mStrengthValues;
224 int32_t mChannelLayout;
225 };
226
TEST_P(BassBoostDataTest,IncreasingStrength)227 TEST_P(BassBoostDataTest, IncreasingStrength) {
228 // Frequencies to generate multitone input
229 std::vector<int> testFrequencies = {100, 1000};
230
231 // FFT bin indices for testFrequencies
232 std::vector<int> binOffsets(testFrequencies.size());
233
234 std::vector<float> input(kInputSize);
235 std::vector<float> baseOutput(kInputSize);
236
237 std::vector<float> inputMag(testFrequencies.size());
238 float prevGain = -100;
239
240 roundToFreqCenteredToFftBin(testFrequencies, binOffsets);
241
242 // Generate multitone input
243 generateSineWave(testFrequencies, input);
244
245 inputMag = calculateMagnitude(input, binOffsets);
246
247 if (isStrengthValid(0)) {
248 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(0, EX_NONE));
249 } else {
250 GTEST_SKIP() << "Strength not supported, skipping the test\n";
251 }
252
253 ASSERT_NO_FATAL_FAILURE(
254 processAndWriteToOutput(input, baseOutput, mEffect, &mOpenEffectReturn));
255
256 std::vector<float> baseMag(testFrequencies.size());
257 baseMag = calculateMagnitude(baseOutput, binOffsets);
258 float baseDiff = calculateGainDiff(inputMag, baseMag);
259
260 for (int strength : mStrengthValues) {
261 // Skipping the further steps for invalid strength values
262 if (!isStrengthValid(strength)) {
263 continue;
264 }
265
266 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(strength, EX_NONE));
267
268 std::vector<float> output(kInputSize);
269 std::vector<float> outputMag(testFrequencies.size());
270
271 ASSERT_NO_FATAL_FAILURE(
272 processAndWriteToOutput(input, output, mEffect, &mOpenEffectReturn));
273
274 outputMag = calculateMagnitude(output, binOffsets);
275 float diff = calculateGainDiff(inputMag, outputMag);
276
277 ASSERT_GT(diff, prevGain);
278 ASSERT_GT(diff, baseDiff);
279 prevGain = diff;
280 }
281 }
282
283 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
284 INSTANTIATE_TEST_SUITE_P(
285 BassBoostTest, BassBoostParamTest,
286 ::testing::Combine(
287 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
288 IFactory::descriptor, getEffectTypeUuidBassBoost())),
289 testing::ValuesIn(EffectHelper::getTestValueSet<BassBoost, int, Range::bassBoost,
290 BassBoost::strengthPm>(
291 kDescPair, EffectHelper::expandTestValueBasic<int>))),
__anon567808b50102(const testing::TestParamInfo<BassBoostParamTest::ParamType>& info) 292 [](const testing::TestParamInfo<BassBoostParamTest::ParamType>& info) {
293 auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
294 std::string strength = std::to_string(std::get<PARAM_STRENGTH>(info.param));
295 std::string name = getPrefix(descriptor) + "_strength_" + strength;
296 std::replace_if(
297 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
298 return name;
299 });
300
301 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BassBoostParamTest);
302
303 INSTANTIATE_TEST_SUITE_P(
304 BassBoostTest, BassBoostDataTest,
305 ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
306 IFactory::descriptor, getEffectTypeUuidBassBoost())),
307 testing::ValuesIn(kLayouts)),
__anon567808b50302(const testing::TestParamInfo<BassBoostDataTest::ParamType>& info) 308 [](const testing::TestParamInfo<BassBoostDataTest::ParamType>& info) {
309 auto descriptor = std::get<DATA_INSTANCE_NAME>(info.param).second;
310 std::string layout = std::to_string(std::get<DATA_LAYOUT>(info.param));
311 std::string name = getPrefix(descriptor) + "_layout_" + layout;
312 std::replace_if(
313 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
314 return name;
315 });
316
317 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BassBoostDataTest);
318
main(int argc,char ** argv)319 int main(int argc, char** argv) {
320 ::testing::InitGoogleTest(&argc, argv);
321 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
322 ABinderProcess_setThreadPoolMaxThreadCount(1);
323 ABinderProcess_startThreadPool();
324 return RUN_ALL_TESTS();
325 }
326