blob: d39fbcd5c3d78ab2739c09bc98dc5e8bd771de80 [file] [log] [blame]
Mikhail Naganovbf393172016-11-11 16:24:50 -08001/*
Kevin Rocard96d2cd92018-11-14 16:22:07 -08002 * Copyright (C) 2018 The Android Open Source Project
Mikhail Naganovbf393172016-11-11 16:24:50 -08003 *
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 "AudioEffectHidlHalTest"
18#include <android-base/logging.h>
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000019#if MAJOR_VERSION <= 6
Mikhail Naganov9f289042017-02-23 08:39:36 -080020#include <system/audio.h>
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000021#endif
Mikhail Naganovbf393172016-11-11 16:24:50 -080022
Kevin Rocard96d2cd92018-11-14 16:22:07 -080023#include PATH(android/hardware/audio/effect/FILE_VERSION/IEffect.h)
24#include PATH(android/hardware/audio/effect/FILE_VERSION/IEffectsFactory.h)
25#include PATH(android/hardware/audio/effect/FILE_VERSION/IEqualizerEffect.h)
26#include PATH(android/hardware/audio/effect/FILE_VERSION/ILoudnessEnhancerEffect.h)
27#include PATH(android/hardware/audio/effect/FILE_VERSION/types.h)
Mikhail Naganov9f289042017-02-23 08:39:36 -080028#include <android/hidl/allocator/1.0/IAllocator.h>
29#include <android/hidl/memory/1.0/IMemory.h>
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000030#if MAJOR_VERSION >= 7
Hayden Gomes4e7d69e2020-11-06 15:15:26 -080031#include <android_audio_policy_configuration_V7_0-enums.h>
32#include <android_audio_policy_configuration_V7_0.h>
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000033#endif
Mikhail Naganovbf393172016-11-11 16:24:50 -080034
Kevin Rocardf5305b32018-11-13 10:41:53 -080035#include <common/all-versions/VersionUtils.h>
36
Mikhail Naganov315ce412019-10-23 16:46:54 -070037#include <gtest/gtest.h>
38#include <hidl/GtestPrinter.h>
39#include <hidl/ServiceManagement.h>
Mikhail Naganovbf393172016-11-11 16:24:50 -080040
Mikhail Naganov00a44c02018-12-14 14:31:45 -080041using ::android::sp;
42using ::android::hardware::hidl_handle;
43using ::android::hardware::hidl_memory;
44using ::android::hardware::hidl_string;
45using ::android::hardware::hidl_vec;
46using ::android::hardware::MQDescriptorSync;
47using ::android::hardware::Return;
48using ::android::hardware::Void;
49using ::android::hardware::audio::common::utils::mkEnumBitfield;
50using ::android::hidl::allocator::V1_0::IAllocator;
51using ::android::hidl::memory::V1_0::IMemory;
52using namespace ::android::hardware::audio::common::CPP_VERSION;
53using namespace ::android::hardware::audio::effect::CPP_VERSION;
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000054#if MAJOR_VERSION >= 7
55// Make an alias for enumerations generated from the APM config XSD.
56namespace xsd {
Hayden Gomes4e7d69e2020-11-06 15:15:26 -080057using namespace ::android::audio::policy::configuration::CPP_VERSION;
Mikhail Naganovd72a7c22020-08-14 00:16:09 +000058}
59#endif
Mikhail Naganovbf393172016-11-11 16:24:50 -080060
Mikhail Naganov9f289042017-02-23 08:39:36 -080061#ifndef ARRAY_SIZE
62#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
63#endif
64
Mikhail Naganov315ce412019-10-23 16:46:54 -070065class AudioEffectsFactoryHidlTest : public ::testing::TestWithParam<std::string> {
66 public:
67 void SetUp() override {
68 effectsFactory = IEffectsFactory::getService(GetParam());
69 ASSERT_NE(effectsFactory, nullptr);
70 }
Kevin Rocard55b10612018-11-12 12:33:16 -080071 void TearDown() override { effectsFactory.clear(); }
Mikhail Naganov9f289042017-02-23 08:39:36 -080072
Kevin Rocard55b10612018-11-12 12:33:16 -080073 protected:
74 static void description(const std::string& description) {
75 RecordProperty("description", description);
76 }
Mikhail Naganovbf393172016-11-11 16:24:50 -080077
Kevin Rocard55b10612018-11-12 12:33:16 -080078 sp<IEffectsFactory> effectsFactory;
Mikhail Naganovbf393172016-11-11 16:24:50 -080079};
80
nelsonli3c12e582019-12-12 13:53:49 +080081TEST_P(AudioEffectsFactoryHidlTest, EnumerateEffects) {
Kevin Rocard55b10612018-11-12 12:33:16 -080082 description("Verify that EnumerateEffects returns at least one effect");
83 Result retval = Result::NOT_INITIALIZED;
84 size_t effectCount = 0;
85 Return<void> ret =
86 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
87 retval = r;
88 effectCount = result.size();
89 });
90 EXPECT_TRUE(ret.isOk());
91 EXPECT_EQ(Result::OK, retval);
92 EXPECT_GT(effectCount, 0u);
Mikhail Naganovbf393172016-11-11 16:24:50 -080093}
94
nelsonli3c12e582019-12-12 13:53:49 +080095TEST_P(AudioEffectsFactoryHidlTest, CreateEffect) {
Kevin Rocard55b10612018-11-12 12:33:16 -080096 description("Verify that an effect can be created via CreateEffect");
97 bool gotEffect = false;
98 Uuid effectUuid;
99 Return<void> ret =
100 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
101 if (r == Result::OK && result.size() > 0) {
102 gotEffect = true;
103 effectUuid = result[0].uuid;
104 }
105 });
106 ASSERT_TRUE(ret.isOk());
107 ASSERT_TRUE(gotEffect);
108 Result retval = Result::NOT_INITIALIZED;
109 sp<IEffect> effect;
110 ret = effectsFactory->createEffect(
Eric Laurentd33e6932019-11-13 13:47:50 -0800111 effectUuid, 1 /*session*/, 1 /*ioHandle*/,
112#if MAJOR_VERSION >= 6
113 0 /*device*/,
114#endif
115 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) {
116 retval = r;
117 if (r == Result::OK) {
118 effect = result;
119 }
120 });
Kevin Rocard55b10612018-11-12 12:33:16 -0800121 EXPECT_TRUE(ret.isOk());
122 EXPECT_EQ(Result::OK, retval);
123 EXPECT_NE(nullptr, effect.get());
Mikhail Naganovbf393172016-11-11 16:24:50 -0800124}
125
nelsonli3c12e582019-12-12 13:53:49 +0800126TEST_P(AudioEffectsFactoryHidlTest, GetDescriptor) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800127 description(
128 "Verify that effects factory can provide an effect descriptor via "
129 "GetDescriptor");
130 hidl_vec<EffectDescriptor> allDescriptors;
131 Return<void> ret =
132 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
133 if (r == Result::OK) {
134 allDescriptors = result;
135 }
Mikhail Naganovbf393172016-11-11 16:24:50 -0800136 });
Kevin Rocard55b10612018-11-12 12:33:16 -0800137 ASSERT_TRUE(ret.isOk());
138 ASSERT_GT(allDescriptors.size(), 0u);
139 for (size_t i = 0; i < allDescriptors.size(); ++i) {
140 ret = effectsFactory->getDescriptor(allDescriptors[i].uuid,
141 [&](Result r, const EffectDescriptor& result) {
142 EXPECT_EQ(r, Result::OK);
143 EXPECT_EQ(result, allDescriptors[i]);
144 });
145 }
146 EXPECT_TRUE(ret.isOk());
Mikhail Naganovbf393172016-11-11 16:24:50 -0800147}
148
nelsonli3c12e582019-12-12 13:53:49 +0800149TEST_P(AudioEffectsFactoryHidlTest, DebugDumpInvalidArgument) {
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700150 description("Verify that debugDump doesn't crash on invalid arguments");
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800151#if MAJOR_VERSION == 2
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700152 Return<void> ret = effectsFactory->debugDump(hidl_handle());
Kevin Rocard20614ba2018-11-10 07:20:17 -0800153#elif MAJOR_VERSION >= 4
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800154 Return<void> ret = effectsFactory->debug(hidl_handle(), {});
155#endif
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700156 ASSERT_TRUE(ret.isOk());
157}
158
Mikhail Naganov9f289042017-02-23 08:39:36 -0800159// Equalizer effect is required by CDD, but only the type is fixed.
160// This is the same UUID as AudioEffect.EFFECT_TYPE_EQUALIZER in Java.
161static const Uuid EQUALIZER_EFFECT_TYPE = {
162 0x0bed4300, 0xddd6, 0x11db, 0x8f34,
163 std::array<uint8_t, 6>{{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}};
164// Loudness Enhancer effect is required by CDD, but only the type is fixed.
165// This is the same UUID as AudioEffect.EFFECT_TYPE_LOUDNESS_ENHANCER in Java.
166static const Uuid LOUDNESS_ENHANCER_EFFECT_TYPE = {
167 0xfe3199be, 0xaed0, 0x413f, 0x87bb,
168 std::array<uint8_t, 6>{{0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}}};
169
Mikhail Naganov892d1472020-03-19 10:44:06 -0700170enum { PARAM_FACTORY_NAME, PARAM_EFFECT_UUID };
171using EffectParameter = std::tuple<std::string, Uuid>;
172
173static inline std::string EffectParameterToString(
174 const ::testing::TestParamInfo<EffectParameter>& info) {
175 return ::android::hardware::PrintInstanceNameToString(::testing::TestParamInfo<std::string>{
176 std::get<PARAM_FACTORY_NAME>(info.param), info.index});
177}
178
Mikhail Naganov9f289042017-02-23 08:39:36 -0800179// The main test class for Audio Effect HIDL HAL.
Mikhail Naganov892d1472020-03-19 10:44:06 -0700180class AudioEffectHidlTest : public ::testing::TestWithParam<EffectParameter> {
Mikhail Naganov315ce412019-10-23 16:46:54 -0700181 public:
182 void SetUp() override {
Mikhail Naganov892d1472020-03-19 10:44:06 -0700183 effectsFactory = IEffectsFactory::getService(std::get<PARAM_FACTORY_NAME>(GetParam()));
Kevin Rocard55b10612018-11-12 12:33:16 -0800184 ASSERT_NE(nullptr, effectsFactory.get());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800185
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000186 ASSERT_NO_FATAL_FAILURE(findAndCreateEffect(getEffectType()));
Kevin Rocard55b10612018-11-12 12:33:16 -0800187 ASSERT_NE(nullptr, effect.get());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800188
Kevin Rocard55b10612018-11-12 12:33:16 -0800189 Return<Result> ret = effect->init();
190 ASSERT_TRUE(ret.isOk());
191 ASSERT_EQ(Result::OK, ret);
192 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800193
Kevin Rocard55b10612018-11-12 12:33:16 -0800194 void TearDown() override {
195 effect.clear();
196 effectsFactory.clear();
197 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800198
Kevin Rocard55b10612018-11-12 12:33:16 -0800199 protected:
200 static void description(const std::string& description) {
201 RecordProperty("description", description);
202 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800203
Mikhail Naganov892d1472020-03-19 10:44:06 -0700204 Uuid getEffectType() const { return std::get<PARAM_EFFECT_UUID>(GetParam()); }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800205
Kevin Rocard55b10612018-11-12 12:33:16 -0800206 void findAndCreateEffect(const Uuid& type);
207 void findEffectInstance(const Uuid& type, Uuid* uuid);
208 void getChannelCount(uint32_t* channelCount);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800209
Kevin Rocard55b10612018-11-12 12:33:16 -0800210 sp<IEffectsFactory> effectsFactory;
211 sp<IEffect> effect;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800212};
213
214void AudioEffectHidlTest::findAndCreateEffect(const Uuid& type) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800215 Uuid effectUuid;
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000216 ASSERT_NO_FATAL_FAILURE(findEffectInstance(type, &effectUuid));
Kevin Rocard55b10612018-11-12 12:33:16 -0800217 Return<void> ret = effectsFactory->createEffect(
Eric Laurentd33e6932019-11-13 13:47:50 -0800218 effectUuid, 1 /*session*/, 1 /*ioHandle*/,
219#if MAJOR_VERSION >= 6
220 0 /*device*/,
221#endif
222 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) {
223 if (r == Result::OK) {
224 effect = result;
225 }
226 });
Kevin Rocard55b10612018-11-12 12:33:16 -0800227 ASSERT_TRUE(ret.isOk());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800228}
229
230void AudioEffectHidlTest::findEffectInstance(const Uuid& type, Uuid* uuid) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800231 bool effectFound = false;
232 Return<void> ret =
233 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
234 if (r == Result::OK) {
235 for (const auto& desc : result) {
236 if (desc.type == type) {
237 effectFound = true;
238 *uuid = desc.uuid;
239 break;
240 }
241 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800242 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800243 });
244 ASSERT_TRUE(ret.isOk());
245 ASSERT_TRUE(effectFound);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800246}
247
248void AudioEffectHidlTest::getChannelCount(uint32_t* channelCount) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800249 Result retval;
250 EffectConfig currentConfig;
251 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
252 retval = r;
253 if (r == Result::OK) {
254 currentConfig = conf;
255 }
256 });
257 ASSERT_TRUE(ret.isOk());
258 ASSERT_EQ(Result::OK, retval);
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000259#if MAJOR_VERSION <= 6
Kevin Rocard55b10612018-11-12 12:33:16 -0800260 ASSERT_TRUE(audio_channel_mask_is_valid(
261 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels)));
262 *channelCount = audio_channel_count_from_out_mask(
263 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels));
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000264#else
Hayden Gomes4e7d69e2020-11-06 15:15:26 -0800265 *channelCount = android::audio::policy::configuration::V7_0::getChannelCount(
Mikhail Naganovf363ed42020-12-10 18:47:51 -0800266 currentConfig.outputCfg.base.channelMask);
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000267 ASSERT_NE(*channelCount, 0);
268#endif
Mikhail Naganov9f289042017-02-23 08:39:36 -0800269}
270
nelsonli3c12e582019-12-12 13:53:49 +0800271TEST_P(AudioEffectHidlTest, Close) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800272 description("Verify that an effect can be closed");
273 Return<Result> ret = effect->close();
274 EXPECT_TRUE(ret.isOk());
275 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800276}
277
nelsonli3c12e582019-12-12 13:53:49 +0800278TEST_P(AudioEffectHidlTest, GetDescriptor) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800279 description("Verify that an effect can return its own descriptor via GetDescriptor");
280 Result retval = Result::NOT_INITIALIZED;
281 Uuid actualType;
282 Return<void> ret = effect->getDescriptor([&](Result r, const EffectDescriptor& desc) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800283 retval = r;
284 if (r == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800285 actualType = desc.type;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800286 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800287 });
288 EXPECT_TRUE(ret.isOk());
289 EXPECT_EQ(Result::OK, retval);
290 EXPECT_EQ(getEffectType(), actualType);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800291}
292
nelsonli3c12e582019-12-12 13:53:49 +0800293TEST_P(AudioEffectHidlTest, GetSetConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800294 description(
295 "Verify that it is possible to manipulate effect config via Get / "
296 "SetConfig");
297 Result retval = Result::NOT_INITIALIZED;
298 EffectConfig currentConfig;
299 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
300 retval = r;
301 if (r == Result::OK) {
302 currentConfig = conf;
303 }
304 });
305 EXPECT_TRUE(ret.isOk());
306 EXPECT_EQ(Result::OK, retval);
307 Return<Result> ret2 = effect->setConfig(currentConfig, nullptr, nullptr);
308 EXPECT_TRUE(ret2.isOk());
309 EXPECT_EQ(Result::OK, ret2);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800310}
311
nelsonli3c12e582019-12-12 13:53:49 +0800312TEST_P(AudioEffectHidlTest, GetConfigReverse) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800313 description("Verify that GetConfigReverse does not crash");
314 Return<void> ret = effect->getConfigReverse([&](Result, const EffectConfig&) {});
315 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700316}
317
nelsonli3c12e582019-12-12 13:53:49 +0800318TEST_P(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800319 description("Verify that GetSupportedAuxChannelsConfigs does not crash");
320 Return<void> ret = effect->getSupportedAuxChannelsConfigs(
321 0, [&](Result, const hidl_vec<EffectAuxChannelsConfig>&) {});
322 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700323}
324
nelsonli3c12e582019-12-12 13:53:49 +0800325TEST_P(AudioEffectHidlTest, GetAuxChannelsConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800326 description("Verify that GetAuxChannelsConfig does not crash");
327 Return<void> ret = effect->getAuxChannelsConfig([&](Result, const EffectAuxChannelsConfig&) {});
328 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700329}
330
nelsonli3c12e582019-12-12 13:53:49 +0800331TEST_P(AudioEffectHidlTest, SetAuxChannelsConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800332 description("Verify that SetAuxChannelsConfig does not crash");
333 Return<Result> ret = effect->setAuxChannelsConfig(EffectAuxChannelsConfig());
334 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700335}
336
Mikhail Naganov9f289042017-02-23 08:39:36 -0800337// Not generated automatically because AudioBuffer contains
338// instances of hidl_memory which can't be compared properly
339// in general case due to presence of handles.
340//
341// However, in this particular case, handles must not present
342// thus comparison is possible.
343//
344// operator== must be defined in the same namespace as the structures.
345namespace android {
346namespace hardware {
347namespace audio {
348namespace effect {
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800349namespace CPP_VERSION {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800350inline bool operator==(const AudioBuffer& lhs, const AudioBuffer& rhs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800351 return lhs.id == rhs.id && lhs.frameCount == rhs.frameCount && lhs.data.handle() == nullptr &&
352 rhs.data.handle() == nullptr;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800353}
354
Kevin Rocard55b10612018-11-12 12:33:16 -0800355inline bool operator==(const EffectBufferConfig& lhs, const EffectBufferConfig& rhs) {
Mikhail Naganovf363ed42020-12-10 18:47:51 -0800356 return lhs.buffer == rhs.buffer &&
357#if MAJOR_VERSION <= 6
358 lhs.samplingRateHz == rhs.samplingRateHz && lhs.channels == rhs.channels &&
359 lhs.format == rhs.format &&
360#else
361 lhs.base.sampleRateHz == rhs.base.sampleRateHz &&
362 lhs.base.channelMask == rhs.base.channelMask && lhs.base.format == rhs.base.format &&
363#endif
Kevin Rocard55b10612018-11-12 12:33:16 -0800364 lhs.accessMode == rhs.accessMode && lhs.mask == rhs.mask;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800365}
366
367inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800368 return lhs.inputCfg == rhs.inputCfg && lhs.outputCfg == rhs.outputCfg;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800369}
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800370} // namespace CPP_VERSION
Mikhail Naganov9f289042017-02-23 08:39:36 -0800371} // namespace effect
372} // namespace audio
373} // namespace hardware
374} // namespace android
375
nelsonli3c12e582019-12-12 13:53:49 +0800376TEST_P(AudioEffectHidlTest, Reset) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800377 description("Verify that Reset preserves effect configuration");
378 Result retval = Result::NOT_INITIALIZED;
379 EffectConfig originalConfig;
380 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
381 retval = r;
382 if (r == Result::OK) {
383 originalConfig = conf;
384 }
385 });
386 ASSERT_TRUE(ret.isOk());
387 ASSERT_EQ(Result::OK, retval);
388 Return<Result> ret2 = effect->reset();
389 EXPECT_TRUE(ret2.isOk());
390 EXPECT_EQ(Result::OK, ret2);
391 EffectConfig configAfterReset;
392 ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
393 retval = r;
394 if (r == Result::OK) {
395 configAfterReset = conf;
396 }
397 });
398 EXPECT_EQ(originalConfig, configAfterReset);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800399}
400
nelsonli3c12e582019-12-12 13:53:49 +0800401TEST_P(AudioEffectHidlTest, DisableEnableDisable) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800402 description("Verify Disable -> Enable -> Disable sequence for an effect");
403 Return<Result> ret = effect->disable();
404 EXPECT_TRUE(ret.isOk());
Mikhail Naganov892d1472020-03-19 10:44:06 -0700405 // Note: some legacy effects may return -EINVAL (INVALID_ARGUMENTS),
406 // more canonical is to return -ENOSYS (NOT_SUPPORTED)
407 EXPECT_TRUE(ret == Result::NOT_SUPPORTED || ret == Result::INVALID_ARGUMENTS);
Kevin Rocard55b10612018-11-12 12:33:16 -0800408 ret = effect->enable();
409 EXPECT_TRUE(ret.isOk());
410 EXPECT_EQ(Result::OK, ret);
411 ret = effect->disable();
412 EXPECT_TRUE(ret.isOk());
413 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800414}
415
nelsonli3c12e582019-12-12 13:53:49 +0800416TEST_P(AudioEffectHidlTest, SetDevice) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800417 description("Verify that SetDevice works for an output chain effect");
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000418#if MAJOR_VERSION <= 6
Kevin Rocardf5305b32018-11-13 10:41:53 -0800419 Return<Result> ret = effect->setDevice(mkEnumBitfield(AudioDevice::OUT_SPEAKER));
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000420#else
421 DeviceAddress device{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER)};
422 Return<Result> ret = effect->setDevice(device);
423#endif
Kevin Rocard55b10612018-11-12 12:33:16 -0800424 EXPECT_TRUE(ret.isOk());
425 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800426}
427
nelsonli3c12e582019-12-12 13:53:49 +0800428TEST_P(AudioEffectHidlTest, SetAndGetVolume) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800429 description("Verify that SetAndGetVolume method works for an effect");
430 uint32_t channelCount;
431 getChannelCount(&channelCount);
432 hidl_vec<uint32_t> volumes;
433 volumes.resize(channelCount);
434 for (uint32_t i = 0; i < channelCount; ++i) {
435 volumes[i] = 0;
436 }
437 Result retval = Result::NOT_INITIALIZED;
438 Return<void> ret =
439 effect->setAndGetVolume(volumes, [&](Result r, const hidl_vec<uint32_t>&) { retval = r; });
440 EXPECT_TRUE(ret.isOk());
441 EXPECT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800442}
443
nelsonli3c12e582019-12-12 13:53:49 +0800444TEST_P(AudioEffectHidlTest, VolumeChangeNotification) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800445 description("Verify that effect accepts VolumeChangeNotification");
446 uint32_t channelCount;
447 getChannelCount(&channelCount);
448 hidl_vec<uint32_t> volumes;
449 volumes.resize(channelCount);
450 for (uint32_t i = 0; i < channelCount; ++i) {
451 volumes[i] = 0;
452 }
453 Return<Result> ret = effect->volumeChangeNotification(volumes);
454 EXPECT_TRUE(ret.isOk());
455 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800456}
457
nelsonli3c12e582019-12-12 13:53:49 +0800458TEST_P(AudioEffectHidlTest, SetAudioMode) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800459 description("Verify that SetAudioMode works for an effect");
460 Return<Result> ret = effect->setAudioMode(AudioMode::NORMAL);
461 EXPECT_TRUE(ret.isOk());
462 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800463}
464
nelsonli3c12e582019-12-12 13:53:49 +0800465TEST_P(AudioEffectHidlTest, SetConfigReverse) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800466 description("Verify that SetConfigReverse does not crash");
467 Return<Result> ret = effect->setConfigReverse(EffectConfig(), nullptr, nullptr);
468 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700469}
470
nelsonli3c12e582019-12-12 13:53:49 +0800471TEST_P(AudioEffectHidlTest, SetInputDevice) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800472 description("Verify that SetInputDevice does not crash");
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000473#if MAJOR_VERSION <= 6
Kevin Rocardf5305b32018-11-13 10:41:53 -0800474 Return<Result> ret = effect->setInputDevice(mkEnumBitfield(AudioDevice::IN_BUILTIN_MIC));
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000475#else
476 DeviceAddress device{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC)};
477 Return<Result> ret = effect->setInputDevice(device);
478#endif
Kevin Rocard55b10612018-11-12 12:33:16 -0800479 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700480}
481
nelsonli3c12e582019-12-12 13:53:49 +0800482TEST_P(AudioEffectHidlTest, SetAudioSource) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800483 description("Verify that SetAudioSource does not crash");
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000484#if MAJOR_VERSION <= 6
Kevin Rocard55b10612018-11-12 12:33:16 -0800485 Return<Result> ret = effect->setAudioSource(AudioSource::MIC);
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000486#else
487 Return<Result> ret = effect->setAudioSource(toString(xsd::AudioSource::AUDIO_SOURCE_MIC));
488#endif
Kevin Rocard55b10612018-11-12 12:33:16 -0800489 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700490}
491
nelsonli3c12e582019-12-12 13:53:49 +0800492TEST_P(AudioEffectHidlTest, Offload) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800493 description("Verify that calling Offload method does not crash");
Mikhail Naganovd72a7c22020-08-14 00:16:09 +0000494 Return<Result> ret = effect->offload(EffectOffloadParameter{});
Kevin Rocard55b10612018-11-12 12:33:16 -0800495 EXPECT_TRUE(ret.isOk());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800496}
497
nelsonli3c12e582019-12-12 13:53:49 +0800498TEST_P(AudioEffectHidlTest, PrepareForProcessing) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800499 description("Verify that PrepareForProcessing method works for an effect");
500 Result retval = Result::NOT_INITIALIZED;
501 Return<void> ret = effect->prepareForProcessing(
502 [&](Result r, const MQDescriptorSync<Result>&) { retval = r; });
503 EXPECT_TRUE(ret.isOk());
504 EXPECT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800505}
506
nelsonli3c12e582019-12-12 13:53:49 +0800507TEST_P(AudioEffectHidlTest, SetProcessBuffers) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800508 description("Verify that SetProcessBuffers works for an effect");
509 sp<IAllocator> ashmem = IAllocator::getService("ashmem");
510 ASSERT_NE(nullptr, ashmem.get());
511 bool success = false;
512 AudioBuffer buffer;
513 Return<void> ret = ashmem->allocate(1024, [&](bool s, const hidl_memory& memory) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800514 success = s;
515 if (s) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800516 buffer.data = memory;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800517 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800518 });
519 ASSERT_TRUE(ret.isOk());
520 ASSERT_TRUE(success);
521 Return<Result> ret2 = effect->setProcessBuffers(buffer, buffer);
522 EXPECT_TRUE(ret2.isOk());
523 EXPECT_EQ(Result::OK, ret2);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800524}
525
nelsonli3c12e582019-12-12 13:53:49 +0800526TEST_P(AudioEffectHidlTest, Command) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800527 description("Verify that Command does not crash");
528 Return<void> ret =
529 effect->command(0, hidl_vec<uint8_t>(), 0, [&](int32_t, const hidl_vec<uint8_t>&) {});
530 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700531}
Mikhail Naganov9f289042017-02-23 08:39:36 -0800532
nelsonli3c12e582019-12-12 13:53:49 +0800533TEST_P(AudioEffectHidlTest, SetParameter) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800534 description("Verify that SetParameter does not crash");
535 Return<Result> ret = effect->setParameter(hidl_vec<uint8_t>(), hidl_vec<uint8_t>());
536 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700537}
538
nelsonli3c12e582019-12-12 13:53:49 +0800539TEST_P(AudioEffectHidlTest, GetParameter) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800540 description("Verify that GetParameter does not crash");
541 Return<void> ret =
542 effect->getParameter(hidl_vec<uint8_t>(), 0, [&](Result, const hidl_vec<uint8_t>&) {});
543 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700544}
545
nelsonli3c12e582019-12-12 13:53:49 +0800546TEST_P(AudioEffectHidlTest, GetSupportedConfigsForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800547 description("Verify that GetSupportedConfigsForFeature does not crash");
548 Return<void> ret = effect->getSupportedConfigsForFeature(
549 0, 0, 0, [&](Result, uint32_t, const hidl_vec<uint8_t>&) {});
550 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700551}
552
nelsonli3c12e582019-12-12 13:53:49 +0800553TEST_P(AudioEffectHidlTest, GetCurrentConfigForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800554 description("Verify that GetCurrentConfigForFeature does not crash");
555 Return<void> ret =
556 effect->getCurrentConfigForFeature(0, 0, [&](Result, const hidl_vec<uint8_t>&) {});
557 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700558}
559
nelsonli3c12e582019-12-12 13:53:49 +0800560TEST_P(AudioEffectHidlTest, SetCurrentConfigForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800561 description("Verify that SetCurrentConfigForFeature does not crash");
562 Return<Result> ret = effect->setCurrentConfigForFeature(0, hidl_vec<uint8_t>());
563 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700564}
565
Mikhail Naganov9f289042017-02-23 08:39:36 -0800566// The main test class for Equalizer Audio Effect HIDL HAL.
567class EqualizerAudioEffectHidlTest : public AudioEffectHidlTest {
Mikhail Naganov892d1472020-03-19 10:44:06 -0700568 public:
Kevin Rocard55b10612018-11-12 12:33:16 -0800569 void SetUp() override {
570 AudioEffectHidlTest::SetUp();
571 equalizer = IEqualizerEffect::castFrom(effect);
572 ASSERT_NE(nullptr, equalizer.get());
573 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800574
Mikhail Naganov892d1472020-03-19 10:44:06 -0700575 void TearDown() override {
576 equalizer.clear();
577 AudioEffectHidlTest::TearDown();
578 }
579
580 protected:
Kevin Rocard55b10612018-11-12 12:33:16 -0800581 void getNumBands(uint16_t* numBands);
582 void getLevelRange(int16_t* minLevel, int16_t* maxLevel);
583 void getBandFrequencyRange(uint16_t band, uint32_t* minFreq, uint32_t* centerFreq,
584 uint32_t* maxFreq);
585 void getPresetCount(size_t* count);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800586
Kevin Rocard55b10612018-11-12 12:33:16 -0800587 sp<IEqualizerEffect> equalizer;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800588};
589
590void EqualizerAudioEffectHidlTest::getNumBands(uint16_t* numBands) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800591 Result retval = Result::NOT_INITIALIZED;
592 Return<void> ret = equalizer->getNumBands([&](Result r, uint16_t b) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800593 retval = r;
594 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800595 *numBands = b;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800596 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800597 });
598 ASSERT_TRUE(ret.isOk());
599 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800600}
601
Kevin Rocard55b10612018-11-12 12:33:16 -0800602void EqualizerAudioEffectHidlTest::getLevelRange(int16_t* minLevel, int16_t* maxLevel) {
603 Result retval = Result::NOT_INITIALIZED;
604 Return<void> ret = equalizer->getLevelRange([&](Result r, int16_t min, int16_t max) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800605 retval = r;
606 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800607 *minLevel = min;
608 *maxLevel = max;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800609 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800610 });
611 ASSERT_TRUE(ret.isOk());
612 ASSERT_EQ(Result::OK, retval);
613}
614
615void EqualizerAudioEffectHidlTest::getBandFrequencyRange(uint16_t band, uint32_t* minFreq,
616 uint32_t* centerFreq, uint32_t* maxFreq) {
617 Result retval = Result::NOT_INITIALIZED;
618 Return<void> ret =
619 equalizer->getBandFrequencyRange(band, [&](Result r, uint32_t min, uint32_t max) {
620 retval = r;
621 if (retval == Result::OK) {
622 *minFreq = min;
623 *maxFreq = max;
624 }
625 });
626 ASSERT_TRUE(ret.isOk());
627 ASSERT_EQ(Result::OK, retval);
628 ret = equalizer->getBandCenterFrequency(band, [&](Result r, uint32_t center) {
629 retval = r;
630 if (retval == Result::OK) {
631 *centerFreq = center;
632 }
633 });
634 ASSERT_TRUE(ret.isOk());
635 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800636}
637
638void EqualizerAudioEffectHidlTest::getPresetCount(size_t* count) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800639 Result retval = Result::NOT_INITIALIZED;
640 Return<void> ret = equalizer->getPresetNames([&](Result r, const hidl_vec<hidl_string>& names) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800641 retval = r;
642 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800643 *count = names.size();
Mikhail Naganov9f289042017-02-23 08:39:36 -0800644 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800645 });
646 ASSERT_TRUE(ret.isOk());
647 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800648}
649
nelsonli3c12e582019-12-12 13:53:49 +0800650TEST_P(EqualizerAudioEffectHidlTest, GetNumBands) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800651 description("Verify that Equalizer effect reports at least one band");
652 uint16_t numBands = 0;
653 getNumBands(&numBands);
654 EXPECT_GT(numBands, 0);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800655}
656
nelsonli3c12e582019-12-12 13:53:49 +0800657TEST_P(EqualizerAudioEffectHidlTest, GetLevelRange) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800658 description("Verify that Equalizer effect reports adequate band level range");
659 int16_t minLevel = 0x7fff, maxLevel = 0;
660 getLevelRange(&minLevel, &maxLevel);
661 EXPECT_GT(maxLevel, minLevel);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800662}
663
nelsonli3c12e582019-12-12 13:53:49 +0800664TEST_P(EqualizerAudioEffectHidlTest, GetSetBandLevel) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800665 description("Verify that manipulating band levels works for Equalizer effect");
666 uint16_t numBands = 0;
667 getNumBands(&numBands);
668 ASSERT_GT(numBands, 0);
669 int16_t levels[3]{0x7fff, 0, 0};
670 getLevelRange(&levels[0], &levels[2]);
671 ASSERT_GT(levels[2], levels[0]);
672 levels[1] = (levels[2] + levels[0]) / 2;
673 for (uint16_t i = 0; i < numBands; ++i) {
674 for (size_t j = 0; j < ARRAY_SIZE(levels); ++j) {
675 Return<Result> ret = equalizer->setBandLevel(i, levels[j]);
676 EXPECT_TRUE(ret.isOk());
677 EXPECT_EQ(Result::OK, ret);
678 Result retval = Result::NOT_INITIALIZED;
679 int16_t actualLevel;
680 Return<void> ret2 = equalizer->getBandLevel(i, [&](Result r, int16_t l) {
681 retval = r;
682 if (retval == Result::OK) {
683 actualLevel = l;
684 }
685 });
686 EXPECT_TRUE(ret2.isOk());
687 EXPECT_EQ(Result::OK, retval);
688 EXPECT_EQ(levels[j], actualLevel);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800689 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800690 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800691}
692
nelsonli3c12e582019-12-12 13:53:49 +0800693TEST_P(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800694 description("Verify that Equalizer effect reports adequate band frequency range");
695 uint16_t numBands = 0;
696 getNumBands(&numBands);
697 ASSERT_GT(numBands, 0);
698 for (uint16_t i = 0; i < numBands; ++i) {
699 uint32_t minFreq = 0xffffffff, centerFreq = 0xffffffff, maxFreq = 0xffffffff;
700 getBandFrequencyRange(i, &minFreq, &centerFreq, &maxFreq);
701 // Note: NXP legacy implementation reports "1" as upper bound for last band,
702 // so this check fails.
703 EXPECT_GE(maxFreq, centerFreq);
704 EXPECT_GE(centerFreq, minFreq);
705 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800706}
707
nelsonli3c12e582019-12-12 13:53:49 +0800708TEST_P(EqualizerAudioEffectHidlTest, GetBandForFrequency) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800709 description("Verify that Equalizer effect supports GetBandForFrequency correctly");
710 uint16_t numBands = 0;
711 getNumBands(&numBands);
712 ASSERT_GT(numBands, 0);
713 for (uint16_t i = 0; i < numBands; ++i) {
714 uint32_t freqs[3]{0, 0, 0};
715 getBandFrequencyRange(i, &freqs[0], &freqs[1], &freqs[2]);
716 // NXP legacy implementation reports "1" as upper bound for last band, some
717 // of the checks fail.
718 for (size_t j = 0; j < ARRAY_SIZE(freqs); ++j) {
719 if (j == 0) {
720 freqs[j]++;
721 } // Min frequency is an open interval.
722 Result retval = Result::NOT_INITIALIZED;
723 uint16_t actualBand = numBands + 1;
724 Return<void> ret = equalizer->getBandForFrequency(freqs[j], [&](Result r, uint16_t b) {
725 retval = r;
726 if (retval == Result::OK) {
727 actualBand = b;
728 }
729 });
730 EXPECT_TRUE(ret.isOk());
731 EXPECT_EQ(Result::OK, retval);
732 EXPECT_EQ(i, actualBand) << "Frequency: " << freqs[j];
733 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800734 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800735}
736
nelsonli3c12e582019-12-12 13:53:49 +0800737TEST_P(EqualizerAudioEffectHidlTest, GetPresetNames) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800738 description("Verify that Equalizer effect reports at least one preset");
739 size_t presetCount;
740 getPresetCount(&presetCount);
741 EXPECT_GT(presetCount, 0u);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800742}
743
nelsonli3c12e582019-12-12 13:53:49 +0800744TEST_P(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800745 description("Verify that manipulating the current preset for Equalizer effect");
746 size_t presetCount;
747 getPresetCount(&presetCount);
748 ASSERT_GT(presetCount, 0u);
749 for (uint16_t i = 0; i < presetCount; ++i) {
750 Return<Result> ret = equalizer->setCurrentPreset(i);
751 EXPECT_TRUE(ret.isOk());
752 EXPECT_EQ(Result::OK, ret);
753 Result retval = Result::NOT_INITIALIZED;
754 uint16_t actualPreset = 0xffff;
755 Return<void> ret2 = equalizer->getCurrentPreset([&](Result r, uint16_t p) {
756 retval = r;
757 if (retval == Result::OK) {
758 actualPreset = p;
759 }
760 });
761 EXPECT_TRUE(ret2.isOk());
762 EXPECT_EQ(Result::OK, retval);
763 EXPECT_EQ(i, actualPreset);
764 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800765}
766
nelsonli3c12e582019-12-12 13:53:49 +0800767TEST_P(EqualizerAudioEffectHidlTest, GetSetAllProperties) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800768 description(
769 "Verify that setting band levels and presets works via Get / "
770 "SetAllProperties for Equalizer effect");
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800771 using AllProperties =
Mikhail Naganov00a44c02018-12-14 14:31:45 -0800772 ::android::hardware::audio::effect::CPP_VERSION::IEqualizerEffect::AllProperties;
Kevin Rocard55b10612018-11-12 12:33:16 -0800773 uint16_t numBands = 0;
774 getNumBands(&numBands);
775 ASSERT_GT(numBands, 0);
776 AllProperties props;
777 props.bandLevels.resize(numBands);
778 for (size_t i = 0; i < numBands; ++i) {
779 props.bandLevels[i] = 0;
780 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800781
Kevin Rocard55b10612018-11-12 12:33:16 -0800782 AllProperties actualProps;
783 Result retval = Result::NOT_INITIALIZED;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800784
Kevin Rocard55b10612018-11-12 12:33:16 -0800785 // Verify setting of the band levels via properties.
786 props.curPreset = -1;
787 Return<Result> ret = equalizer->setAllProperties(props);
788 EXPECT_TRUE(ret.isOk());
789 EXPECT_EQ(Result::OK, ret);
790 Return<void> ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800791 retval = r;
792 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800793 actualProps = p;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800794 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800795 });
796 EXPECT_TRUE(ret2.isOk());
797 EXPECT_EQ(Result::OK, retval);
798 EXPECT_EQ(props.bandLevels, actualProps.bandLevels);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800799
Kevin Rocard55b10612018-11-12 12:33:16 -0800800 // Verify setting of the current preset via properties.
801 props.curPreset = 0; // Assuming there is at least one preset.
802 ret = equalizer->setAllProperties(props);
803 EXPECT_TRUE(ret.isOk());
804 EXPECT_EQ(Result::OK, ret);
805 ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) {
806 retval = r;
807 if (retval == Result::OK) {
808 actualProps = p;
809 }
810 });
811 EXPECT_TRUE(ret2.isOk());
812 EXPECT_EQ(Result::OK, retval);
813 EXPECT_EQ(props.curPreset, actualProps.curPreset);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800814}
815
816// The main test class for Equalizer Audio Effect HIDL HAL.
817class LoudnessEnhancerAudioEffectHidlTest : public AudioEffectHidlTest {
Mikhail Naganov892d1472020-03-19 10:44:06 -0700818 public:
Kevin Rocard55b10612018-11-12 12:33:16 -0800819 void SetUp() override {
820 AudioEffectHidlTest::SetUp();
821 enhancer = ILoudnessEnhancerEffect::castFrom(effect);
822 ASSERT_NE(nullptr, enhancer.get());
823 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800824
Mikhail Naganov892d1472020-03-19 10:44:06 -0700825 void TearDown() override {
826 enhancer.clear();
827 AudioEffectHidlTest::TearDown();
828 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800829
Mikhail Naganov892d1472020-03-19 10:44:06 -0700830 protected:
Kevin Rocard55b10612018-11-12 12:33:16 -0800831 sp<ILoudnessEnhancerEffect> enhancer;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800832};
833
nelsonli3c12e582019-12-12 13:53:49 +0800834TEST_P(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800835 description(
836 "Verify that manipulating the target gain works for Loudness Enhancer "
837 "effect");
838 const int32_t gain = 100;
839 Return<Result> ret = enhancer->setTargetGain(gain);
840 EXPECT_TRUE(ret.isOk());
841 EXPECT_EQ(Result::OK, ret);
842 int32_t actualGain = 0;
843 Result retval;
844 Return<void> ret2 = enhancer->getTargetGain([&](Result r, int32_t g) {
845 retval = r;
846 if (retval == Result::OK) {
847 actualGain = g;
848 }
849 });
850 EXPECT_TRUE(ret2.isOk());
851 EXPECT_EQ(Result::OK, retval);
852 EXPECT_EQ(gain, actualGain);
Mikhail Naganovbf393172016-11-11 16:24:50 -0800853}
Zhuoyao Zhang7dc6ce82018-02-08 12:44:27 -0800854
Mikhail Naganov892d1472020-03-19 10:44:06 -0700855INSTANTIATE_TEST_SUITE_P(EffectsFactory, AudioEffectsFactoryHidlTest,
856 ::testing::ValuesIn(::android::hardware::getAllHalInstanceNames(
857 IEffectsFactory::descriptor)),
858 ::android::hardware::PrintInstanceNameToString);
Mikhail Naganov315ce412019-10-23 16:46:54 -0700859INSTANTIATE_TEST_SUITE_P(
Mikhail Naganov892d1472020-03-19 10:44:06 -0700860 Equalizer_IEffect, AudioEffectHidlTest,
861 ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames(
862 IEffectsFactory::descriptor)),
863 ::testing::Values(EQUALIZER_EFFECT_TYPE)),
864 EffectParameterToString);
Mikhail Naganov315ce412019-10-23 16:46:54 -0700865INSTANTIATE_TEST_SUITE_P(
Mikhail Naganov892d1472020-03-19 10:44:06 -0700866 LoudnessEnhancer_IEffect, AudioEffectHidlTest,
867 ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames(
868 IEffectsFactory::descriptor)),
869 ::testing::Values(LOUDNESS_ENHANCER_EFFECT_TYPE)),
870 EffectParameterToString);
nelsonli3c12e582019-12-12 13:53:49 +0800871INSTANTIATE_TEST_SUITE_P(
Mikhail Naganov315ce412019-10-23 16:46:54 -0700872 Equalizer, EqualizerAudioEffectHidlTest,
Mikhail Naganov892d1472020-03-19 10:44:06 -0700873 ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames(
874 IEffectsFactory::descriptor)),
875 ::testing::Values(EQUALIZER_EFFECT_TYPE)),
876 EffectParameterToString);
Mikhail Naganov315ce412019-10-23 16:46:54 -0700877INSTANTIATE_TEST_SUITE_P(
878 LoudnessEnhancer, LoudnessEnhancerAudioEffectHidlTest,
Mikhail Naganov892d1472020-03-19 10:44:06 -0700879 ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames(
880 IEffectsFactory::descriptor)),
881 ::testing::Values(LOUDNESS_ENHANCER_EFFECT_TYPE)),
882 EffectParameterToString);
Mikhail Naganovb9743d42020-07-21 10:57:03 -0700883// When the VTS test runs on a device lacking the corresponding HAL version the parameter
884// list is empty, this isn't a problem.
885GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AudioEffectsFactoryHidlTest);
886GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AudioEffectHidlTest);
887GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EqualizerAudioEffectHidlTest);
888GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(LoudnessEnhancerAudioEffectHidlTest);