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