| /* |
| * Copyright (C) 2022 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "VtsHalPresetReverbTargetTest" |
| #include <android-base/logging.h> |
| #include <android/binder_enums.h> |
| #include <audio_utils/power.h> |
| #include <system/audio.h> |
| |
| #include "EffectHelper.h" |
| |
| using namespace android; |
| |
| using aidl::android::hardware::audio::common::getChannelCount; |
| using aidl::android::hardware::audio::effect::Descriptor; |
| using aidl::android::hardware::audio::effect::getEffectTypeUuidPresetReverb; |
| using aidl::android::hardware::audio::effect::IEffect; |
| using aidl::android::hardware::audio::effect::IFactory; |
| using aidl::android::hardware::audio::effect::Parameter; |
| using aidl::android::hardware::audio::effect::PresetReverb; |
| using android::hardware::audio::common::testing::detail::TestExecutionTracer; |
| |
| class PresetReverbHelper : public EffectHelper { |
| public: |
| void SetUpPresetReverb() { |
| ASSERT_NE(nullptr, mFactory); |
| ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor)); |
| Parameter::Specific specific = getDefaultParamSpecific(); |
| Parameter::Common common = EffectHelper::createParamCommon( |
| 0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */, |
| kSamplingFrequency /* oSampleRate */, mFrameCount /* iFrameCount */, |
| mFrameCount /* oFrameCount */); |
| ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE)); |
| ASSERT_NE(nullptr, mEffect); |
| } |
| |
| void TearDownPresetReverb() { |
| ASSERT_NO_FATAL_FAILURE(close(mEffect)); |
| ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect)); |
| mOpenEffectReturn = IEffect::OpenEffectReturn{}; |
| } |
| |
| Parameter::Specific getDefaultParamSpecific() { |
| PresetReverb pr = PresetReverb::make<PresetReverb::preset>(kDefaultPreset); |
| Parameter::Specific specific = |
| Parameter::Specific::make<Parameter::Specific::presetReverb>(pr); |
| return specific; |
| } |
| |
| Parameter createPresetReverbParam(const PresetReverb::Presets& param) { |
| return Parameter::make<Parameter::specific>( |
| Parameter::Specific::make<Parameter::Specific::presetReverb>( |
| PresetReverb::make<PresetReverb::preset>(param))); |
| } |
| |
| void setAndVerifyPreset(const PresetReverb::Presets& param) { |
| auto expectedParam = createPresetReverbParam(param); |
| EXPECT_STATUS(EX_NONE, mEffect->setParameter(expectedParam)) << expectedParam.toString(); |
| |
| PresetReverb::Id revId = |
| PresetReverb::Id::make<PresetReverb::Id::commonTag>(PresetReverb::preset); |
| |
| auto id = Parameter::Id::make<Parameter::Id::presetReverbTag>(revId); |
| // get parameter |
| Parameter getParam; |
| EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam)); |
| EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString() |
| << "\ngetParam:" << getParam.toString(); |
| } |
| |
| static constexpr int kSamplingFrequency = 44100; |
| static constexpr int kDurationMilliSec = 2000; |
| static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000; |
| int mStereoChannelCount = |
| getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>( |
| AudioChannelLayout::LAYOUT_STEREO)); |
| PresetReverb::Presets kDefaultPreset = PresetReverb::Presets::NONE; |
| int mFrameCount = kBufferSize / mStereoChannelCount; |
| std::shared_ptr<IFactory> mFactory; |
| std::shared_ptr<IEffect> mEffect; |
| IEffect::OpenEffectReturn mOpenEffectReturn; |
| Descriptor mDescriptor; |
| }; |
| |
| /** |
| * Here we focus on specific parameter checking, general IEffect interfaces testing performed in |
| * VtsAudioEffectTargetTest. |
| */ |
| enum ParamName { PARAM_INSTANCE_NAME, PARAM_PRESETS }; |
| using PresetReverbParamTestParam = |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, PresetReverb::Presets>; |
| |
| // Testing for enum values |
| const std::vector<PresetReverb::Presets> kPresetsValues{ |
| ndk::enum_range<PresetReverb::Presets>().begin(), |
| ndk::enum_range<PresetReverb::Presets>().end()}; |
| |
| class PresetReverbParamTest : public ::testing::TestWithParam<PresetReverbParamTestParam>, |
| public PresetReverbHelper { |
| public: |
| PresetReverbParamTest() : mParamPreset(std::get<PARAM_PRESETS>(GetParam())) { |
| std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam()); |
| } |
| |
| void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpPresetReverb()); } |
| |
| void TearDown() override { TearDownPresetReverb(); } |
| |
| const PresetReverb::Presets mParamPreset; |
| }; |
| |
| TEST_P(PresetReverbParamTest, SetAndGetPresets) { |
| ASSERT_NO_FATAL_FAILURE(setAndVerifyPreset(mParamPreset)); |
| } |
| |
| using PresetReverbProcessTestParam = std::pair<std::shared_ptr<IFactory>, Descriptor>; |
| |
| class PresetReverbProcessTest : public ::testing::TestWithParam<PresetReverbProcessTestParam>, |
| public PresetReverbHelper { |
| public: |
| PresetReverbProcessTest() { |
| std::tie(mFactory, mDescriptor) = GetParam(); |
| generateSineWaveInput(); |
| } |
| |
| void SetUp() override { |
| SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags); |
| ASSERT_NO_FATAL_FAILURE(SetUpPresetReverb()); |
| } |
| void TearDown() override { |
| SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags); |
| ASSERT_NO_FATAL_FAILURE(TearDownPresetReverb()); |
| } |
| |
| void generateSineWaveInput() { |
| int frequency = 1000; |
| for (size_t i = 0; i < kBufferSize; i++) { |
| mInput.push_back(sin(2 * M_PI * frequency * i / kSamplingFrequency)); |
| } |
| } |
| |
| bool isAuxiliary() { |
| return mDescriptor.common.flags.type == |
| aidl::android::hardware::audio::effect::Flags::Type::AUXILIARY; |
| } |
| |
| float computeReverbOutputEnergy(std::vector<float> output) { |
| if (!isAuxiliary()) { |
| // Extract auxiliary output |
| for (size_t i = 0; i < output.size(); i++) { |
| output[i] -= mInput[i]; |
| } |
| } |
| return (audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT, |
| output.size())); |
| } |
| |
| void setPresetAndProcess(const PresetReverb::Presets& preset, std::vector<float>& output) { |
| ASSERT_NO_FATAL_FAILURE(setAndVerifyPreset(preset)); |
| ASSERT_NO_FATAL_FAILURE( |
| processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn)); |
| } |
| |
| void validateIncreasingEnergy(const std::vector<PresetReverb::Presets>& presets) { |
| float baseOutputEnergy = 0; |
| |
| for (PresetReverb::Presets preset : presets) { |
| std::vector<float> output(kBufferSize); |
| setPresetAndProcess(preset, output); |
| float outputEnergy = computeReverbOutputEnergy(output); |
| |
| ASSERT_GT(outputEnergy, baseOutputEnergy); |
| baseOutputEnergy = outputEnergy; |
| } |
| } |
| |
| std::vector<float> mInput; |
| }; |
| |
| TEST_P(PresetReverbProcessTest, DecreasingRoomSize) { |
| std::vector<PresetReverb::Presets> roomPresets = {PresetReverb::Presets::LARGEROOM, |
| PresetReverb::Presets::MEDIUMROOM, |
| PresetReverb::Presets::SMALLROOM}; |
| validateIncreasingEnergy(roomPresets); |
| } |
| |
| TEST_P(PresetReverbProcessTest, DecreasingHallSize) { |
| std::vector<PresetReverb::Presets> hallPresets = {PresetReverb::Presets::LARGEHALL, |
| PresetReverb::Presets::MEDIUMHALL}; |
| validateIncreasingEnergy(hallPresets); |
| } |
| |
| TEST_P(PresetReverbProcessTest, PresetPlate) { |
| std::vector<float> output(kBufferSize); |
| |
| setPresetAndProcess(PresetReverb::Presets::PLATE, output); |
| float outputEnergy = computeReverbOutputEnergy(output); |
| // Since there is no comparator preset, validating it is greater than zero |
| ASSERT_GT(outputEnergy, 0); |
| } |
| |
| TEST_P(PresetReverbProcessTest, PresetNone) { |
| std::vector<float> output(kBufferSize); |
| |
| setPresetAndProcess(kDefaultPreset, output); |
| float outputEnergy = computeReverbOutputEnergy(output); |
| // NONE type doesn't create reverb effect |
| ASSERT_EQ(outputEnergy, 0); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PresetReverbTest, PresetReverbParamTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, getEffectTypeUuidPresetReverb())), |
| testing::ValuesIn(kPresetsValues)), |
| [](const testing::TestParamInfo<PresetReverbParamTest::ParamType>& info) { |
| auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second; |
| std::string preset = |
| std::to_string(static_cast<int>(std::get<PARAM_PRESETS>(info.param))); |
| std::string name = getPrefix(descriptor) + "_preset" + preset; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PresetReverbParamTest); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PresetReverbTest, PresetReverbProcessTest, |
| testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, getEffectTypeUuidPresetReverb())), |
| [](const testing::TestParamInfo<PresetReverbProcessTest::ParamType>& info) { |
| auto descriptor = info.param; |
| return getPrefix(descriptor.second); |
| }); |
| |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PresetReverbProcessTest); |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer()); |
| ABinderProcess_setThreadPoolMaxThreadCount(1); |
| ABinderProcess_startThreadPool(); |
| return RUN_ALL_TESTS(); |
| } |