blob: a081cfb2cb625915fe0b4bab4cf25ed35edb0614 [file] [log] [blame]
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +00001/*
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#pragma once
18
Shunkai Yao812d5b42022-11-16 18:08:50 +000019#include <algorithm>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000020#include <memory>
Shunkai Yao61f9dd22024-05-08 22:34:36 +000021#include <optional>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000022#include <string>
Shunkai Yao0a0c45e2023-02-13 17:41:11 +000023#include <type_traits>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000024#include <unordered_map>
Shunkai Yaof60fc372023-12-12 17:48:18 +000025#include <utility>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000026#include <vector>
27
Mikhail Naganov872d4a62023-03-09 18:19:01 -080028#include <Utils.h>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000029#include <aidl/android/hardware/audio/effect/IEffect.h>
30#include <aidl/android/hardware/audio/effect/IFactory.h>
31#include <aidl/android/media/audio/common/AudioChannelLayout.h>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000032#include <android/binder_auto_utils.h>
33#include <fmq/AidlMessageQueue.h>
Krzysztof KosiƄskia3a78a62023-03-04 00:58:52 +000034#include <gtest/gtest.h>
Shunkai Yao9e60e632023-06-23 04:34:50 +000035#include <system/audio_aidl_utils.h>
Shunkai Yao0a0c45e2023-02-13 17:41:11 +000036#include <system/audio_effects/aidl_effects_utils.h>
Shunkai Yaof8be1ac2023-03-06 18:41:27 +000037#include <system/audio_effects/effect_uuid.h>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000038
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000039#include "EffectFactoryHelper.h"
40#include "TestUtils.h"
Sneha Patil93e4eb52024-02-13 14:09:48 +053041#include "pffft.hpp"
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000042
43using namespace android;
44using aidl::android::hardware::audio::effect::CommandId;
45using aidl::android::hardware::audio::effect::Descriptor;
Shunkai Yao61f9dd22024-05-08 22:34:36 +000046using aidl::android::hardware::audio::effect::getEffectTypeUuidSpatializer;
47using aidl::android::hardware::audio::effect::getRange;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000048using aidl::android::hardware::audio::effect::IEffect;
Shunkai Yao61f9dd22024-05-08 22:34:36 +000049using aidl::android::hardware::audio::effect::isRangeValid;
Shunkai Yaod8b60252025-01-07 21:44:51 +000050using aidl::android::hardware::audio::effect::kDrainSupportedVersion;
Shunkai Yao61f9dd22024-05-08 22:34:36 +000051using aidl::android::hardware::audio::effect::kEffectTypeUuidSpatializer;
Shunkai Yaoef683a92024-04-18 04:38:17 +000052using aidl::android::hardware::audio::effect::kEventFlagDataMqNotEmpty;
Shunkai Yao65c7c702024-01-09 20:50:53 +000053using aidl::android::hardware::audio::effect::kEventFlagDataMqUpdate;
Shunkai Yao41888a22023-04-10 17:13:30 +000054using aidl::android::hardware::audio::effect::kEventFlagNotEmpty;
Shunkai Yaoef683a92024-04-18 04:38:17 +000055using aidl::android::hardware::audio::effect::kReopenSupportedVersion;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000056using aidl::android::hardware::audio::effect::Parameter;
Shunkai Yao0a0c45e2023-02-13 17:41:11 +000057using aidl::android::hardware::audio::effect::Range;
Shunkai Yao61f9dd22024-05-08 22:34:36 +000058using aidl::android::hardware::audio::effect::Spatializer;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000059using aidl::android::hardware::audio::effect::State;
60using aidl::android::hardware::common::fmq::SynchronizedReadWrite;
61using aidl::android::media::audio::common::AudioChannelLayout;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000062using aidl::android::media::audio::common::AudioFormatDescription;
63using aidl::android::media::audio::common::AudioFormatType;
64using aidl::android::media::audio::common::AudioUuid;
65using aidl::android::media::audio::common::PcmType;
Shunkai Yao9e60e632023-06-23 04:34:50 +000066using ::android::audio::utils::toString;
Shunkai Yao41888a22023-04-10 17:13:30 +000067using ::android::hardware::EventFlag;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000068
Shunkai Yao812d5b42022-11-16 18:08:50 +000069const AudioFormatDescription kDefaultFormatDescription = {
Shunkai Yao6afc8552022-10-26 22:47:20 +000070 .type = AudioFormatType::PCM, .pcm = PcmType::FLOAT_32_BIT, .encoding = ""};
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000071
Shunkai Yao812d5b42022-11-16 18:08:50 +000072typedef ::android::AidlMessageQueue<IEffect::Status,
73 ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
74 StatusMQ;
75typedef ::android::AidlMessageQueue<float,
76 ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
77 DataMQ;
78
Shunkai Yao9e60e632023-06-23 04:34:50 +000079static inline std::string getPrefix(Descriptor& descriptor) {
Jaideep Sharmae4c7a962023-06-14 19:14:44 +053080 std::string prefix = "Implementor_" + descriptor.common.implementor + "_name_" +
Shunkai Yao9e60e632023-06-23 04:34:50 +000081 descriptor.common.name + "_UUID_" + toString(descriptor.common.id.uuid);
Sneha Patil94abce02024-04-03 12:15:03 +053082 std::replace_if(
83 prefix.begin(), prefix.end(), [](const char c) { return !std::isalnum(c); }, '_');
Jaideep Sharmae4c7a962023-06-14 19:14:44 +053084 return prefix;
85}
86
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +000087class EffectHelper {
88 public:
Shunkai Yao61f9dd22024-05-08 22:34:36 +000089 void create(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect>& effect,
90 Descriptor& desc, binder_status_t status = EX_NONE) {
Shunkai Yao812d5b42022-11-16 18:08:50 +000091 ASSERT_NE(factory, nullptr);
Shunkai Yaocb0fc412022-12-15 20:34:32 +000092 auto& id = desc.common.id;
93 ASSERT_STATUS(status, factory->createEffect(id.uuid, &effect));
Shunkai Yao812d5b42022-11-16 18:08:50 +000094 if (status == EX_NONE) {
Jaideep Sharmae4c7a962023-06-14 19:14:44 +053095 ASSERT_NE(effect, nullptr) << toString(id.uuid);
Shunkai Yao28aff3d2024-06-15 03:16:06 +000096 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::INIT));
Shunkai Yao812d5b42022-11-16 18:08:50 +000097 }
Shunkai Yao61f9dd22024-05-08 22:34:36 +000098 mIsSpatializer = id.type == getEffectTypeUuidSpatializer();
99 mDescriptor = desc;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000100 }
101
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000102 static void destroyIgnoreRet(std::shared_ptr<IFactory> factory,
103 std::shared_ptr<IEffect> effect) {
104 if (factory && effect) {
105 factory->destroyEffect(effect);
106 }
107 }
108
Shunkai Yao812d5b42022-11-16 18:08:50 +0000109 static void destroy(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect> effect,
110 binder_status_t status = EX_NONE) {
111 ASSERT_NE(factory, nullptr);
112 ASSERT_NE(effect, nullptr);
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000113 ASSERT_STATUS(status, factory->destroyEffect(effect));
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000114 }
115
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000116 void open(std::shared_ptr<IEffect> effect, const Parameter::Common& common,
117 const std::optional<Parameter::Specific>& specific, IEffect::OpenEffectReturn* ret,
118 binder_status_t status = EX_NONE) {
Shunkai Yao812d5b42022-11-16 18:08:50 +0000119 ASSERT_NE(effect, nullptr);
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000120 ASSERT_STATUS(status, effect->open(common, specific, ret));
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000121 if (status != EX_NONE) {
122 return;
123 }
124
125 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE));
126 updateFrameSize(common);
Shunkai Yao812d5b42022-11-16 18:08:50 +0000127 }
128
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000129 void open(std::shared_ptr<IEffect> effect, int session = 0, binder_status_t status = EX_NONE) {
Shunkai Yao812d5b42022-11-16 18:08:50 +0000130 ASSERT_NE(effect, nullptr);
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000131 Parameter::Common common = createParamCommon(session);
Shunkai Yao812d5b42022-11-16 18:08:50 +0000132 IEffect::OpenEffectReturn ret;
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000133 ASSERT_NO_FATAL_FAILURE(open(effect, common, std::nullopt /* specific */, &ret, status));
Shunkai Yao812d5b42022-11-16 18:08:50 +0000134 }
135
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000136 void reopen(std::shared_ptr<IEffect> effect, const Parameter::Common& common,
137 IEffect::OpenEffectReturn* ret, binder_status_t status = EX_NONE) {
138 ASSERT_NE(effect, nullptr);
139 ASSERT_STATUS(status, effect->reopen(ret));
140 if (status != EX_NONE) {
141 return;
142 }
143 updateFrameSize(common);
144 }
145
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000146 static void closeIgnoreRet(std::shared_ptr<IEffect> effect) {
147 if (effect) {
148 effect->close();
149 }
150 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000151
Shunkai Yao812d5b42022-11-16 18:08:50 +0000152 static void close(std::shared_ptr<IEffect> effect, binder_status_t status = EX_NONE) {
153 if (effect) {
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000154 ASSERT_STATUS(status, effect->close());
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000155 if (status == EX_NONE) {
156 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::INIT));
157 }
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000158 }
159 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000160
Shunkai Yao812d5b42022-11-16 18:08:50 +0000161 static void getDescriptor(std::shared_ptr<IEffect> effect, Descriptor& desc,
162 binder_status_t status = EX_NONE) {
163 ASSERT_NE(effect, nullptr);
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000164 ASSERT_STATUS(status, effect->getDescriptor(&desc));
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000165 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000166
Shunkai Yao812d5b42022-11-16 18:08:50 +0000167 static void expectState(std::shared_ptr<IEffect> effect, State expectState,
168 binder_status_t status = EX_NONE) {
169 ASSERT_NE(effect, nullptr);
170 State state;
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000171 ASSERT_STATUS(status, effect->getState(&state));
172 ASSERT_EQ(expectState, state);
173 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000174
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000175 static void commandIgnoreRet(std::shared_ptr<IEffect> effect, CommandId command) {
176 if (effect) {
177 effect->command(command);
178 }
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000179 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000180
Shunkai Yao812d5b42022-11-16 18:08:50 +0000181 static void command(std::shared_ptr<IEffect> effect, CommandId command,
182 binder_status_t status = EX_NONE) {
183 ASSERT_NE(effect, nullptr);
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000184 ASSERT_STATUS(status, effect->command(command));
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000185 if (status != EX_NONE) {
186 return;
187 }
188
189 switch (command) {
190 case CommandId::START:
191 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::PROCESSING));
192 break;
193 case CommandId::STOP:
Shunkai Yaod8b60252025-01-07 21:44:51 +0000194 // Enforce the state checking after kDrainSupportedVersion
195 if (getHalVersion(effect) >= kDrainSupportedVersion) {
196 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE));
197 }
198 break;
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000199 case CommandId::RESET:
200 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE));
201 break;
202 default:
203 return;
204 }
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000205 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000206
Shunkai Yao41888a22023-04-10 17:13:30 +0000207 static void writeToFmq(std::unique_ptr<StatusMQ>& statusMq, std::unique_ptr<DataMQ>& dataMq,
Shunkai Yaoef683a92024-04-18 04:38:17 +0000208 const std::vector<float>& buffer, int version) {
Shunkai Yao41888a22023-04-10 17:13:30 +0000209 const size_t available = dataMq->availableToWrite();
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000210 ASSERT_NE(0Ul, available);
Shunkai Yao812d5b42022-11-16 18:08:50 +0000211 auto bufferFloats = buffer.size();
212 auto floatsToWrite = std::min(available, bufferFloats);
Shunkai Yao41888a22023-04-10 17:13:30 +0000213 ASSERT_TRUE(dataMq->write(buffer.data(), floatsToWrite));
214
215 EventFlag* efGroup;
216 ASSERT_EQ(::android::OK,
217 EventFlag::createEventFlag(statusMq->getEventFlagWord(), &efGroup));
218 ASSERT_NE(nullptr, efGroup);
Shunkai Yaoef683a92024-04-18 04:38:17 +0000219 efGroup->wake(version >= kReopenSupportedVersion ? kEventFlagDataMqNotEmpty
220 : kEventFlagNotEmpty);
Shunkai Yao41888a22023-04-10 17:13:30 +0000221 ASSERT_EQ(::android::OK, EventFlag::deleteEventFlag(&efGroup));
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000222 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000223
Shunkai Yao812d5b42022-11-16 18:08:50 +0000224 static void readFromFmq(std::unique_ptr<StatusMQ>& statusMq, size_t statusNum,
225 std::unique_ptr<DataMQ>& dataMq, size_t expectFloats,
Shunkai Yaob49631f2023-02-03 01:44:32 +0000226 std::vector<float>& buffer,
227 std::optional<int> expectStatus = STATUS_OK) {
228 if (0 == statusNum) {
229 ASSERT_EQ(0ul, statusMq->availableToRead());
230 return;
231 }
Shunkai Yao812d5b42022-11-16 18:08:50 +0000232 IEffect::Status status{};
Shunkai Yaocb0fc412022-12-15 20:34:32 +0000233 ASSERT_TRUE(statusMq->readBlocking(&status, statusNum));
Shunkai Yaob49631f2023-02-03 01:44:32 +0000234 if (expectStatus.has_value()) {
235 ASSERT_EQ(expectStatus.value(), status.status);
236 }
237
238 ASSERT_EQ(expectFloats, (unsigned)status.fmqProduced);
239 ASSERT_EQ(expectFloats, dataMq->availableToRead());
240 if (expectFloats != 0) {
241 ASSERT_TRUE(dataMq->read(buffer.data(), expectFloats));
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000242 }
243 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000244
Shunkai Yao65c7c702024-01-09 20:50:53 +0000245 static void expectDataMqUpdateEventFlag(std::unique_ptr<StatusMQ>& statusMq) {
246 EventFlag* efGroup;
247 ASSERT_EQ(::android::OK,
248 EventFlag::createEventFlag(statusMq->getEventFlagWord(), &efGroup));
249 ASSERT_NE(nullptr, efGroup);
250 uint32_t efState = 0;
251 EXPECT_EQ(::android::OK, efGroup->wait(kEventFlagDataMqUpdate, &efState, 1'000'000 /*1ms*/,
252 true /* retry */));
253 EXPECT_TRUE(efState & kEventFlagDataMqUpdate);
254 }
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000255
256 Parameter::Common createParamCommon(int session = 0, int ioHandle = -1, int iSampleRate = 48000,
257 int oSampleRate = 48000, long iFrameCount = 0x100,
258 long oFrameCount = 0x100) {
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000259 AudioChannelLayout inputLayout = AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000260 AudioChannelLayout::LAYOUT_STEREO);
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000261 AudioChannelLayout outputLayout = inputLayout;
262
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000263 // query supported input layout and use it as the default parameter in common
264 if (mIsSpatializer && isRangeValid<Range::spatializer>(Spatializer::supportedChannelLayout,
265 mDescriptor.capability)) {
266 const auto layoutRange = getRange<Range::spatializer, Range::SpatializerRange>(
267 mDescriptor.capability, Spatializer::supportedChannelLayout);
268 if (std::vector<AudioChannelLayout> layouts;
269 layoutRange &&
270 0 != (layouts = layoutRange->min.get<Spatializer::supportedChannelLayout>())
271 .size()) {
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000272 inputLayout = layouts[0];
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000273 }
274 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000275
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000276 return createParamCommon(session, ioHandle, iSampleRate, oSampleRate, iFrameCount,
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000277 oFrameCount, inputLayout, outputLayout);
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000278 }
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000279
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000280 static Parameter::Common createParamCommon(int session, int ioHandle, int iSampleRate,
281 int oSampleRate, long iFrameCount, long oFrameCount,
282 AudioChannelLayout inputChannelLayout,
283 AudioChannelLayout outputChannelLayout) {
Shunkai Yao812d5b42022-11-16 18:08:50 +0000284 Parameter::Common common;
285 common.session = session;
286 common.ioHandle = ioHandle;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000287
Shunkai Yao812d5b42022-11-16 18:08:50 +0000288 auto& input = common.input;
289 auto& output = common.output;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000290 input.base.sampleRate = iSampleRate;
Shunkai Yao812d5b42022-11-16 18:08:50 +0000291 input.base.channelMask = inputChannelLayout;
292 input.base.format = kDefaultFormatDescription;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000293 input.frameCount = iFrameCount;
294 output.base.sampleRate = oSampleRate;
Shunkai Yao812d5b42022-11-16 18:08:50 +0000295 output.base.channelMask = outputChannelLayout;
296 output.base.format = kDefaultFormatDescription;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000297 output.frameCount = oFrameCount;
Shunkai Yao812d5b42022-11-16 18:08:50 +0000298 return common;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000299 }
300
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000301 typedef ::android::AidlMessageQueue<
302 IEffect::Status, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
303 StatusMQ;
304 typedef ::android::AidlMessageQueue<
Shunkai Yao6afc8552022-10-26 22:47:20 +0000305 float, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000306 DataMQ;
307
308 class EffectParam {
309 public:
310 std::unique_ptr<StatusMQ> statusMQ;
311 std::unique_ptr<DataMQ> inputMQ;
312 std::unique_ptr<DataMQ> outputMQ;
313 };
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000314
315 template <typename T, Range::Tag tag>
316 static bool isParameterValid(const T& target, const Descriptor& desc) {
317 if (desc.capability.range.getTag() != tag) {
318 return true;
319 }
320 const auto& ranges = desc.capability.range.get<tag>();
321 return inRange(target, ranges);
322 }
323
324 /**
325 * Add to test value set: (min+max)/2, minimum/maximum numeric limits, and min-1/max+1 if
326 * result still in numeric limits after -1/+1.
327 * Only use this when the type of test value is basic type (std::is_arithmetic return true).
328 */
329 template <typename S, typename = std::enable_if_t<std::is_arithmetic_v<S>>>
330 static std::set<S> expandTestValueBasic(std::set<S>& s) {
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000331 const auto minLimit = std::numeric_limits<S>::min(),
332 maxLimit = std::numeric_limits<S>::max();
333 if (s.size()) {
Shraddha Basantwanib76f5ab2023-03-27 16:00:03 +0530334 const auto min = *s.begin(), max = *s.rbegin();
Shunkai Yao5ed80c52023-09-07 17:42:39 +0000335 s.insert((min & max) + ((min ^ max) >> 1));
336 if (min > minLimit + 1) {
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000337 s.insert(min - 1);
338 }
Shunkai Yao5ed80c52023-09-07 17:42:39 +0000339 if (max < maxLimit - 1) {
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000340 s.insert(max + 1);
341 }
342 }
343 s.insert(minLimit);
344 s.insert(maxLimit);
345 return s;
346 }
347
Shunkai Yaof60fc372023-12-12 17:48:18 +0000348 template <typename T, typename S, Range::Tag R, typename T::Tag tag>
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000349 static std::set<S> getTestValueSet(
Shunkai Yaof60fc372023-12-12 17:48:18 +0000350 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> descList) {
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000351 std::set<S> result;
Shunkai Yaof60fc372023-12-12 17:48:18 +0000352 for (const auto& [_, desc] : descList) {
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000353 if (desc.capability.range.getTag() == R) {
354 const auto& ranges = desc.capability.range.get<R>();
355 for (const auto& range : ranges) {
356 if (range.min.getTag() == tag) {
357 result.insert(range.min.template get<tag>());
358 }
359 if (range.max.getTag() == tag) {
360 result.insert(range.max.template get<tag>());
361 }
362 }
363 }
364 }
Shunkai Yaof60fc372023-12-12 17:48:18 +0000365 return result;
366 }
367
368 template <typename T, typename S, Range::Tag R, typename T::Tag tag, typename Functor>
369 static std::set<S> getTestValueSet(
370 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> descList,
371 Functor functor) {
372 auto result = getTestValueSet<T, S, R, tag>(descList);
Shunkai Yao0a0c45e2023-02-13 17:41:11 +0000373 return functor(result);
374 }
Sneha Patilf533b502023-10-25 12:39:55 +0530375
376 static void processAndWriteToOutput(std::vector<float>& inputBuffer,
377 std::vector<float>& outputBuffer,
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000378 const std::shared_ptr<IEffect>& effect,
379 IEffect::OpenEffectReturn* openEffectReturn,
380 int version = -1, int times = 1) {
Sneha Patilf533b502023-10-25 12:39:55 +0530381 // Initialize AidlMessagequeues
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000382 auto statusMQ = std::make_unique<EffectHelper::StatusMQ>(openEffectReturn->statusMQ);
Sneha Patilf533b502023-10-25 12:39:55 +0530383 ASSERT_TRUE(statusMQ->isValid());
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000384 auto inputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->inputDataMQ);
Sneha Patilf533b502023-10-25 12:39:55 +0530385 ASSERT_TRUE(inputMQ->isValid());
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000386 auto outputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->outputDataMQ);
Sneha Patilf533b502023-10-25 12:39:55 +0530387 ASSERT_TRUE(outputMQ->isValid());
388
389 // Enabling the process
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000390 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::START));
Sneha Patilf533b502023-10-25 12:39:55 +0530391
392 // Write from buffer to message queues and calling process
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000393 if (version == -1) {
394 ASSERT_IS_OK(effect->getInterfaceVersion(&version));
395 }
Sneha Patilf533b502023-10-25 12:39:55 +0530396
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000397 for (int i = 0; i < times; i++) {
398 EXPECT_NO_FATAL_FAILURE(
399 EffectHelper::writeToFmq(statusMQ, inputMQ, inputBuffer, version));
400 // Read the updated message queues into buffer
401 EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 1, outputMQ,
402 outputBuffer.size(), outputBuffer));
403 }
404
405 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::STOP));
406 EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 0, outputMQ, 0, outputBuffer));
Sneha Patilf533b502023-10-25 12:39:55 +0530407
408 // Disable the process
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000409 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET));
Sneha Patilf533b502023-10-25 12:39:55 +0530410 }
Sneha Patil93e4eb52024-02-13 14:09:48 +0530411
412 // Find FFT bin indices for testFrequencies and get bin center frequencies
413 void roundToFreqCenteredToFftBin(std::vector<int>& testFrequencies,
414 std::vector<int>& binOffsets, const float kBinWidth) {
415 for (size_t i = 0; i < testFrequencies.size(); i++) {
416 binOffsets[i] = std::round(testFrequencies[i] / kBinWidth);
417 testFrequencies[i] = std::round(binOffsets[i] * kBinWidth);
418 }
419 }
420
421 // Generate multitone input between -1 to +1 using testFrequencies
422 void generateMultiTone(const std::vector<int>& testFrequencies, std::vector<float>& input,
423 const int samplingFrequency) {
424 for (size_t i = 0; i < input.size(); i++) {
425 input[i] = 0;
426
427 for (size_t j = 0; j < testFrequencies.size(); j++) {
428 input[i] += sin(2 * M_PI * testFrequencies[j] * i / samplingFrequency);
429 }
430 input[i] /= testFrequencies.size();
431 }
432 }
433
434 // Use FFT transform to convert the buffer to frequency domain
435 // Compute its magnitude at binOffsets
436 std::vector<float> calculateMagnitude(const std::vector<float>& buffer,
437 const std::vector<int>& binOffsets, const int nPointFFT) {
438 std::vector<float> fftInput(nPointFFT);
439 PFFFT_Setup* inputHandle = pffft_new_setup(nPointFFT, PFFFT_REAL);
440 pffft_transform_ordered(inputHandle, buffer.data(), fftInput.data(), nullptr,
441 PFFFT_FORWARD);
442 pffft_destroy_setup(inputHandle);
443 std::vector<float> bufferMag(binOffsets.size());
444 for (size_t i = 0; i < binOffsets.size(); i++) {
445 size_t k = binOffsets[i];
446 bufferMag[i] = sqrt((fftInput[k * 2] * fftInput[k * 2]) +
447 (fftInput[k * 2 + 1] * fftInput[k * 2 + 1]));
448 }
449
450 return bufferMag;
451 }
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000452
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000453 void updateFrameSize(const Parameter::Common& common) {
454 mInputFrameSize = ::aidl::android::hardware::audio::common::getFrameSizeInBytes(
455 common.input.base.format, common.input.base.channelMask);
456 mInputSamples = common.input.frameCount * mInputFrameSize / sizeof(float);
457 mOutputFrameSize = ::aidl::android::hardware::audio::common::getFrameSizeInBytes(
458 common.output.base.format, common.output.base.channelMask);
459 mOutputSamples = common.output.frameCount * mOutputFrameSize / sizeof(float);
460 }
461
Shunkai Yaod8b60252025-01-07 21:44:51 +0000462 static int getHalVersion(const std::shared_ptr<IEffect>& effect) {
463 int version = 0;
464 return (effect && effect->getInterfaceVersion(&version).isOk()) ? version : 0;
465 }
466
Shunkai Yao61f9dd22024-05-08 22:34:36 +0000467 bool mIsSpatializer;
468 Descriptor mDescriptor;
Shunkai Yao28aff3d2024-06-15 03:16:06 +0000469 size_t mInputFrameSize, mOutputFrameSize;
470 size_t mInputSamples, mOutputSamples;
Shunkai Yaoa4ab38c2022-10-14 01:07:47 +0000471};