Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 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 | #pragma once |
| 18 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 19 | #include <algorithm> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 20 | #include <memory> |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 21 | #include <optional> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 22 | #include <string> |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 23 | #include <type_traits> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 24 | #include <unordered_map> |
Shunkai Yao | f60fc37 | 2023-12-12 17:48:18 +0000 | [diff] [blame] | 25 | #include <utility> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 26 | #include <vector> |
| 27 | |
Mikhail Naganov | 872d4a6 | 2023-03-09 18:19:01 -0800 | [diff] [blame] | 28 | #include <Utils.h> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 29 | #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 Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 32 | #include <android/binder_auto_utils.h> |
| 33 | #include <fmq/AidlMessageQueue.h> |
Krzysztof KosiĆski | a3a78a6 | 2023-03-04 00:58:52 +0000 | [diff] [blame] | 34 | #include <gtest/gtest.h> |
Shunkai Yao | 9e60e63 | 2023-06-23 04:34:50 +0000 | [diff] [blame] | 35 | #include <system/audio_aidl_utils.h> |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 36 | #include <system/audio_effects/aidl_effects_utils.h> |
Shunkai Yao | f8be1ac | 2023-03-06 18:41:27 +0000 | [diff] [blame] | 37 | #include <system/audio_effects/effect_uuid.h> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 38 | |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 39 | #include "EffectFactoryHelper.h" |
| 40 | #include "TestUtils.h" |
Sneha Patil | 93e4eb5 | 2024-02-13 14:09:48 +0530 | [diff] [blame] | 41 | #include "pffft.hpp" |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 42 | |
| 43 | using namespace android; |
| 44 | using aidl::android::hardware::audio::effect::CommandId; |
| 45 | using aidl::android::hardware::audio::effect::Descriptor; |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 46 | using aidl::android::hardware::audio::effect::getEffectTypeUuidSpatializer; |
| 47 | using aidl::android::hardware::audio::effect::getRange; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 48 | using aidl::android::hardware::audio::effect::IEffect; |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 49 | using aidl::android::hardware::audio::effect::isRangeValid; |
Shunkai Yao | d8b6025 | 2025-01-07 21:44:51 +0000 | [diff] [blame] | 50 | using aidl::android::hardware::audio::effect::kDrainSupportedVersion; |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 51 | using aidl::android::hardware::audio::effect::kEffectTypeUuidSpatializer; |
Shunkai Yao | ef683a9 | 2024-04-18 04:38:17 +0000 | [diff] [blame] | 52 | using aidl::android::hardware::audio::effect::kEventFlagDataMqNotEmpty; |
Shunkai Yao | 65c7c70 | 2024-01-09 20:50:53 +0000 | [diff] [blame] | 53 | using aidl::android::hardware::audio::effect::kEventFlagDataMqUpdate; |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 54 | using aidl::android::hardware::audio::effect::kEventFlagNotEmpty; |
Shunkai Yao | ef683a9 | 2024-04-18 04:38:17 +0000 | [diff] [blame] | 55 | using aidl::android::hardware::audio::effect::kReopenSupportedVersion; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 56 | using aidl::android::hardware::audio::effect::Parameter; |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 57 | using aidl::android::hardware::audio::effect::Range; |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 58 | using aidl::android::hardware::audio::effect::Spatializer; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 59 | using aidl::android::hardware::audio::effect::State; |
| 60 | using aidl::android::hardware::common::fmq::SynchronizedReadWrite; |
| 61 | using aidl::android::media::audio::common::AudioChannelLayout; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 62 | using aidl::android::media::audio::common::AudioFormatDescription; |
| 63 | using aidl::android::media::audio::common::AudioFormatType; |
| 64 | using aidl::android::media::audio::common::AudioUuid; |
| 65 | using aidl::android::media::audio::common::PcmType; |
Shunkai Yao | 9e60e63 | 2023-06-23 04:34:50 +0000 | [diff] [blame] | 66 | using ::android::audio::utils::toString; |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 67 | using ::android::hardware::EventFlag; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 68 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 69 | const AudioFormatDescription kDefaultFormatDescription = { |
Shunkai Yao | 6afc855 | 2022-10-26 22:47:20 +0000 | [diff] [blame] | 70 | .type = AudioFormatType::PCM, .pcm = PcmType::FLOAT_32_BIT, .encoding = ""}; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 71 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 72 | typedef ::android::AidlMessageQueue<IEffect::Status, |
| 73 | ::aidl::android::hardware::common::fmq::SynchronizedReadWrite> |
| 74 | StatusMQ; |
| 75 | typedef ::android::AidlMessageQueue<float, |
| 76 | ::aidl::android::hardware::common::fmq::SynchronizedReadWrite> |
| 77 | DataMQ; |
| 78 | |
Shunkai Yao | 9e60e63 | 2023-06-23 04:34:50 +0000 | [diff] [blame] | 79 | static inline std::string getPrefix(Descriptor& descriptor) { |
Jaideep Sharma | e4c7a96 | 2023-06-14 19:14:44 +0530 | [diff] [blame] | 80 | std::string prefix = "Implementor_" + descriptor.common.implementor + "_name_" + |
Shunkai Yao | 9e60e63 | 2023-06-23 04:34:50 +0000 | [diff] [blame] | 81 | descriptor.common.name + "_UUID_" + toString(descriptor.common.id.uuid); |
Sneha Patil | 94abce0 | 2024-04-03 12:15:03 +0530 | [diff] [blame] | 82 | std::replace_if( |
| 83 | prefix.begin(), prefix.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
Jaideep Sharma | e4c7a96 | 2023-06-14 19:14:44 +0530 | [diff] [blame] | 84 | return prefix; |
| 85 | } |
| 86 | |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 87 | class EffectHelper { |
| 88 | public: |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 89 | void create(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect>& effect, |
| 90 | Descriptor& desc, binder_status_t status = EX_NONE) { |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 91 | ASSERT_NE(factory, nullptr); |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 92 | auto& id = desc.common.id; |
| 93 | ASSERT_STATUS(status, factory->createEffect(id.uuid, &effect)); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 94 | if (status == EX_NONE) { |
Jaideep Sharma | e4c7a96 | 2023-06-14 19:14:44 +0530 | [diff] [blame] | 95 | ASSERT_NE(effect, nullptr) << toString(id.uuid); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 96 | ASSERT_NO_FATAL_FAILURE(expectState(effect, State::INIT)); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 97 | } |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 98 | mIsSpatializer = id.type == getEffectTypeUuidSpatializer(); |
| 99 | mDescriptor = desc; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 100 | } |
| 101 | |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 102 | 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 Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 109 | 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 Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 113 | ASSERT_STATUS(status, factory->destroyEffect(effect)); |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 114 | } |
| 115 | |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 116 | 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 Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 119 | ASSERT_NE(effect, nullptr); |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 120 | ASSERT_STATUS(status, effect->open(common, specific, ret)); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 121 | if (status != EX_NONE) { |
| 122 | return; |
| 123 | } |
| 124 | |
| 125 | ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE)); |
| 126 | updateFrameSize(common); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 129 | void open(std::shared_ptr<IEffect> effect, int session = 0, binder_status_t status = EX_NONE) { |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 130 | ASSERT_NE(effect, nullptr); |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 131 | Parameter::Common common = createParamCommon(session); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 132 | IEffect::OpenEffectReturn ret; |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 133 | ASSERT_NO_FATAL_FAILURE(open(effect, common, std::nullopt /* specific */, &ret, status)); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 134 | } |
| 135 | |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 136 | 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 Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 146 | static void closeIgnoreRet(std::shared_ptr<IEffect> effect) { |
| 147 | if (effect) { |
| 148 | effect->close(); |
| 149 | } |
| 150 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 151 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 152 | static void close(std::shared_ptr<IEffect> effect, binder_status_t status = EX_NONE) { |
| 153 | if (effect) { |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 154 | ASSERT_STATUS(status, effect->close()); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 155 | if (status == EX_NONE) { |
| 156 | ASSERT_NO_FATAL_FAILURE(expectState(effect, State::INIT)); |
| 157 | } |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 158 | } |
| 159 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 160 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 161 | static void getDescriptor(std::shared_ptr<IEffect> effect, Descriptor& desc, |
| 162 | binder_status_t status = EX_NONE) { |
| 163 | ASSERT_NE(effect, nullptr); |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 164 | ASSERT_STATUS(status, effect->getDescriptor(&desc)); |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 165 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 166 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 167 | 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 Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 171 | ASSERT_STATUS(status, effect->getState(&state)); |
| 172 | ASSERT_EQ(expectState, state); |
| 173 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 174 | |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 175 | static void commandIgnoreRet(std::shared_ptr<IEffect> effect, CommandId command) { |
| 176 | if (effect) { |
| 177 | effect->command(command); |
| 178 | } |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 179 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 180 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 181 | static void command(std::shared_ptr<IEffect> effect, CommandId command, |
| 182 | binder_status_t status = EX_NONE) { |
| 183 | ASSERT_NE(effect, nullptr); |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 184 | ASSERT_STATUS(status, effect->command(command)); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 185 | 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 Yao | d8b6025 | 2025-01-07 21:44:51 +0000 | [diff] [blame] | 194 | // Enforce the state checking after kDrainSupportedVersion |
| 195 | if (getHalVersion(effect) >= kDrainSupportedVersion) { |
| 196 | ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE)); |
| 197 | } |
| 198 | break; |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 199 | case CommandId::RESET: |
| 200 | ASSERT_NO_FATAL_FAILURE(expectState(effect, State::IDLE)); |
| 201 | break; |
| 202 | default: |
| 203 | return; |
| 204 | } |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 205 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 206 | |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 207 | static void writeToFmq(std::unique_ptr<StatusMQ>& statusMq, std::unique_ptr<DataMQ>& dataMq, |
Shunkai Yao | ef683a9 | 2024-04-18 04:38:17 +0000 | [diff] [blame] | 208 | const std::vector<float>& buffer, int version) { |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 209 | const size_t available = dataMq->availableToWrite(); |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 210 | ASSERT_NE(0Ul, available); |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 211 | auto bufferFloats = buffer.size(); |
| 212 | auto floatsToWrite = std::min(available, bufferFloats); |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 213 | 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 Yao | ef683a9 | 2024-04-18 04:38:17 +0000 | [diff] [blame] | 219 | efGroup->wake(version >= kReopenSupportedVersion ? kEventFlagDataMqNotEmpty |
| 220 | : kEventFlagNotEmpty); |
Shunkai Yao | 41888a2 | 2023-04-10 17:13:30 +0000 | [diff] [blame] | 221 | ASSERT_EQ(::android::OK, EventFlag::deleteEventFlag(&efGroup)); |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 222 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 223 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 224 | static void readFromFmq(std::unique_ptr<StatusMQ>& statusMq, size_t statusNum, |
| 225 | std::unique_ptr<DataMQ>& dataMq, size_t expectFloats, |
Shunkai Yao | b49631f | 2023-02-03 01:44:32 +0000 | [diff] [blame] | 226 | 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 Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 232 | IEffect::Status status{}; |
Shunkai Yao | cb0fc41 | 2022-12-15 20:34:32 +0000 | [diff] [blame] | 233 | ASSERT_TRUE(statusMq->readBlocking(&status, statusNum)); |
Shunkai Yao | b49631f | 2023-02-03 01:44:32 +0000 | [diff] [blame] | 234 | 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 Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 242 | } |
| 243 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 244 | |
Shunkai Yao | 65c7c70 | 2024-01-09 20:50:53 +0000 | [diff] [blame] | 245 | 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 Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 255 | |
| 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 Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 259 | AudioChannelLayout inputLayout = AudioChannelLayout::make<AudioChannelLayout::layoutMask>( |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 260 | AudioChannelLayout::LAYOUT_STEREO); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 261 | AudioChannelLayout outputLayout = inputLayout; |
| 262 | |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 263 | // 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 Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 272 | inputLayout = layouts[0]; |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 273 | } |
| 274 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 275 | |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 276 | return createParamCommon(session, ioHandle, iSampleRate, oSampleRate, iFrameCount, |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 277 | oFrameCount, inputLayout, outputLayout); |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 278 | } |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 279 | |
Shunkai Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 280 | static Parameter::Common createParamCommon(int session, int ioHandle, int iSampleRate, |
| 281 | int oSampleRate, long iFrameCount, long oFrameCount, |
| 282 | AudioChannelLayout inputChannelLayout, |
| 283 | AudioChannelLayout outputChannelLayout) { |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 284 | Parameter::Common common; |
| 285 | common.session = session; |
| 286 | common.ioHandle = ioHandle; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 287 | |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 288 | auto& input = common.input; |
| 289 | auto& output = common.output; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 290 | input.base.sampleRate = iSampleRate; |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 291 | input.base.channelMask = inputChannelLayout; |
| 292 | input.base.format = kDefaultFormatDescription; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 293 | input.frameCount = iFrameCount; |
| 294 | output.base.sampleRate = oSampleRate; |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 295 | output.base.channelMask = outputChannelLayout; |
| 296 | output.base.format = kDefaultFormatDescription; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 297 | output.frameCount = oFrameCount; |
Shunkai Yao | 812d5b4 | 2022-11-16 18:08:50 +0000 | [diff] [blame] | 298 | return common; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 299 | } |
| 300 | |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 301 | typedef ::android::AidlMessageQueue< |
| 302 | IEffect::Status, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite> |
| 303 | StatusMQ; |
| 304 | typedef ::android::AidlMessageQueue< |
Shunkai Yao | 6afc855 | 2022-10-26 22:47:20 +0000 | [diff] [blame] | 305 | float, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite> |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 306 | 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 Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 314 | |
| 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 Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 331 | const auto minLimit = std::numeric_limits<S>::min(), |
| 332 | maxLimit = std::numeric_limits<S>::max(); |
| 333 | if (s.size()) { |
Shraddha Basantwani | b76f5ab | 2023-03-27 16:00:03 +0530 | [diff] [blame] | 334 | const auto min = *s.begin(), max = *s.rbegin(); |
Shunkai Yao | 5ed80c5 | 2023-09-07 17:42:39 +0000 | [diff] [blame] | 335 | s.insert((min & max) + ((min ^ max) >> 1)); |
| 336 | if (min > minLimit + 1) { |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 337 | s.insert(min - 1); |
| 338 | } |
Shunkai Yao | 5ed80c5 | 2023-09-07 17:42:39 +0000 | [diff] [blame] | 339 | if (max < maxLimit - 1) { |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 340 | s.insert(max + 1); |
| 341 | } |
| 342 | } |
| 343 | s.insert(minLimit); |
| 344 | s.insert(maxLimit); |
| 345 | return s; |
| 346 | } |
| 347 | |
Shunkai Yao | f60fc37 | 2023-12-12 17:48:18 +0000 | [diff] [blame] | 348 | template <typename T, typename S, Range::Tag R, typename T::Tag tag> |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 349 | static std::set<S> getTestValueSet( |
Shunkai Yao | f60fc37 | 2023-12-12 17:48:18 +0000 | [diff] [blame] | 350 | std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> descList) { |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 351 | std::set<S> result; |
Shunkai Yao | f60fc37 | 2023-12-12 17:48:18 +0000 | [diff] [blame] | 352 | for (const auto& [_, desc] : descList) { |
Shunkai Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 353 | 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 Yao | f60fc37 | 2023-12-12 17:48:18 +0000 | [diff] [blame] | 365 | 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 Yao | 0a0c45e | 2023-02-13 17:41:11 +0000 | [diff] [blame] | 373 | return functor(result); |
| 374 | } |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 375 | |
| 376 | static void processAndWriteToOutput(std::vector<float>& inputBuffer, |
| 377 | std::vector<float>& outputBuffer, |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 378 | const std::shared_ptr<IEffect>& effect, |
| 379 | IEffect::OpenEffectReturn* openEffectReturn, |
| 380 | int version = -1, int times = 1) { |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 381 | // Initialize AidlMessagequeues |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 382 | auto statusMQ = std::make_unique<EffectHelper::StatusMQ>(openEffectReturn->statusMQ); |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 383 | ASSERT_TRUE(statusMQ->isValid()); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 384 | auto inputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->inputDataMQ); |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 385 | ASSERT_TRUE(inputMQ->isValid()); |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 386 | auto outputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->outputDataMQ); |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 387 | ASSERT_TRUE(outputMQ->isValid()); |
| 388 | |
| 389 | // Enabling the process |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 390 | ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::START)); |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 391 | |
| 392 | // Write from buffer to message queues and calling process |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 393 | if (version == -1) { |
| 394 | ASSERT_IS_OK(effect->getInterfaceVersion(&version)); |
| 395 | } |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 396 | |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 397 | 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 Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 407 | |
| 408 | // Disable the process |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 409 | ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET)); |
Sneha Patil | f533b50 | 2023-10-25 12:39:55 +0530 | [diff] [blame] | 410 | } |
Sneha Patil | 93e4eb5 | 2024-02-13 14:09:48 +0530 | [diff] [blame] | 411 | |
| 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 Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 452 | |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 453 | 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 Yao | d8b6025 | 2025-01-07 21:44:51 +0000 | [diff] [blame] | 462 | 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 Yao | 61f9dd2 | 2024-05-08 22:34:36 +0000 | [diff] [blame] | 467 | bool mIsSpatializer; |
| 468 | Descriptor mDescriptor; |
Shunkai Yao | 28aff3d | 2024-06-15 03:16:06 +0000 | [diff] [blame] | 469 | size_t mInputFrameSize, mOutputFrameSize; |
| 470 | size_t mInputSamples, mOutputSamples; |
Shunkai Yao | a4ab38c | 2022-10-14 01:07:47 +0000 | [diff] [blame] | 471 | }; |