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 "VtsHalVolumeTest"
18 #include <android-base/logging.h>
19
20 #include "EffectHelper.h"
21
22 using namespace android;
23
24 using aidl::android::hardware::audio::common::getChannelCount;
25 using aidl::android::hardware::audio::effect::Descriptor;
26 using aidl::android::hardware::audio::effect::getEffectTypeUuidVolume;
27 using aidl::android::hardware::audio::effect::IEffect;
28 using aidl::android::hardware::audio::effect::IFactory;
29 using aidl::android::hardware::audio::effect::Parameter;
30 using aidl::android::hardware::audio::effect::Volume;
31 using android::hardware::audio::common::testing::detail::TestExecutionTracer;
32
33 class VolumeControlHelper : public EffectHelper {
34 public:
SetUpVolumeControl()35 void SetUpVolumeControl() {
36 ASSERT_NE(nullptr, mFactory);
37 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
38 initFrameCount();
39 Parameter::Specific specific = getDefaultParamSpecific();
40 Parameter::Common common = createParamCommon(
41 0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,
42 kSamplingFrequency /* oSampleRate */, mInputFrameCount /* iFrameCount */,
43 mInputFrameCount /* oFrameCount */);
44 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE));
45 ASSERT_NE(nullptr, mEffect);
46 }
47
TearDownVolumeControl()48 void TearDownVolumeControl() {
49 ASSERT_NO_FATAL_FAILURE(close(mEffect));
50 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
51 mOpenEffectReturn = IEffect::OpenEffectReturn{};
52 }
53
getDefaultParamSpecific()54 Parameter::Specific getDefaultParamSpecific() {
55 Volume vol = Volume::make<Volume::levelDb>(kMinLevel);
56 Parameter::Specific specific = Parameter::Specific::make<Parameter::Specific::volume>(vol);
57 return specific;
58 }
59
createVolumeParam(int param,Volume::Tag volTag)60 Parameter createVolumeParam(int param, Volume::Tag volTag) {
61 return Parameter::make<Parameter::specific>(
62 Parameter::Specific::make<Parameter::Specific::volume>(
63 (volTag == Volume::mute) ? Volume::make<Volume::mute>(param)
64 : Volume::make<Volume::levelDb>(param)));
65 }
66
initFrameCount()67 void initFrameCount() {
68 int channelCount = getChannelCount(
69 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChannelLayout));
70 mInputFrameCount = kBufferSize / channelCount;
71 mOutputFrameCount = kBufferSize / channelCount;
72 }
73
isLevelValid(int level)74 bool isLevelValid(int level) {
75 auto vol = Volume::make<Volume::levelDb>(level);
76 return isParameterValid<Volume, Range::volume>(vol, mDescriptor);
77 }
78
setAndVerifyParameters(Volume::Tag volTag,int param,binder_exception_t expected)79 void setAndVerifyParameters(Volume::Tag volTag, int param, binder_exception_t expected) {
80 auto expectedParam = createVolumeParam(param, volTag);
81 EXPECT_STATUS(expected, mEffect->setParameter(expectedParam)) << expectedParam.toString();
82
83 if (expected == EX_NONE) {
84 Volume::Id volId = Volume::Id::make<Volume::Id::commonTag>(volTag);
85
86 auto id = Parameter::Id::make<Parameter::Id::volumeTag>(volId);
87 // get parameter
88 Parameter getParam;
89 // if set success, then get should match
90 EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));
91 EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()
92 << "\ngetParam:" << getParam.toString();
93 }
94 }
95
96 static constexpr int kDurationMilliSec = 1440;
97 static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;
98 static constexpr int kMinLevel = -96;
99 static constexpr int mChannelLayout = kDefaultChannelLayout;
100 long mInputFrameCount, mOutputFrameCount;
101 std::shared_ptr<IFactory> mFactory;
102 std::shared_ptr<IEffect> mEffect;
103 IEffect::OpenEffectReturn mOpenEffectReturn;
104 Descriptor mDescriptor;
105 };
106 /**
107 * Here we focus on specific parameter checking, general IEffect interfaces testing performed in
108 * VtsAudioEffectTargetTest.
109 */
110 enum VolumeLevelParamName { PARAM_INSTANCE_NAME, PARAM_LEVEL };
111 using VolumeLevelTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>;
112
113 class VolumeLevelParamTest : public ::testing::TestWithParam<VolumeLevelTestParam>,
114 public VolumeControlHelper {
115 public:
VolumeLevelParamTest()116 VolumeLevelParamTest() : mParamLevel(std::get<PARAM_LEVEL>(GetParam())) {
117 std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
118 }
119
SetUp()120 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl()); }
TearDown()121 void TearDown() override { TearDownVolumeControl(); }
122
123 int mParamLevel = 0;
124 };
125
TEST_P(VolumeLevelParamTest,SetAndGetParams)126 TEST_P(VolumeLevelParamTest, SetAndGetParams) {
127 ASSERT_NO_FATAL_FAILURE(
128 setAndVerifyParameters(Volume::levelDb, mParamLevel,
129 isLevelValid(mParamLevel) ? EX_NONE : EX_ILLEGAL_ARGUMENT));
130 }
131
132 enum VolumeMuteParamName { MUTE_PARAM_INSTANCE_NAME, PARAM_MUTE };
133 using VolumeMuteTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, bool>;
134
135 class VolumeMuteParamTest : public ::testing::TestWithParam<VolumeMuteTestParam>,
136 public VolumeControlHelper {
137 public:
VolumeMuteParamTest()138 VolumeMuteParamTest() : mParamMute(std::get<PARAM_MUTE>(GetParam())) {
139 std::tie(mFactory, mDescriptor) = std::get<MUTE_PARAM_INSTANCE_NAME>(GetParam());
140 }
141
SetUp()142 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl()); }
TearDown()143 void TearDown() override { TearDownVolumeControl(); }
144
145 bool mParamMute = false;
146 };
147
TEST_P(VolumeMuteParamTest,SetAndGetParams)148 TEST_P(VolumeMuteParamTest, SetAndGetParams) {
149 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, mParamMute, EX_NONE));
150 }
151
152 using VolumeDataTestParam = std::pair<std::shared_ptr<IFactory>, Descriptor>;
153
154 class VolumeDataTest : public ::testing::TestWithParam<VolumeDataTestParam>,
155 public VolumeControlHelper {
156 public:
VolumeDataTest()157 VolumeDataTest()
158 : kVsrApiLevel(
159 android::base::GetIntProperty("ro.vendor.api_level", __ANDROID_API_FUTURE__)) {
160 std::tie(mFactory, mDescriptor) = GetParam();
161 mInput.resize(kBufferSize);
162 mInputMag.resize(mTestFrequencies.size());
163 mBinOffsets.resize(mTestFrequencies.size());
164 roundToFreqCenteredToFftBin(mTestFrequencies, mBinOffsets, kBinWidth);
165 }
166
calculatePercentageDiff(const std::vector<float> & outputMag)167 std::vector<int> calculatePercentageDiff(const std::vector<float>& outputMag) {
168 std::vector<int> percentages(mTestFrequencies.size());
169
170 for (size_t i = 0; i < mInputMag.size(); i++) {
171 float diff = mInputMag[i] - outputMag[i];
172 percentages[i] = std::round(diff / mInputMag[i] * 100);
173 }
174 return percentages;
175 }
176
177 // Convert Decibel value to Percentage
percentageDb(float level)178 int percentageDb(float level) { return std::round((1 - (pow(10, level / 20))) * 100); }
179
SetUp()180 void SetUp() override {
181 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
182 // Skips test fixture if api_level <= 34 (__ANDROID_API_U__).
183 if (kVsrApiLevel <= __ANDROID_API_U__) GTEST_SKIP();
184 ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput, 1.0, kSamplingFrequency,
185 mChannelLayout));
186 ASSERT_NO_FATAL_FAILURE(
187 calculateAndVerifyMagnitude(mInputMag, mChannelLayout, mInput, mBinOffsets));
188
189 ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl());
190 }
TearDown()191 void TearDown() override {
192 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
193 if (kVsrApiLevel <= __ANDROID_API_U__) GTEST_SKIP();
194 TearDownVolumeControl();
195 }
196
197 const int kVsrApiLevel;
198 static constexpr int kMaxAudioSample = 1;
199 static constexpr int kTransitionDuration = 300;
200 static constexpr float kBinWidth = (float)kSamplingFrequency / kNPointFFT;
201 static constexpr size_t offset = kSamplingFrequency * kTransitionDuration / 1000;
202 static constexpr float kBaseLevel = 0;
203 std::vector<int> mTestFrequencies = {100, 1000};
204 std::vector<float> mInput;
205 std::vector<float> mInputMag;
206 std::vector<int> mBinOffsets;
207 };
208
TEST_P(VolumeDataTest,ApplyLevelMuteUnmute)209 TEST_P(VolumeDataTest, ApplyLevelMuteUnmute) {
210 std::vector<float> output(kBufferSize);
211 std::vector<int> diffs(mTestFrequencies.size());
212 std::vector<float> outputMag(mTestFrequencies.size());
213
214 if (!isLevelValid(kBaseLevel)) {
215 GTEST_SKIP() << "Volume Level not supported, skipping the test\n";
216 }
217
218 // Apply Volume Level
219
220 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, kBaseLevel, EX_NONE));
221 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
222
223 ASSERT_NO_FATAL_FAILURE(
224 calculateAndVerifyMagnitude(outputMag, mChannelLayout, output, mBinOffsets));
225
226 diffs = calculatePercentageDiff(outputMag);
227
228 for (size_t i = 0; i < diffs.size(); i++) {
229 ASSERT_EQ(diffs[i], percentageDb(kBaseLevel));
230 }
231
232 // Apply Mute
233
234 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, true /*mute*/, EX_NONE));
235 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
236
237 std::vector<float> subOutputMute(output.begin() + offset, output.end());
238
239 ASSERT_NO_FATAL_FAILURE(
240 calculateAndVerifyMagnitude(outputMag, mChannelLayout, subOutputMute, mBinOffsets));
241
242 diffs = calculatePercentageDiff(outputMag);
243
244 for (size_t i = 0; i < diffs.size(); i++) {
245 ASSERT_EQ(diffs[i], percentageDb(kMinLevel /*Mute*/));
246 }
247
248 // Verifying Fade out
249 ASSERT_NO_FATAL_FAILURE(
250 calculateAndVerifyMagnitude(outputMag, mChannelLayout, output, mBinOffsets));
251
252 diffs = calculatePercentageDiff(outputMag);
253
254 for (size_t i = 0; i < diffs.size(); i++) {
255 ASSERT_LT(diffs[i], percentageDb(kMinLevel /*Mute*/));
256 }
257
258 // Apply Unmute
259
260 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::mute, false /*unmute*/, EX_NONE));
261 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
262
263 std::vector<float> subOutputUnmute(output.begin() + offset, output.end());
264
265 ASSERT_NO_FATAL_FAILURE(
266 calculateAndVerifyMagnitude(outputMag, mChannelLayout, subOutputUnmute, mBinOffsets));
267
268 diffs = calculatePercentageDiff(outputMag);
269
270 for (size_t i = 0; i < diffs.size(); i++) {
271 ASSERT_EQ(diffs[i], percentageDb(kBaseLevel));
272 }
273
274 // Verifying Fade in
275 ASSERT_NO_FATAL_FAILURE(
276 calculateAndVerifyMagnitude(outputMag, mChannelLayout, output, mBinOffsets));
277
278 diffs = calculatePercentageDiff(outputMag);
279
280 for (size_t i = 0; i < diffs.size(); i++) {
281 ASSERT_GT(diffs[i], percentageDb(kBaseLevel));
282 }
283 }
284
TEST_P(VolumeDataTest,DecreasingLevels)285 TEST_P(VolumeDataTest, DecreasingLevels) {
286 std::vector<int> decreasingLevels = {-24, -48, -96};
287 std::vector<float> baseOutput(kBufferSize);
288 std::vector<int> baseDiffs(mTestFrequencies.size());
289 std::vector<float> outputMag(mTestFrequencies.size());
290
291 if (!isLevelValid(kBaseLevel)) {
292 GTEST_SKIP() << "Volume Level not supported, skipping the test\n";
293 }
294
295 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, kBaseLevel, EX_NONE));
296 ASSERT_NO_FATAL_FAILURE(
297 processAndWriteToOutput(mInput, baseOutput, mEffect, &mOpenEffectReturn));
298
299 ASSERT_NO_FATAL_FAILURE(
300 calculateAndVerifyMagnitude(outputMag, mChannelLayout, baseOutput, mBinOffsets));
301
302 baseDiffs = calculatePercentageDiff(outputMag);
303
304 for (int level : decreasingLevels) {
305 std::vector<float> output(kBufferSize);
306 std::vector<int> diffs(mTestFrequencies.size());
307
308 // Skipping the further steps for unnsupported level values
309 if (!isLevelValid(level)) {
310 continue;
311 }
312 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameters(Volume::levelDb, level, EX_NONE));
313 ASSERT_NO_FATAL_FAILURE(
314 processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
315
316 ASSERT_NO_FATAL_FAILURE(
317 calculateAndVerifyMagnitude(outputMag, mChannelLayout, output, mBinOffsets));
318
319 diffs = calculatePercentageDiff(outputMag);
320
321 // Decrease in volume level results in greater magnitude difference
322 for (size_t i = 0; i < diffs.size(); i++) {
323 ASSERT_GT(diffs[i], baseDiffs[i]);
324 }
325
326 baseDiffs = diffs;
327 }
328 }
329
330 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
331 INSTANTIATE_TEST_SUITE_P(
332 VolumeTest, VolumeLevelParamTest,
333 ::testing::Combine(
334 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
335 IFactory::descriptor, getEffectTypeUuidVolume())),
336 testing::ValuesIn(
337 EffectHelper::getTestValueSet<Volume, int, Range::volume, Volume::levelDb>(
338 kDescPair, EffectHelper::expandTestValueBasic<int>))),
__anon8eb15a1d0102(const testing::TestParamInfo<VolumeLevelParamTest::ParamType>& info) 339 [](const testing::TestParamInfo<VolumeLevelParamTest::ParamType>& info) {
340 auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
341 std::string level = std::to_string(std::get<PARAM_LEVEL>(info.param));
342 std::string name = getPrefix(descriptor) + "_level" + level;
343 std::replace_if(
344 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
345 return name;
346 });
347
348 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VolumeLevelParamTest);
349
350 INSTANTIATE_TEST_SUITE_P(
351 VolumeTest, VolumeMuteParamTest,
352 ::testing::Combine(
353 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
354 IFactory::descriptor, getEffectTypeUuidVolume())),
355 testing::Bool() /* mute */),
__anon8eb15a1d0302(const testing::TestParamInfo<VolumeMuteParamTest::ParamType>& info) 356 [](const testing::TestParamInfo<VolumeMuteParamTest::ParamType>& info) {
357 auto descriptor = std::get<MUTE_PARAM_INSTANCE_NAME>(info.param).second;
358 std::string mute = std::to_string(std::get<PARAM_MUTE>(info.param));
359 std::string name = getPrefix(descriptor) + "_mute" + mute;
360 std::replace_if(
361 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
362 return name;
363 });
364
365 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VolumeMuteParamTest);
366
367 INSTANTIATE_TEST_SUITE_P(VolumeTest, VolumeDataTest,
368 testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
369 IFactory::descriptor, getEffectTypeUuidVolume())),
__anon8eb15a1d0502(const testing::TestParamInfo<VolumeDataTest::ParamType>& info) 370 [](const testing::TestParamInfo<VolumeDataTest::ParamType>& info) {
371 auto descriptor = info.param;
372 std::string name = getPrefix(descriptor.second);
373 std::replace_if(
374 name.begin(), name.end(),
375 [](const char c) { return !std::isalnum(c); }, '_');
376 return name;
377 });
378
379 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VolumeDataTest);
380
main(int argc,char ** argv)381 int main(int argc, char** argv) {
382 ::testing::InitGoogleTest(&argc, argv);
383 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
384 ABinderProcess_setThreadPoolMaxThreadCount(1);
385 ABinderProcess_startThreadPool();
386 return RUN_ALL_TESTS();
387 }
388