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