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 <unordered_set>
18
19 #define LOG_TAG "VtsHalVisualizerTest"
20 #include <android-base/logging.h>
21 #include <android/binder_enums.h>
22 #include <audio_utils/power.h>
23
24 #include "EffectHelper.h"
25
26 using namespace android;
27
28 using aidl::android::hardware::audio::common::getChannelCount;
29 using aidl::android::hardware::audio::effect::Descriptor;
30 using aidl::android::hardware::audio::effect::getEffectTypeUuidVisualizer;
31 using aidl::android::hardware::audio::effect::IEffect;
32 using aidl::android::hardware::audio::effect::IFactory;
33 using aidl::android::hardware::audio::effect::Parameter;
34 using aidl::android::hardware::audio::effect::Visualizer;
35 using android::hardware::audio::common::testing::detail::TestExecutionTracer;
36
37 /**
38 * Here we focus on specific parameter checking, general IEffect interfaces testing performed in
39 * VtsAudioEffectTargetTest.
40 */
41 enum ParamName {
42 PARAM_INSTANCE_NAME,
43 PARAM_CAPTURE_SIZE,
44 PARAM_SCALING_MODE,
45 PARAM_MEASUREMENT_MODE,
46 PARAM_LATENCY,
47 };
48 using VisualizerTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int,
49 Visualizer::ScalingMode, Visualizer::MeasurementMode, int>;
50
51 class VisualizerTestHelper : public EffectHelper {
52 public:
VisualizerTestHelper(std::pair<std::shared_ptr<IFactory>,Descriptor> descPair={},int captureSize=128,int latency=0,Visualizer::ScalingMode scalingMode=Visualizer::ScalingMode::NORMALIZED,Visualizer::MeasurementMode measurementMode=Visualizer::MeasurementMode::NONE)53 VisualizerTestHelper(
54 std::pair<std::shared_ptr<IFactory>, Descriptor> descPair = {}, int captureSize = 128,
55 int latency = 0,
56 Visualizer::ScalingMode scalingMode = Visualizer::ScalingMode::NORMALIZED,
57 Visualizer::MeasurementMode measurementMode = Visualizer::MeasurementMode::NONE)
58 : mCaptureSize(captureSize),
59 mLatency(latency),
60 mScalingMode(scalingMode),
61 mMeasurementMode(measurementMode),
62 mInputBuffer(mBufferSizeInFrames),
63 mOutputBuffer(mBufferSizeInFrames) {
64 std::tie(mFactory, mDescriptor) = descPair;
65 }
66
SetUpVisualizer()67 void SetUpVisualizer() {
68 ASSERT_NE(nullptr, mFactory);
69 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
70
71 AudioChannelLayout inputLayout = AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
72 AudioChannelLayout::LAYOUT_MONO);
73 AudioChannelLayout outputLayout = inputLayout;
74
75 Parameter::Common common = createParamCommon(
76 0 /* session */, 1 /* ioHandle */, mBufferSizeInFrames /* iSampleRate */,
77 mBufferSizeInFrames /* oSampleRate */, kInputFrameCount /* iFrameCount */,
78 kOutputFrameCount /* oFrameCount */, inputLayout, outputLayout);
79 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &mOpenEffectReturn, EX_NONE));
80 ASSERT_NE(nullptr, mEffect);
81 mVersion = EffectFactoryHelper::getHalVersion(mFactory);
82 }
83
TearDownVisualizer()84 void TearDownVisualizer() {
85 ASSERT_NO_FATAL_FAILURE(close(mEffect));
86 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
87 mOpenEffectReturn = IEffect::OpenEffectReturn{};
88 }
89
SetAndGetParameters(bool * allParamsValid=nullptr)90 void SetAndGetParameters(bool* allParamsValid = nullptr) {
91 if (allParamsValid != nullptr) *allParamsValid = true;
92 for (auto& it : mCommonTags) {
93 auto& tag = it.first;
94 auto& vs = it.second;
95
96 // validate parameter
97 Descriptor desc;
98 ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
99 const bool valid = isParameterValid<Visualizer, Range::visualizer>(vs, desc);
100 const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;
101 if (expected == EX_ILLEGAL_ARGUMENT && allParamsValid != nullptr) {
102 *allParamsValid = false;
103 }
104
105 // set parameter
106 Parameter expectParam;
107 Parameter::Specific specific;
108 specific.set<Parameter::Specific::visualizer>(vs);
109 expectParam.set<Parameter::specific>(specific);
110 EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();
111
112 // only get if parameter in range and set success
113 if (expected == EX_NONE) {
114 Parameter getParam;
115 Parameter::Id id;
116 Visualizer::Id vsId;
117 vsId.set<Visualizer::Id::commonTag>(tag);
118 id.set<Parameter::Id::visualizerTag>(vsId);
119 EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam))
120 << " with: " << id.toString();
121 EXPECT_EQ(expectParam, getParam) << "\nexpect:" << expectParam.toString()
122 << "\ngetParam:" << getParam.toString();
123 }
124 }
125 }
126
addCaptureSizeParam(int captureSize)127 void addCaptureSizeParam(int captureSize) {
128 mCommonTags.push_back({Visualizer::captureSamples,
129 Visualizer::make<Visualizer::captureSamples>(captureSize)});
130 }
131
addScalingModeParam(Visualizer::ScalingMode scalingMode)132 void addScalingModeParam(Visualizer::ScalingMode scalingMode) {
133 mCommonTags.push_back(
134 {Visualizer::scalingMode, Visualizer::make<Visualizer::scalingMode>(scalingMode)});
135 }
136
addMeasurementModeParam(Visualizer::MeasurementMode measurementMode)137 void addMeasurementModeParam(Visualizer::MeasurementMode measurementMode) {
138 mCommonTags.push_back({Visualizer::measurementMode,
139 Visualizer::make<Visualizer::measurementMode>(measurementMode)});
140 }
141
addLatencyParam(int latency)142 void addLatencyParam(int latency) {
143 mCommonTags.push_back(
144 {Visualizer::latencyMs, Visualizer::make<Visualizer::latencyMs>(latency)});
145 }
146
getScalingModeValues()147 static std::unordered_set<Visualizer::ScalingMode> getScalingModeValues() {
148 return {ndk::enum_range<Visualizer::ScalingMode>().begin(),
149 ndk::enum_range<Visualizer::ScalingMode>().end()};
150 }
151
152 static constexpr long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
153 const size_t mChannelCount =
154 getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
155 AudioChannelLayout::LAYOUT_MONO));
156 const size_t mBufferSizeInFrames = kInputFrameCount * mChannelCount;
157 const int mCaptureSize;
158 const int mLatency;
159 const Visualizer::ScalingMode mScalingMode;
160 const Visualizer::MeasurementMode mMeasurementMode;
161 int mVersion;
162 std::vector<float> mInputBuffer;
163 std::vector<float> mOutputBuffer;
164 std::shared_ptr<IEffect> mEffect;
165 std::shared_ptr<IFactory> mFactory;
166 Descriptor mDescriptor;
167 IEffect::OpenEffectReturn mOpenEffectReturn;
168
169 private:
170 std::vector<std::pair<Visualizer::Tag, Visualizer>> mCommonTags;
CleanUp()171 void CleanUp() { mCommonTags.clear(); }
172 };
173
174 class VisualizerParamTest : public ::testing::TestWithParam<VisualizerTestParam>,
175 public VisualizerTestHelper {
176 public:
VisualizerParamTest()177 VisualizerParamTest()
178 : VisualizerTestHelper(std::get<PARAM_INSTANCE_NAME>(GetParam()),
179 std::get<PARAM_CAPTURE_SIZE>(GetParam()),
180 std::get<PARAM_LATENCY>(GetParam()),
181 std::get<PARAM_SCALING_MODE>(GetParam()),
182 std::get<PARAM_MEASUREMENT_MODE>(GetParam())) {
183 generateInputBuffer(mInputBuffer, 0, true, mChannelCount, kMaxAudioSampleValue);
184 }
185
SetUp()186 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVisualizer()); }
187
TearDown()188 void TearDown() override { TearDownVisualizer(); }
189
getMeasurementModeValues()190 static std::unordered_set<Visualizer::MeasurementMode> getMeasurementModeValues() {
191 return {ndk::enum_range<Visualizer::MeasurementMode>().begin(),
192 ndk::enum_range<Visualizer::MeasurementMode>().end()};
193 }
194 };
195
TEST_P(VisualizerParamTest,SetAndGetCaptureSize)196 TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {
197 addCaptureSizeParam(mCaptureSize);
198 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
199 }
200
TEST_P(VisualizerParamTest,SetAndGetScalingMode)201 TEST_P(VisualizerParamTest, SetAndGetScalingMode) {
202 addScalingModeParam(mScalingMode);
203 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
204 }
205
TEST_P(VisualizerParamTest,SetAndGetMeasurementMode)206 TEST_P(VisualizerParamTest, SetAndGetMeasurementMode) {
207 addMeasurementModeParam(mMeasurementMode);
208 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
209 }
210
TEST_P(VisualizerParamTest,SetAndGetLatency)211 TEST_P(VisualizerParamTest, SetAndGetLatency) {
212 addLatencyParam(mLatency);
213 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
214 }
215
TEST_P(VisualizerParamTest,testCaptureSampleBufferSizeAndOutput)216 TEST_P(VisualizerParamTest, testCaptureSampleBufferSizeAndOutput) {
217 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
218
219 bool allParamsValid = true;
220 addCaptureSizeParam(mCaptureSize);
221 addScalingModeParam(mScalingMode);
222 addMeasurementModeParam(mMeasurementMode);
223 addLatencyParam(mLatency);
224 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters(&allParamsValid));
225
226 Parameter getParam;
227 Parameter::Id id;
228 Visualizer::Id vsId;
229 vsId.set<Visualizer::Id::commonTag>(Visualizer::captureSampleBuffer);
230 id.set<Parameter::Id::visualizerTag>(vsId);
231 EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam)) << " with: " << id.toString();
232
233 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect,
234 &mOpenEffectReturn, mVersion));
235 ASSERT_EQ(mInputBuffer, mOutputBuffer);
236
237 if (allParamsValid) {
238 std::vector<uint8_t> captureBuffer = getParam.get<Parameter::specific>()
239 .get<Parameter::Specific::visualizer>()
240 .get<Visualizer::captureSampleBuffer>();
241 ASSERT_EQ((size_t)mCaptureSize, captureBuffer.size());
242 }
243 }
244
245 class VisualizerDataTest : public ::testing::TestWithParam<VisualizerTestParam>,
246 public VisualizerTestHelper {
247 public:
VisualizerDataTest()248 VisualizerDataTest()
249 : VisualizerTestHelper(std::get<PARAM_INSTANCE_NAME>(GetParam()),
250 std::get<PARAM_CAPTURE_SIZE>(GetParam()),
251 std::get<PARAM_LATENCY>(GetParam()),
252 std::get<PARAM_SCALING_MODE>(GetParam()),
253 std::get<PARAM_MEASUREMENT_MODE>(GetParam())) {}
254
SetUp()255 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVisualizer()); }
256
TearDown()257 void TearDown() override { TearDownVisualizer(); }
258 };
259
TEST_P(VisualizerDataTest,testScalingModeParameters)260 TEST_P(VisualizerDataTest, testScalingModeParameters) {
261 SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
262
263 // This test holds true for the following range
264 static_assert(kMaxAudioSampleValue <= 1.0 && kMaxAudioSampleValue > 0.0,
265 "Valid range of kMaxAudioSample value for the test: (0.0, 1.0]");
266
267 constexpr float kPowerToleranceDb = 0.5;
268
269 ASSERT_NO_FATAL_FAILURE(generateSineWave(1000, mInputBuffer, 1.0, mBufferSizeInFrames,
270 AudioChannelLayout::LAYOUT_MONO));
271 const float expectedPowerNormalized = audio_utils_compute_power_mono(
272 mInputBuffer.data(), AUDIO_FORMAT_PCM_FLOAT, mInputBuffer.size());
273
274 const std::vector<float> testMaxAudioSampleValueList = {
275 0.25 * kMaxAudioSampleValue, 0.5 * kMaxAudioSampleValue, 0.75 * kMaxAudioSampleValue,
276 kMaxAudioSampleValue};
277
278 Parameter::Id idCsb;
279 Visualizer::Id vsIdCsb;
280 vsIdCsb.set<Visualizer::Id::commonTag>(Visualizer::captureSampleBuffer);
281 idCsb.set<Parameter::Id::visualizerTag>(vsIdCsb);
282
283 for (float maxAudioSampleValue : testMaxAudioSampleValueList) {
284 bool allParamsValid = true;
285 addCaptureSizeParam(mCaptureSize);
286 addScalingModeParam(mScalingMode);
287 addLatencyParam(mLatency);
288 ASSERT_NO_FATAL_FAILURE(SetAndGetParameters(&allParamsValid));
289
290 ASSERT_NO_FATAL_FAILURE(generateSineWave(std::vector<int>{1000}, mInputBuffer,
291 maxAudioSampleValue, mBufferSizeInFrames,
292 AudioChannelLayout::LAYOUT_MONO));
293
294 // The stop and reset calls to the effect are made towards the end in order to fetch the
295 // captureSampleBuffer values
296 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect,
297 &mOpenEffectReturn, mVersion, 1, false));
298 if (allParamsValid) {
299 Parameter getParam;
300 EXPECT_STATUS(EX_NONE, mEffect->getParameter(idCsb, &getParam))
301 << " with: " << idCsb.toString();
302 std::vector<uint8_t> captureBuffer = getParam.get<Parameter::specific>()
303 .get<Parameter::Specific::visualizer>()
304 .get<Visualizer::captureSampleBuffer>();
305 ASSERT_EQ((size_t)mCaptureSize, captureBuffer.size());
306
307 float currPowerCsb = audio_utils_compute_power_mono(
308 captureBuffer.data(), AUDIO_FORMAT_PCM_8_BIT, mCaptureSize);
309
310 if (mScalingMode == Visualizer::ScalingMode::NORMALIZED) {
311 EXPECT_NEAR(currPowerCsb, expectedPowerNormalized, kPowerToleranceDb);
312 } else {
313 float powerI = audio_utils_compute_power_mono(
314 mInputBuffer.data(), AUDIO_FORMAT_PCM_FLOAT, mInputBuffer.size());
315 EXPECT_NEAR(currPowerCsb, powerI, kPowerToleranceDb);
316 }
317 }
318 ASSERT_NO_FATAL_FAILURE(command(mEffect, CommandId::STOP));
319 ASSERT_NO_FATAL_FAILURE(command(mEffect, CommandId::RESET));
320 }
321 }
322
323 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
324 INSTANTIATE_TEST_SUITE_P(
325 VisualizerParamTest, VisualizerParamTest,
326 ::testing::Combine(
327 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
328 IFactory::descriptor, getEffectTypeUuidVisualizer())),
329 testing::ValuesIn(EffectHelper::getTestValueSet<Visualizer, int, Range::visualizer,
330 Visualizer::captureSamples>(
331 kDescPair, EffectHelper::expandTestValueBasic<int>)),
332 testing::ValuesIn(VisualizerTestHelper::getScalingModeValues()),
333 testing::ValuesIn(VisualizerParamTest::getMeasurementModeValues()),
334 testing::ValuesIn(EffectHelper::getTestValueSet<Visualizer, int, Range::visualizer,
335 Visualizer::latencyMs>(
336 kDescPair, EffectHelper::expandTestValueBasic<int>))),
__anon465e7b730102(const testing::TestParamInfo<VisualizerParamTest::ParamType>& info) 337 [](const testing::TestParamInfo<VisualizerParamTest::ParamType>& info) {
338 auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
339 std::string captureSize = std::to_string(std::get<PARAM_CAPTURE_SIZE>(info.param));
340 std::string scalingMode = aidl::android::hardware::audio::effect::toString(
341 std::get<PARAM_SCALING_MODE>(info.param));
342 std::string measurementMode = aidl::android::hardware::audio::effect::toString(
343 std::get<PARAM_MEASUREMENT_MODE>(info.param));
344 std::string latency = std::to_string(std::get<PARAM_LATENCY>(info.param));
345
346 std::string name = getPrefix(descriptor) + "_captureSize" + captureSize +
347 "_scalingMode" + scalingMode + "_measurementMode" + measurementMode +
348 "_latency" + latency;
349 std::replace_if(
350 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
351 return name;
352 });
353
354 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VisualizerParamTest);
355
356 INSTANTIATE_TEST_SUITE_P(
357 VisualizerDataTest, VisualizerDataTest,
358 ::testing::Combine(
359 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
360 IFactory::descriptor, getEffectTypeUuidVisualizer())),
361 testing::Values(128), // captureSize
362 testing::ValuesIn(VisualizerTestHelper::getScalingModeValues()),
363 testing::Values(Visualizer::MeasurementMode::PEAK_RMS),
364 testing::Values(0) // latency
365 ),
__anon465e7b730302(const testing::TestParamInfo<VisualizerDataTest::ParamType>& info) 366 [](const testing::TestParamInfo<VisualizerDataTest::ParamType>& info) {
367 auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
368 std::string captureSize = std::to_string(std::get<PARAM_CAPTURE_SIZE>(info.param));
369 std::string scalingMode = aidl::android::hardware::audio::effect::toString(
370 std::get<PARAM_SCALING_MODE>(info.param));
371 std::string measurementMode = aidl::android::hardware::audio::effect::toString(
372 std::get<PARAM_MEASUREMENT_MODE>(info.param));
373 std::string latency = std::to_string(std::get<PARAM_LATENCY>(info.param));
374
375 std::string name = getPrefix(descriptor) + "_captureSize" + captureSize +
376 "_scalingMode" + scalingMode + "_measurementMode" + measurementMode +
377 "_latency" + latency;
378 std::replace_if(
379 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
380 return name;
381 });
382
383 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VisualizerDataTest);
384
main(int argc,char ** argv)385 int main(int argc, char** argv) {
386 ::testing::InitGoogleTest(&argc, argv);
387 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
388 ABinderProcess_setThreadPoolMaxThreadCount(1);
389 ABinderProcess_startThreadPool();
390 return RUN_ALL_TESTS();
391 }
392