VtsHalAudioEffectV2_0TargetTest.cpp revision 05fa0d0312e8702b90944c522a95f98d67044bc2
1/* 2 * Copyright (C) 2017 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 "AudioEffectHidlHalTest" 18#include <android-base/logging.h> 19#include <system/audio.h> 20 21#include <android/hardware/audio/effect/2.0/IEffect.h> 22#include <android/hardware/audio/effect/2.0/IEffectsFactory.h> 23#include <android/hardware/audio/effect/2.0/IEqualizerEffect.h> 24#include <android/hardware/audio/effect/2.0/ILoudnessEnhancerEffect.h> 25#include <android/hardware/audio/effect/2.0/types.h> 26#include <android/hidl/allocator/1.0/IAllocator.h> 27#include <android/hidl/memory/1.0/IMemory.h> 28 29#include <VtsHalHidlTargetTestBase.h> 30 31using android::hardware::audio::common::V2_0::AudioDevice; 32using android::hardware::audio::common::V2_0::AudioHandleConsts; 33using android::hardware::audio::common::V2_0::AudioMode; 34using android::hardware::audio::common::V2_0::AudioSource; 35using android::hardware::audio::common::V2_0::Uuid; 36using android::hardware::audio::effect::V2_0::AudioBuffer; 37using android::hardware::audio::effect::V2_0::EffectAuxChannelsConfig; 38using android::hardware::audio::effect::V2_0::EffectBufferConfig; 39using android::hardware::audio::effect::V2_0::EffectConfig; 40using android::hardware::audio::effect::V2_0::EffectDescriptor; 41using android::hardware::audio::effect::V2_0::EffectOffloadParameter; 42using android::hardware::audio::effect::V2_0::IEffect; 43using android::hardware::audio::effect::V2_0::IEffectsFactory; 44using android::hardware::audio::effect::V2_0::IEqualizerEffect; 45using android::hardware::audio::effect::V2_0::ILoudnessEnhancerEffect; 46using android::hardware::audio::effect::V2_0::Result; 47using android::hardware::MQDescriptorSync; 48using android::hardware::Return; 49using android::hardware::Void; 50using android::hardware::hidl_memory; 51using android::hardware::hidl_string; 52using android::hardware::hidl_vec; 53using android::hidl::allocator::V1_0::IAllocator; 54using android::hidl::memory::V1_0::IMemory; 55using android::sp; 56 57#ifndef ARRAY_SIZE 58#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a))) 59#endif 60 61// The main test class for Audio Effects Factory HIDL HAL. 62class AudioEffectsFactoryHidlTest : public ::testing::VtsHalHidlTargetTestBase { 63 public: 64 void SetUp() override { 65 effectsFactory = 66 ::testing::VtsHalHidlTargetTestBase::getService<IEffectsFactory>(); 67 ASSERT_NE(effectsFactory, nullptr); 68 } 69 70 void TearDown() override { effectsFactory.clear(); } 71 72 protected: 73 static void description(const std::string& description) { 74 RecordProperty("description", description); 75 } 76 77 sp<IEffectsFactory> effectsFactory; 78}; 79 80TEST_F(AudioEffectsFactoryHidlTest, EnumerateEffects) { 81 description("Verify that EnumerateEffects returns at least one effect"); 82 Result retval = Result::NOT_INITIALIZED; 83 size_t effectCount = 0; 84 Return<void> ret = effectsFactory->getAllDescriptors( 85 [&](Result r, const hidl_vec<EffectDescriptor>& result) { 86 retval = r; 87 effectCount = result.size(); 88 }); 89 EXPECT_TRUE(ret.isOk()); 90 EXPECT_EQ(Result::OK, retval); 91 EXPECT_GT(effectCount, 0u); 92} 93 94TEST_F(AudioEffectsFactoryHidlTest, CreateEffect) { 95 description("Verify that an effect can be created via CreateEffect"); 96 bool gotEffect = false; 97 Uuid effectUuid; 98 Return<void> ret = effectsFactory->getAllDescriptors( 99 [&](Result r, const hidl_vec<EffectDescriptor>& result) { 100 if (r == Result::OK && result.size() > 0) { 101 gotEffect = true; 102 effectUuid = result[0].uuid; 103 } 104 }); 105 ASSERT_TRUE(ret.isOk()); 106 ASSERT_TRUE(gotEffect); 107 Result retval = Result::NOT_INITIALIZED; 108 sp<IEffect> effect; 109 ret = effectsFactory->createEffect( 110 effectUuid, 1 /*session*/, 1 /*ioHandle*/, 111 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) { 112 retval = r; 113 if (r == Result::OK) { 114 effect = result; 115 } 116 }); 117 EXPECT_TRUE(ret.isOk()); 118 EXPECT_EQ(Result::OK, retval); 119 EXPECT_NE(nullptr, effect.get()); 120} 121 122TEST_F(AudioEffectsFactoryHidlTest, GetDescriptor) { 123 description( 124 "Verify that effects factory can provide an effect descriptor via " 125 "GetDescriptor"); 126 hidl_vec<EffectDescriptor> allDescriptors; 127 Return<void> ret = effectsFactory->getAllDescriptors( 128 [&](Result r, const hidl_vec<EffectDescriptor>& result) { 129 if (r == Result::OK) { 130 allDescriptors = result; 131 } 132 }); 133 ASSERT_TRUE(ret.isOk()); 134 ASSERT_GT(allDescriptors.size(), 0u); 135 for (size_t i = 0; i < allDescriptors.size(); ++i) { 136 ret = effectsFactory->getDescriptor( 137 allDescriptors[i].uuid, [&](Result r, const EffectDescriptor& result) { 138 EXPECT_EQ(r, Result::OK); 139 EXPECT_EQ(result, allDescriptors[i]); 140 }); 141 } 142 EXPECT_TRUE(ret.isOk()); 143} 144 145// Equalizer effect is required by CDD, but only the type is fixed. 146// This is the same UUID as AudioEffect.EFFECT_TYPE_EQUALIZER in Java. 147static const Uuid EQUALIZER_EFFECT_TYPE = { 148 0x0bed4300, 0xddd6, 0x11db, 0x8f34, 149 std::array<uint8_t, 6>{{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}}; 150// Loudness Enhancer effect is required by CDD, but only the type is fixed. 151// This is the same UUID as AudioEffect.EFFECT_TYPE_LOUDNESS_ENHANCER in Java. 152static const Uuid LOUDNESS_ENHANCER_EFFECT_TYPE = { 153 0xfe3199be, 0xaed0, 0x413f, 0x87bb, 154 std::array<uint8_t, 6>{{0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}}}; 155 156// The main test class for Audio Effect HIDL HAL. 157class AudioEffectHidlTest : public ::testing::VtsHalHidlTargetTestBase { 158 public: 159 void SetUp() override { 160 effectsFactory = 161 ::testing::VtsHalHidlTargetTestBase::getService<IEffectsFactory>(); 162 ASSERT_NE(nullptr, effectsFactory.get()); 163 164 findAndCreateEffect(getEffectType()); 165 ASSERT_NE(nullptr, effect.get()); 166 167 Return<Result> ret = effect->init(); 168 ASSERT_TRUE(ret.isOk()); 169 ASSERT_EQ(Result::OK, ret); 170 } 171 172 void TearDown() override { 173 effect.clear(); 174 effectsFactory.clear(); 175 } 176 177 protected: 178 static void description(const std::string& description) { 179 RecordProperty("description", description); 180 } 181 182 virtual Uuid getEffectType() { return EQUALIZER_EFFECT_TYPE; } 183 184 void findAndCreateEffect(const Uuid& type); 185 void findEffectInstance(const Uuid& type, Uuid* uuid); 186 void getChannelCount(uint32_t* channelCount); 187 188 sp<IEffectsFactory> effectsFactory; 189 sp<IEffect> effect; 190}; 191 192void AudioEffectHidlTest::findAndCreateEffect(const Uuid& type) { 193 Uuid effectUuid; 194 findEffectInstance(type, &effectUuid); 195 Return<void> ret = effectsFactory->createEffect( 196 effectUuid, 1 /*session*/, 1 /*ioHandle*/, 197 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) { 198 if (r == Result::OK) { 199 effect = result; 200 } 201 }); 202 ASSERT_TRUE(ret.isOk()); 203} 204 205void AudioEffectHidlTest::findEffectInstance(const Uuid& type, Uuid* uuid) { 206 bool effectFound = false; 207 Return<void> ret = effectsFactory->getAllDescriptors( 208 [&](Result r, const hidl_vec<EffectDescriptor>& result) { 209 if (r == Result::OK) { 210 for (const auto& desc : result) { 211 if (desc.type == type) { 212 effectFound = true; 213 *uuid = desc.uuid; 214 break; 215 } 216 } 217 } 218 }); 219 ASSERT_TRUE(ret.isOk()); 220 ASSERT_TRUE(effectFound); 221} 222 223void AudioEffectHidlTest::getChannelCount(uint32_t* channelCount) { 224 Result retval; 225 EffectConfig currentConfig; 226 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { 227 retval = r; 228 if (r == Result::OK) { 229 currentConfig = conf; 230 } 231 }); 232 ASSERT_TRUE(ret.isOk()); 233 ASSERT_EQ(Result::OK, retval); 234 ASSERT_TRUE(audio_channel_mask_is_valid( 235 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels))); 236 *channelCount = audio_channel_count_from_out_mask( 237 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels)); 238} 239 240TEST_F(AudioEffectHidlTest, Close) { 241 description("Verify that an effect can be closed"); 242 Return<Result> ret = effect->close(); 243 EXPECT_TRUE(ret.isOk()); 244 EXPECT_EQ(Result::OK, ret); 245} 246 247TEST_F(AudioEffectHidlTest, GetDescriptor) { 248 description( 249 "Verify that an effect can return its own descriptor via GetDescriptor"); 250 Result retval = Result::NOT_INITIALIZED; 251 Uuid actualType; 252 Return<void> ret = 253 effect->getDescriptor([&](Result r, const EffectDescriptor& desc) { 254 retval = r; 255 if (r == Result::OK) { 256 actualType = desc.type; 257 } 258 }); 259 EXPECT_TRUE(ret.isOk()); 260 EXPECT_EQ(Result::OK, retval); 261 EXPECT_EQ(getEffectType(), actualType); 262} 263 264TEST_F(AudioEffectHidlTest, GetSetConfig) { 265 description( 266 "Verify that it is possible to manipulate effect config via Get / " 267 "SetConfig"); 268 Result retval = Result::NOT_INITIALIZED; 269 EffectConfig currentConfig; 270 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { 271 retval = r; 272 if (r == Result::OK) { 273 currentConfig = conf; 274 } 275 }); 276 EXPECT_TRUE(ret.isOk()); 277 EXPECT_EQ(Result::OK, retval); 278 Return<Result> ret2 = effect->setConfig(currentConfig, nullptr, nullptr); 279 EXPECT_TRUE(ret2.isOk()); 280 EXPECT_EQ(Result::OK, ret2); 281} 282 283TEST_F(AudioEffectHidlTest, GetConfigReverse) { 284 description("Verify that GetConfigReverse does not crash"); 285 Return<void> ret = 286 effect->getConfigReverse([&](Result, const EffectConfig&) {}); 287 EXPECT_TRUE(ret.isOk()); 288} 289 290TEST_F(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) { 291 description("Verify that GetSupportedAuxChannelsConfigs does not crash"); 292 Return<void> ret = effect->getSupportedAuxChannelsConfigs( 293 0, [&](Result, const hidl_vec<EffectAuxChannelsConfig>&) {}); 294 EXPECT_TRUE(ret.isOk()); 295} 296 297TEST_F(AudioEffectHidlTest, GetAuxChannelsConfig) { 298 description("Verify that GetAuxChannelsConfig does not crash"); 299 Return<void> ret = effect->getAuxChannelsConfig( 300 [&](Result, const EffectAuxChannelsConfig&) {}); 301 EXPECT_TRUE(ret.isOk()); 302} 303 304TEST_F(AudioEffectHidlTest, SetAuxChannelsConfig) { 305 description("Verify that SetAuxChannelsConfig does not crash"); 306 Return<Result> ret = effect->setAuxChannelsConfig(EffectAuxChannelsConfig()); 307 EXPECT_TRUE(ret.isOk()); 308} 309 310// Not generated automatically because AudioBuffer contains 311// instances of hidl_memory which can't be compared properly 312// in general case due to presence of handles. 313// 314// However, in this particular case, handles must not present 315// thus comparison is possible. 316// 317// operator== must be defined in the same namespace as the structures. 318namespace android { 319namespace hardware { 320namespace audio { 321namespace effect { 322namespace V2_0 { 323inline bool operator==(const AudioBuffer& lhs, const AudioBuffer& rhs) { 324 return lhs.id == rhs.id && lhs.frameCount == rhs.frameCount && 325 lhs.data.handle() == nullptr && rhs.data.handle() == nullptr; 326} 327 328inline bool operator==(const EffectBufferConfig& lhs, 329 const EffectBufferConfig& rhs) { 330 return lhs.buffer == rhs.buffer && lhs.samplingRateHz == rhs.samplingRateHz && 331 lhs.channels == rhs.channels && lhs.format == rhs.format && 332 lhs.accessMode == rhs.accessMode && lhs.mask == rhs.mask; 333} 334 335inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) { 336 return lhs.inputCfg == rhs.inputCfg && lhs.outputCfg == rhs.outputCfg; 337} 338} // namespace V2_0 339} // namespace effect 340} // namespace audio 341} // namespace hardware 342} // namespace android 343 344TEST_F(AudioEffectHidlTest, Reset) { 345 description("Verify that Reset preserves effect configuration"); 346 Result retval = Result::NOT_INITIALIZED; 347 EffectConfig originalConfig; 348 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { 349 retval = r; 350 if (r == Result::OK) { 351 originalConfig = conf; 352 } 353 }); 354 ASSERT_TRUE(ret.isOk()); 355 ASSERT_EQ(Result::OK, retval); 356 Return<Result> ret2 = effect->reset(); 357 EXPECT_TRUE(ret2.isOk()); 358 EXPECT_EQ(Result::OK, ret2); 359 EffectConfig configAfterReset; 360 ret = effect->getConfig([&](Result r, const EffectConfig& conf) { 361 retval = r; 362 if (r == Result::OK) { 363 configAfterReset = conf; 364 } 365 }); 366 EXPECT_EQ(originalConfig, configAfterReset); 367} 368 369TEST_F(AudioEffectHidlTest, DisableEnableDisable) { 370 description("Verify Disable -> Enable -> Disable sequence for an effect"); 371 Return<Result> ret = effect->disable(); 372 EXPECT_TRUE(ret.isOk()); 373 EXPECT_EQ(Result::INVALID_ARGUMENTS, ret); 374 ret = effect->enable(); 375 EXPECT_TRUE(ret.isOk()); 376 EXPECT_EQ(Result::OK, ret); 377 ret = effect->disable(); 378 EXPECT_TRUE(ret.isOk()); 379 EXPECT_EQ(Result::OK, ret); 380} 381 382TEST_F(AudioEffectHidlTest, SetDevice) { 383 description("Verify that SetDevice works for an output chain effect"); 384 Return<Result> ret = effect->setDevice(AudioDevice::OUT_SPEAKER); 385 EXPECT_TRUE(ret.isOk()); 386 EXPECT_EQ(Result::OK, ret); 387} 388 389TEST_F(AudioEffectHidlTest, SetAndGetVolume) { 390 description("Verify that SetAndGetVolume method works for an effect"); 391 uint32_t channelCount; 392 getChannelCount(&channelCount); 393 hidl_vec<uint32_t> volumes; 394 volumes.resize(channelCount); 395 for (uint32_t i = 0; i < channelCount; ++i) { 396 volumes[i] = 0; 397 } 398 Result retval = Result::NOT_INITIALIZED; 399 Return<void> ret = effect->setAndGetVolume( 400 volumes, [&](Result r, const hidl_vec<uint32_t>&) { retval = r; }); 401 EXPECT_TRUE(ret.isOk()); 402 EXPECT_EQ(Result::OK, retval); 403} 404 405TEST_F(AudioEffectHidlTest, VolumeChangeNotification) { 406 description("Verify that effect accepts VolumeChangeNotification"); 407 uint32_t channelCount; 408 getChannelCount(&channelCount); 409 hidl_vec<uint32_t> volumes; 410 volumes.resize(channelCount); 411 for (uint32_t i = 0; i < channelCount; ++i) { 412 volumes[i] = 0; 413 } 414 Return<Result> ret = effect->volumeChangeNotification(volumes); 415 EXPECT_TRUE(ret.isOk()); 416 EXPECT_EQ(Result::OK, ret); 417} 418 419TEST_F(AudioEffectHidlTest, SetAudioMode) { 420 description("Verify that SetAudioMode works for an effect"); 421 Return<Result> ret = effect->setAudioMode(AudioMode::NORMAL); 422 EXPECT_TRUE(ret.isOk()); 423 EXPECT_EQ(Result::OK, ret); 424} 425 426TEST_F(AudioEffectHidlTest, SetConfigReverse) { 427 description("Verify that SetConfigReverse does not crash"); 428 Return<Result> ret = 429 effect->setConfigReverse(EffectConfig(), nullptr, nullptr); 430 EXPECT_TRUE(ret.isOk()); 431} 432 433TEST_F(AudioEffectHidlTest, SetInputDevice) { 434 description("Verify that SetInputDevice does not crash"); 435 Return<Result> ret = effect->setInputDevice(AudioDevice::IN_BUILTIN_MIC); 436 EXPECT_TRUE(ret.isOk()); 437} 438 439TEST_F(AudioEffectHidlTest, SetAudioSource) { 440 description("Verify that SetAudioSource does not crash"); 441 Return<Result> ret = effect->setAudioSource(AudioSource::MIC); 442 EXPECT_TRUE(ret.isOk()); 443} 444 445TEST_F(AudioEffectHidlTest, Offload) { 446 description("Verify that calling Offload methods works for an effect"); 447 EffectOffloadParameter offloadParam; 448 offloadParam.isOffload = false; 449 offloadParam.ioHandle = 450 static_cast<int>(AudioHandleConsts::AUDIO_IO_HANDLE_NONE); 451 Return<Result> ret = effect->offload(offloadParam); 452 EXPECT_TRUE(ret.isOk()); 453 EXPECT_EQ(Result::OK, ret); 454} 455 456TEST_F(AudioEffectHidlTest, PrepareForProcessing) { 457 description("Verify that PrepareForProcessing method works for an effect"); 458 Result retval = Result::NOT_INITIALIZED; 459 Return<void> ret = effect->prepareForProcessing( 460 [&](Result r, const MQDescriptorSync<Result>&) { retval = r; }); 461 EXPECT_TRUE(ret.isOk()); 462 EXPECT_EQ(Result::OK, retval); 463} 464 465TEST_F(AudioEffectHidlTest, SetProcessBuffers) { 466 description("Verify that SetProcessBuffers works for an effect"); 467 sp<IAllocator> ashmem = IAllocator::getService("ashmem"); 468 ASSERT_NE(nullptr, ashmem.get()); 469 bool success = false; 470 AudioBuffer buffer; 471 Return<void> ret = 472 ashmem->allocate(1024, [&](bool s, const hidl_memory& memory) { 473 success = s; 474 if (s) { 475 buffer.data = memory; 476 } 477 }); 478 ASSERT_TRUE(ret.isOk()); 479 ASSERT_TRUE(success); 480 Return<Result> ret2 = effect->setProcessBuffers(buffer, buffer); 481 EXPECT_TRUE(ret2.isOk()); 482 EXPECT_EQ(Result::OK, ret2); 483} 484 485TEST_F(AudioEffectHidlTest, Command) { 486 description("Verify that Command does not crash"); 487 Return<void> ret = effect->command(0, hidl_vec<uint8_t>(), 0, 488 [&](int32_t, const hidl_vec<uint8_t>&) {}); 489 EXPECT_TRUE(ret.isOk()); 490} 491 492TEST_F(AudioEffectHidlTest, SetParameter) { 493 description("Verify that SetParameter does not crash"); 494 Return<Result> ret = 495 effect->setParameter(hidl_vec<uint8_t>(), hidl_vec<uint8_t>()); 496 EXPECT_TRUE(ret.isOk()); 497} 498 499TEST_F(AudioEffectHidlTest, GetParameter) { 500 description("Verify that GetParameter does not crash"); 501 Return<void> ret = effect->getParameter( 502 hidl_vec<uint8_t>(), 0, [&](Result, const hidl_vec<uint8_t>&) {}); 503 EXPECT_TRUE(ret.isOk()); 504} 505 506TEST_F(AudioEffectHidlTest, GetSupportedConfigsForFeature) { 507 description("Verify that GetSupportedConfigsForFeature does not crash"); 508 Return<void> ret = effect->getSupportedConfigsForFeature( 509 0, 0, 0, [&](Result, uint32_t, const hidl_vec<uint8_t>&) {}); 510 EXPECT_TRUE(ret.isOk()); 511} 512 513TEST_F(AudioEffectHidlTest, GetCurrentConfigForFeature) { 514 description("Verify that GetCurrentConfigForFeature does not crash"); 515 Return<void> ret = effect->getCurrentConfigForFeature( 516 0, 0, [&](Result, const hidl_vec<uint8_t>&) {}); 517 EXPECT_TRUE(ret.isOk()); 518} 519 520TEST_F(AudioEffectHidlTest, SetCurrentConfigForFeature) { 521 description("Verify that SetCurrentConfigForFeature does not crash"); 522 Return<Result> ret = 523 effect->setCurrentConfigForFeature(0, hidl_vec<uint8_t>()); 524 EXPECT_TRUE(ret.isOk()); 525} 526 527 528// The main test class for Equalizer Audio Effect HIDL HAL. 529class EqualizerAudioEffectHidlTest : public AudioEffectHidlTest { 530 public: 531 void SetUp() override { 532 AudioEffectHidlTest::SetUp(); 533 equalizer = IEqualizerEffect::castFrom(effect); 534 ASSERT_NE(nullptr, equalizer.get()); 535 } 536 537 protected: 538 Uuid getEffectType() override { return EQUALIZER_EFFECT_TYPE; } 539 void getNumBands(uint16_t* numBands); 540 void getLevelRange(int16_t* minLevel, int16_t* maxLevel); 541 void getBandFrequencyRange(uint16_t band, uint32_t* minFreq, 542 uint32_t* centerFreq, uint32_t* maxFreq); 543 void getPresetCount(size_t* count); 544 545 sp<IEqualizerEffect> equalizer; 546}; 547 548void EqualizerAudioEffectHidlTest::getNumBands(uint16_t* numBands) { 549 Result retval = Result::NOT_INITIALIZED; 550 Return<void> ret = equalizer->getNumBands([&](Result r, uint16_t b) { 551 retval = r; 552 if (retval == Result::OK) { 553 *numBands = b; 554 } 555 }); 556 ASSERT_TRUE(ret.isOk()); 557 ASSERT_EQ(Result::OK, retval); 558} 559 560void EqualizerAudioEffectHidlTest::getLevelRange(int16_t* minLevel, 561 int16_t* maxLevel) { 562 Result retval = Result::NOT_INITIALIZED; 563 Return<void> ret = 564 equalizer->getLevelRange([&](Result r, int16_t min, int16_t max) { 565 retval = r; 566 if (retval == Result::OK) { 567 *minLevel = min; 568 *maxLevel = max; 569 } 570 }); 571 ASSERT_TRUE(ret.isOk()); 572 ASSERT_EQ(Result::OK, retval); 573} 574 575void EqualizerAudioEffectHidlTest::getBandFrequencyRange(uint16_t band, 576 uint32_t* minFreq, 577 uint32_t* centerFreq, 578 uint32_t* maxFreq) { 579 Result retval = Result::NOT_INITIALIZED; 580 Return<void> ret = equalizer->getBandFrequencyRange( 581 band, [&](Result r, uint32_t min, uint32_t max) { 582 retval = r; 583 if (retval == Result::OK) { 584 *minFreq = min; 585 *maxFreq = max; 586 } 587 }); 588 ASSERT_TRUE(ret.isOk()); 589 ASSERT_EQ(Result::OK, retval); 590 ret = equalizer->getBandCenterFrequency(band, [&](Result r, uint32_t center) { 591 retval = r; 592 if (retval == Result::OK) { 593 *centerFreq = center; 594 } 595 }); 596 ASSERT_TRUE(ret.isOk()); 597 ASSERT_EQ(Result::OK, retval); 598} 599 600void EqualizerAudioEffectHidlTest::getPresetCount(size_t* count) { 601 Result retval = Result::NOT_INITIALIZED; 602 Return<void> ret = equalizer->getPresetNames( 603 [&](Result r, const hidl_vec<hidl_string>& names) { 604 retval = r; 605 if (retval == Result::OK) { 606 *count = names.size(); 607 } 608 }); 609 ASSERT_TRUE(ret.isOk()); 610 ASSERT_EQ(Result::OK, retval); 611} 612 613TEST_F(EqualizerAudioEffectHidlTest, GetNumBands) { 614 description("Verify that Equalizer effect reports at least one band"); 615 uint16_t numBands = 0; 616 getNumBands(&numBands); 617 EXPECT_GT(numBands, 0); 618} 619 620TEST_F(EqualizerAudioEffectHidlTest, GetLevelRange) { 621 description("Verify that Equalizer effect reports adequate band level range"); 622 int16_t minLevel = 0x7fff, maxLevel = 0; 623 getLevelRange(&minLevel, &maxLevel); 624 EXPECT_GT(maxLevel, minLevel); 625} 626 627TEST_F(EqualizerAudioEffectHidlTest, GetSetBandLevel) { 628 description( 629 "Verify that manipulating band levels works for Equalizer effect"); 630 uint16_t numBands = 0; 631 getNumBands(&numBands); 632 ASSERT_GT(numBands, 0); 633 int16_t levels[3]{0x7fff, 0, 0}; 634 getLevelRange(&levels[0], &levels[2]); 635 ASSERT_GT(levels[2], levels[0]); 636 levels[1] = (levels[2] + levels[0]) / 2; 637 for (uint16_t i = 0; i < numBands; ++i) { 638 for (size_t j = 0; j < ARRAY_SIZE(levels); ++j) { 639 Return<Result> ret = equalizer->setBandLevel(i, levels[j]); 640 EXPECT_TRUE(ret.isOk()); 641 EXPECT_EQ(Result::OK, ret); 642 Result retval = Result::NOT_INITIALIZED; 643 int16_t actualLevel; 644 Return<void> ret2 = equalizer->getBandLevel(i, [&](Result r, int16_t l) { 645 retval = r; 646 if (retval == Result::OK) { 647 actualLevel = l; 648 } 649 }); 650 EXPECT_TRUE(ret2.isOk()); 651 EXPECT_EQ(Result::OK, retval); 652 EXPECT_EQ(levels[j], actualLevel); 653 } 654 } 655} 656 657TEST_F(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) { 658 description( 659 "Verify that Equalizer effect reports adequate band frequency range"); 660 uint16_t numBands = 0; 661 getNumBands(&numBands); 662 ASSERT_GT(numBands, 0); 663 for (uint16_t i = 0; i < numBands; ++i) { 664 uint32_t minFreq = 0xffffffff, centerFreq = 0xffffffff, 665 maxFreq = 0xffffffff; 666 getBandFrequencyRange(i, &minFreq, ¢erFreq, &maxFreq); 667 // Note: NXP legacy implementation reports "1" as upper bound for last band, 668 // so this check fails. 669 EXPECT_GE(maxFreq, centerFreq); 670 EXPECT_GE(centerFreq, minFreq); 671 } 672} 673 674TEST_F(EqualizerAudioEffectHidlTest, GetBandForFrequency) { 675 description( 676 "Verify that Equalizer effect supports GetBandForFrequency correctly"); 677 uint16_t numBands = 0; 678 getNumBands(&numBands); 679 ASSERT_GT(numBands, 0); 680 for (uint16_t i = 0; i < numBands; ++i) { 681 uint32_t freqs[3]{0, 0, 0}; 682 getBandFrequencyRange(i, &freqs[0], &freqs[1], &freqs[2]); 683 // NXP legacy implementation reports "1" as upper bound for last band, some 684 // of the checks fail. 685 for (size_t j = 0; j < ARRAY_SIZE(freqs); ++j) { 686 if (j == 0) { 687 freqs[j]++; 688 } // Min frequency is an open interval. 689 Result retval = Result::NOT_INITIALIZED; 690 uint16_t actualBand = numBands + 1; 691 Return<void> ret = 692 equalizer->getBandForFrequency(freqs[j], [&](Result r, uint16_t b) { 693 retval = r; 694 if (retval == Result::OK) { 695 actualBand = b; 696 } 697 }); 698 EXPECT_TRUE(ret.isOk()); 699 EXPECT_EQ(Result::OK, retval); 700 EXPECT_EQ(i, actualBand) << "Frequency: " << freqs[j]; 701 } 702 } 703} 704 705TEST_F(EqualizerAudioEffectHidlTest, GetPresetNames) { 706 description("Verify that Equalizer effect reports at least one preset"); 707 size_t presetCount; 708 getPresetCount(&presetCount); 709 EXPECT_GT(presetCount, 0u); 710} 711 712TEST_F(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) { 713 description( 714 "Verify that manipulating the current preset for Equalizer effect"); 715 size_t presetCount; 716 getPresetCount(&presetCount); 717 ASSERT_GT(presetCount, 0u); 718 for (uint16_t i = 0; i < presetCount; ++i) { 719 Return<Result> ret = equalizer->setCurrentPreset(i); 720 EXPECT_TRUE(ret.isOk()); 721 EXPECT_EQ(Result::OK, ret); 722 Result retval = Result::NOT_INITIALIZED; 723 uint16_t actualPreset = 0xffff; 724 Return<void> ret2 = equalizer->getCurrentPreset([&](Result r, uint16_t p) { 725 retval = r; 726 if (retval == Result::OK) { 727 actualPreset = p; 728 } 729 }); 730 EXPECT_TRUE(ret2.isOk()); 731 EXPECT_EQ(Result::OK, retval); 732 EXPECT_EQ(i, actualPreset); 733 } 734} 735 736TEST_F(EqualizerAudioEffectHidlTest, GetSetAllProperties) { 737 description( 738 "Verify that setting band levels and presets works via Get / " 739 "SetAllProperties for Equalizer effect"); 740 using AllProperties = 741 android::hardware::audio::effect::V2_0::IEqualizerEffect::AllProperties; 742 uint16_t numBands = 0; 743 getNumBands(&numBands); 744 ASSERT_GT(numBands, 0); 745 AllProperties props; 746 props.bandLevels.resize(numBands); 747 for (size_t i = 0; i < numBands; ++i) { 748 props.bandLevels[i] = 0; 749 } 750 751 AllProperties actualProps; 752 Result retval = Result::NOT_INITIALIZED; 753 754 // Verify setting of the band levels via properties. 755 props.curPreset = -1; 756 Return<Result> ret = equalizer->setAllProperties(props); 757 EXPECT_TRUE(ret.isOk()); 758 EXPECT_EQ(Result::OK, ret); 759 Return<void> ret2 = 760 equalizer->getAllProperties([&](Result r, AllProperties p) { 761 retval = r; 762 if (retval == Result::OK) { 763 actualProps = p; 764 } 765 }); 766 EXPECT_TRUE(ret2.isOk()); 767 EXPECT_EQ(Result::OK, retval); 768 EXPECT_EQ(props.bandLevels, actualProps.bandLevels); 769 770 // Verify setting of the current preset via properties. 771 props.curPreset = 0; // Assuming there is at least one preset. 772 ret = equalizer->setAllProperties(props); 773 EXPECT_TRUE(ret.isOk()); 774 EXPECT_EQ(Result::OK, ret); 775 ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) { 776 retval = r; 777 if (retval == Result::OK) { 778 actualProps = p; 779 } 780 }); 781 EXPECT_TRUE(ret2.isOk()); 782 EXPECT_EQ(Result::OK, retval); 783 EXPECT_EQ(props.curPreset, actualProps.curPreset); 784} 785 786// The main test class for Equalizer Audio Effect HIDL HAL. 787class LoudnessEnhancerAudioEffectHidlTest : public AudioEffectHidlTest { 788 public: 789 void SetUp() override { 790 AudioEffectHidlTest::SetUp(); 791 enhancer = ILoudnessEnhancerEffect::castFrom(effect); 792 ASSERT_NE(nullptr, enhancer.get()); 793 } 794 795 protected: 796 Uuid getEffectType() override { return LOUDNESS_ENHANCER_EFFECT_TYPE; } 797 798 sp<ILoudnessEnhancerEffect> enhancer; 799}; 800 801TEST_F(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) { 802 description( 803 "Verify that manipulating the target gain works for Loudness Enhancer " 804 "effect"); 805 const int32_t gain = 100; 806 Return<Result> ret = enhancer->setTargetGain(gain); 807 EXPECT_TRUE(ret.isOk()); 808 EXPECT_EQ(Result::OK, ret); 809 int32_t actualGain = 0; 810 Result retval; 811 Return<void> ret2 = enhancer->getTargetGain([&](Result r, int32_t g) { 812 retval = r; 813 if (retval == Result::OK) { 814 actualGain = g; 815 } 816 }); 817 EXPECT_TRUE(ret2.isOk()); 818 EXPECT_EQ(Result::OK, retval); 819 EXPECT_EQ(gain, actualGain); 820} 821