1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <algorithm>
18 #include <limits>
19 #include <map>
20 #include <memory>
21 #include <optional>
22 #include <string>
23 #include <vector>
24
25 #include <aidl/Gtest.h>
26 #include <aidl/Vintf.h>
27 #include <aidl/android/hardware/audio/effect/IEffect.h>
28 #include <aidl/android/hardware/audio/effect/IFactory.h>
29 #define LOG_TAG "VtsHalEqualizerTest"
30 #include <android-base/logging.h>
31 #include <android-base/properties.h>
32 #include <android/binder_interface_utils.h>
33 #include <android/binder_manager.h>
34 #include <android/binder_process.h>
35 #include <gtest/gtest.h>
36
37 #include "AudioHalBinderServiceUtil.h"
38 #include "EffectHelper.h"
39 #include "TestUtils.h"
40
41 using namespace android;
42
43 using aidl::android::hardware::audio::effect::Descriptor;
44 using aidl::android::hardware::audio::effect::Equalizer;
45 using aidl::android::hardware::audio::effect::getEffectTypeUuidEqualizer;
46 using aidl::android::hardware::audio::effect::IEffect;
47 using aidl::android::hardware::audio::effect::IFactory;
48 using aidl::android::hardware::audio::effect::Parameter;
49
50 /**
51 * Here we focus on specific effect (equalizer) parameter checking, general IEffect interfaces
52 * testing performed in VtsAudioEfectTargetTest.
53 */
54
55 enum ParamName { PARAM_INSTANCE_NAME, PARAM_PRESET, PARAM_BAND_LEVEL };
56 using EqualizerParamTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int,
57 std::vector<Equalizer::BandLevel>>;
58
59 /*
60 Testing parameter range, assuming the parameter supported by effect is in this range.
61 This range is verified with IEffect.getDescriptor(), for any index supported vts expect EX_NONE
62 from IEffect.setParameter(), otherwise expect EX_ILLEGAL_ARGUMENT.
63 */
64 const std::vector<int> kBandLevels = {0, -10, 10}; // needs update with implementation
65
66 class EqualizerTest : public ::testing::TestWithParam<EqualizerParamTestParam>,
67 public EffectHelper {
68 public:
EqualizerTest()69 EqualizerTest()
70 : mPresetIndex(std::get<PARAM_PRESET>(GetParam())),
71 mBandLevel(std::get<PARAM_BAND_LEVEL>(GetParam())) {
72 std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
73 }
74
SetUp()75 void SetUp() override {
76 ASSERT_NE(nullptr, mFactory);
77 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
78
79 Parameter::Common common = EffectHelper::createParamCommon(
80 0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,
81 kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);
82 IEffect::OpenEffectReturn ret;
83 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &ret, EX_NONE));
84 ASSERT_NE(nullptr, mEffect);
85 }
TearDown()86 void TearDown() override {
87 ASSERT_NO_FATAL_FAILURE(close(mEffect));
88 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
89 }
90
91 static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
92 std::shared_ptr<IFactory> mFactory;
93 std::shared_ptr<IEffect> mEffect;
94 Descriptor mDescriptor;
95 int mPresetIndex;
96 std::vector<Equalizer::BandLevel> mBandLevel;
97
SetAndGetEqualizerParameters()98 void SetAndGetEqualizerParameters() {
99 ASSERT_NE(nullptr, mEffect);
100 for (auto& it : mTags) {
101 auto& tag = it.first;
102 auto& eq = it.second;
103
104 // validate parameter
105 const bool valid = isParameterValid<Equalizer, Range::equalizer>(eq, mDescriptor);
106 const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;
107
108 // set
109 Parameter::Specific specific =
110 Parameter::Specific::make<Parameter::Specific::equalizer>(eq);
111 Parameter expectParam = Parameter::make<Parameter::specific>(specific);
112 EXPECT_STATUS(expected, mEffect->setParameter(expectParam))
113 << expectParam.toString() << "\n"
114 << mDescriptor.toString();
115
116 // only get if parameter in range and set success
117 if (expected == EX_NONE) {
118 Parameter getParam;
119 Equalizer::Id eqId = Equalizer::Id::make<Equalizer::Id::commonTag>(tag);
120 Parameter::Id id = Parameter::Id::make<Parameter::Id::equalizerTag>(eqId);
121 // if set success, then get should match
122 EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));
123 EXPECT_TRUE(isEqParameterExpected(expectParam, getParam))
124 << "\nexpect:" << expectParam.toString()
125 << "\ngetParam:" << getParam.toString();
126 }
127 }
128 }
129
isEqParameterExpected(const Parameter & expect,const Parameter & target)130 bool isEqParameterExpected(const Parameter& expect, const Parameter& target) {
131 // if parameter same, then for sure they are matched
132 if (expect == target) return true;
133
134 // if not, see if target include the expect parameter, and others all default (0).
135 /*
136 * This is to verify the case of client setParameter to a single bandLevel ({3, -1} for
137 * example), and return of getParameter must be [{0, 0}, {1, 0}, {2, 0}, {3, -1}, {4, 0}]
138 */
139 EXPECT_EQ(expect.getTag(), Parameter::specific);
140 EXPECT_EQ(target.getTag(), Parameter::specific);
141
142 Parameter::Specific expectSpec = expect.get<Parameter::specific>(),
143 targetSpec = target.get<Parameter::specific>();
144 EXPECT_EQ(expectSpec.getTag(), Parameter::Specific::equalizer);
145 EXPECT_EQ(targetSpec.getTag(), Parameter::Specific::equalizer);
146
147 Equalizer expectEq = expectSpec.get<Parameter::Specific::equalizer>(),
148 targetEq = targetSpec.get<Parameter::Specific::equalizer>();
149 EXPECT_EQ(expectEq.getTag(), targetEq.getTag());
150
151 auto eqTag = targetEq.getTag();
152 switch (eqTag) {
153 case Equalizer::bandLevels: {
154 auto expectBl = expectEq.get<Equalizer::bandLevels>();
155 std::sort(expectBl.begin(), expectBl.end(),
156 [](const auto& a, const auto& b) { return a.index < b.index; });
157 expectBl.erase(std::unique(expectBl.begin(), expectBl.end()), expectBl.end());
158 auto targetBl = targetEq.get<Equalizer::bandLevels>();
159 return std::includes(targetBl.begin(), targetBl.end(), expectBl.begin(),
160 expectBl.end());
161 }
162 case Equalizer::preset: {
163 return expectEq.get<Equalizer::preset>() == targetEq.get<Equalizer::preset>();
164 }
165 default:
166 return false;
167 }
168 return false;
169 }
170
addPresetParam(int preset)171 void addPresetParam(int preset) {
172 mTags.push_back({Equalizer::preset, Equalizer::make<Equalizer::preset>(preset)});
173 }
174
addBandLevelsParam(std::vector<Equalizer::BandLevel> & bandLevels)175 void addBandLevelsParam(std::vector<Equalizer::BandLevel>& bandLevels) {
176 mTags.push_back(
177 {Equalizer::bandLevels, Equalizer::make<Equalizer::bandLevels>(bandLevels)});
178 }
179
180 private:
181 std::vector<std::pair<Equalizer::Tag, Equalizer>> mTags;
182
CleanUp()183 void CleanUp() { mTags.clear(); }
184 };
185
TEST_P(EqualizerTest,SetAndGetParams)186 TEST_P(EqualizerTest, SetAndGetParams) {
187 addBandLevelsParam(mBandLevel);
188 addPresetParam(mPresetIndex);
189 EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
190 }
191
192 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
193 INSTANTIATE_TEST_SUITE_P(
194 EqualizerTest, EqualizerTest,
195 ::testing::Combine(
196 testing::ValuesIn(kDescPair = EffectFactoryHelper::getAllEffectDescriptors(
197 IFactory::descriptor, getEffectTypeUuidEqualizer())),
198 testing::ValuesIn(EffectHelper::getTestValueSet<Equalizer, int, Range::equalizer,
199 Equalizer::preset>(
200 kDescPair, EffectHelper::expandTestValueBasic<int>)),
201 testing::ValuesIn(
202 EffectHelper::getTestValueSet<Equalizer, std::vector<Equalizer::BandLevel>,
203 Range::equalizer, Equalizer::bandLevels>(
204 kDescPair,
__anonb0c372a60202(std::set<std::vector<Equalizer::BandLevel>>& bandLevels) 205 [](std::set<std::vector<Equalizer::BandLevel>>& bandLevels) {
206 return bandLevels;
207 }))),
__anonb0c372a60302(const testing::TestParamInfo<EqualizerTest::ParamType>& info) 208 [](const testing::TestParamInfo<EqualizerTest::ParamType>& info) {
209 auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
210 std::string bandLevel =
211 ::android::internal::ToString(std::get<PARAM_BAND_LEVEL>(info.param));
212 std::string name = getPrefix(descriptor) + "_preset_" +
213 std::to_string(std::get<PARAM_PRESET>(info.param)) + "_bandLevel_" +
214 bandLevel;
215 std::replace_if(
216 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
217 return name;
218 });
219 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EqualizerTest);
220
main(int argc,char ** argv)221 int main(int argc, char** argv) {
222 ::testing::InitGoogleTest(&argc, argv);
223 ABinderProcess_setThreadPoolMaxThreadCount(1);
224 ABinderProcess_startThreadPool();
225 return RUN_ALL_TESTS();
226 }
227