blob: 2df97d178b219e566121ad7344f4f08b22aef1df [file] [log] [blame]
Shunkai Yaoa03533e2023-01-25 06:38:10 +00001/*
2 * Copyright (C) 2023 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 <utility>
18
19#define LOG_TAG "AidlConversionEffect"
20//#define LOG_NDEBUG 0
21#include <utils/Log.h>
22
23#include <media/AidlConversionCppNdk.h>
24#include <media/AidlConversionEffect.h>
25
26////////////////////////////////////////////////////////////////////////////////////////////////////
27// AIDL NDK backend to legacy audio data structure conversion utilities.
28
29namespace aidl {
30namespace android {
31
32using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
Shraddha Basantwani64db6d42023-02-01 16:24:19 +053033using ::aidl::android::hardware::audio::effect::AutomaticGainControlV2;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000034using ::aidl::android::hardware::audio::effect::BassBoost;
35using ::aidl::android::hardware::audio::effect::Descriptor;
36using ::aidl::android::hardware::audio::effect::Downmix;
Shunkai Yaodba8ba32023-01-27 17:02:21 +000037using ::aidl::android::hardware::audio::effect::DynamicsProcessing;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000038using ::aidl::android::hardware::audio::effect::Flags;
39using ::aidl::android::hardware::audio::effect::Parameter;
Shunkai Yao242521c2023-01-29 18:08:09 +000040using ::aidl::android::hardware::audio::effect::PresetReverb;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000041using ::aidl::android::media::audio::common::AudioDeviceDescription;
42
43using ::android::BAD_VALUE;
44using ::android::base::unexpected;
45
46////////////////////////////////////////////////////////////////////////////////////////////////////
47// Converters
48
49ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(Flags::Type type) {
50 switch (type) {
51 case Flags::Type::INSERT:
52 return EFFECT_FLAG_TYPE_INSERT;
53 case Flags::Type::AUXILIARY:
54 return EFFECT_FLAG_TYPE_AUXILIARY;
55 case Flags::Type::REPLACE:
56 return EFFECT_FLAG_TYPE_REPLACE;
57 case Flags::Type::PRE_PROC:
58 return EFFECT_FLAG_TYPE_PRE_PROC;
59 case Flags::Type::POST_PROC:
60 return EFFECT_FLAG_TYPE_POST_PROC;
61 }
62 return unexpected(BAD_VALUE);
63}
64
65ConversionResult<Flags::Type> legacy2aidl_uint32_Flags_Type(uint32_t legacy) {
66 switch (legacy & EFFECT_FLAG_TYPE_MASK) {
67 case EFFECT_FLAG_TYPE_INSERT:
68 return Flags::Type::INSERT;
69 case EFFECT_FLAG_TYPE_AUXILIARY:
70 return Flags::Type::AUXILIARY;
71 case EFFECT_FLAG_TYPE_REPLACE:
72 return Flags::Type::REPLACE;
73 case EFFECT_FLAG_TYPE_PRE_PROC:
74 return Flags::Type::PRE_PROC;
75 case EFFECT_FLAG_TYPE_POST_PROC:
76 return Flags::Type::POST_PROC;
77 }
78 return unexpected(BAD_VALUE);
79}
80
81ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(Flags::Insert insert) {
82 switch (insert) {
83 case Flags::Insert::ANY:
84 return EFFECT_FLAG_INSERT_ANY;
85 case Flags::Insert::FIRST:
86 return EFFECT_FLAG_INSERT_FIRST;
87 case Flags::Insert::LAST:
88 return EFFECT_FLAG_INSERT_LAST;
89 case Flags::Insert::EXCLUSIVE:
90 return EFFECT_FLAG_INSERT_EXCLUSIVE;
91 }
92 return unexpected(BAD_VALUE);
93}
94
95ConversionResult<Flags::Insert> legacy2aidl_uint32_Flags_Insert(uint32_t legacy) {
96 switch (legacy & EFFECT_FLAG_INSERT_MASK) {
97 case EFFECT_FLAG_INSERT_ANY:
98 return Flags::Insert::ANY;
99 case EFFECT_FLAG_INSERT_FIRST:
100 return Flags::Insert::FIRST;
101 case EFFECT_FLAG_INSERT_LAST:
102 return Flags::Insert::LAST;
103 case EFFECT_FLAG_INSERT_EXCLUSIVE:
104 return Flags::Insert::EXCLUSIVE;
105 }
106 return unexpected(BAD_VALUE);
107}
108
109ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(Flags::Volume volume) {
110 switch (volume) {
111 case Flags::Volume::NONE:
112 return 0;
113 case Flags::Volume::CTRL:
114 return EFFECT_FLAG_VOLUME_CTRL;
115 case Flags::Volume::IND:
116 return EFFECT_FLAG_VOLUME_IND;
117 case Flags::Volume::MONITOR:
118 return EFFECT_FLAG_VOLUME_MONITOR;
119 }
120 return unexpected(BAD_VALUE);
121}
122
123ConversionResult<Flags::Volume> legacy2aidl_uint32_Flags_Volume(uint32_t legacy) {
124 switch (legacy & EFFECT_FLAG_VOLUME_MASK) {
125 case EFFECT_FLAG_VOLUME_CTRL:
126 return Flags::Volume::CTRL;
127 case EFFECT_FLAG_VOLUME_IND:
128 return Flags::Volume::IND;
129 case EFFECT_FLAG_VOLUME_MONITOR:
130 return Flags::Volume::MONITOR;
131 case EFFECT_FLAG_VOLUME_NONE:
132 return Flags::Volume::NONE;
133 }
134 return unexpected(BAD_VALUE);
135}
136
137ConversionResult<uint32_t> aidl2legacy_Flags_uint32(Flags aidl) {
138 uint32_t legacy = 0;
139 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Type_uint32(aidl.type));
140 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Insert_uint32(aidl.insert));
141 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Volume_uint32(aidl.volume));
142 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_HardwareAccelerator_uint32(aidl.hwAcceleratorMode));
143
144 if (aidl.offloadIndication) {
145 legacy |= EFFECT_FLAG_OFFLOAD_SUPPORTED;
146 }
147 if (aidl.deviceIndication) {
148 legacy |= EFFECT_FLAG_DEVICE_IND;
149 }
150 if (aidl.audioModeIndication) {
151 legacy |= EFFECT_FLAG_AUDIO_MODE_IND;
152 }
153 if (aidl.audioSourceIndication) {
154 legacy |= EFFECT_FLAG_AUDIO_SOURCE_IND;
155 }
Shunkai Yaofba5c2d2023-02-02 22:50:00 +0000156 if (aidl.bypass) {
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000157 legacy |= EFFECT_FLAG_NO_PROCESS;
158 }
159 return legacy;
160}
161
162ConversionResult<Flags> legacy2aidl_uint32_Flags(uint32_t legacy) {
163 Flags aidl;
164
165 aidl.type = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Type(legacy));
166 aidl.insert = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Insert(legacy));
167 aidl.volume = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Volume(legacy));
168 aidl.hwAcceleratorMode = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_HardwareAccelerator(legacy));
169 aidl.offloadIndication = (legacy & EFFECT_FLAG_OFFLOAD_SUPPORTED);
170 aidl.deviceIndication = (legacy & EFFECT_FLAG_DEVICE_IND);
171 aidl.audioModeIndication = (legacy & EFFECT_FLAG_AUDIO_MODE_IND);
172 aidl.audioSourceIndication = (legacy & EFFECT_FLAG_AUDIO_SOURCE_IND);
Shunkai Yaofba5c2d2023-02-02 22:50:00 +0000173 aidl.bypass = (legacy & EFFECT_FLAG_NO_PROCESS);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000174 return aidl;
175}
176
177ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(
178 Flags::HardwareAccelerator hwAcceleratorMode) {
179 switch (hwAcceleratorMode) {
180 case Flags::HardwareAccelerator::NONE:
181 return 0;
182 case Flags::HardwareAccelerator::SIMPLE:
183 return EFFECT_FLAG_HW_ACC_SIMPLE;
184 case Flags::HardwareAccelerator::TUNNEL:
185 return EFFECT_FLAG_HW_ACC_TUNNEL;
186 }
187 return unexpected(BAD_VALUE);
188}
189
190ConversionResult<Flags::HardwareAccelerator> legacy2aidl_uint32_Flags_HardwareAccelerator(
191 uint32_t legacy) {
192 switch (legacy & EFFECT_FLAG_HW_ACC_MASK) {
193 case EFFECT_FLAG_HW_ACC_SIMPLE:
194 return Flags::HardwareAccelerator::SIMPLE;
195 case EFFECT_FLAG_HW_ACC_TUNNEL:
196 return Flags::HardwareAccelerator::TUNNEL;
197 case 0:
198 return Flags::HardwareAccelerator::NONE;
199 }
200 return unexpected(BAD_VALUE);
201}
202
203ConversionResult<effect_descriptor_t>
204aidl2legacy_Descriptor_effect_descriptor(const Descriptor& aidl) {
205 effect_descriptor_t legacy;
206 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.type));
207 legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.uuid));
208 // legacy descriptor doesn't have proxy information
209 // proxy = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.proxy));
210 legacy.apiVersion = EFFECT_CONTROL_API_VERSION;
211 legacy.flags = VALUE_OR_RETURN(aidl2legacy_Flags_uint32(aidl.common.flags));
212 legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.cpuLoad));
213 legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.memoryUsage));
214 RETURN_IF_ERROR(aidl2legacy_string(aidl.common.name, legacy.name, sizeof(legacy.name)));
215 RETURN_IF_ERROR(aidl2legacy_string(aidl.common.implementor, legacy.implementor,
216 sizeof(legacy.implementor)));
217 return legacy;
218}
219
220ConversionResult<Descriptor>
221legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& legacy) {
222 Descriptor aidl;
223 aidl.common.id.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));
224 aidl.common.id.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));
225 // legacy descriptor doesn't have proxy information
226 // aidl.common.id.proxy
227 aidl.common.flags = VALUE_OR_RETURN(legacy2aidl_uint32_Flags(legacy.flags));
228 aidl.common.cpuLoad = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.cpuLoad));
229 aidl.common.memoryUsage = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.memoryUsage));
230 aidl.common.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
231 aidl.common.implementor =
232 VALUE_OR_RETURN(legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));
233 return aidl;
234}
235
236ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_echoDelay(const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000237 int echoDelay = VALUE_OR_RETURN(
238 GET_PARAMETER_SPECIFIC_FIELD(aidl, AcousticEchoCanceler, acousticEchoCanceler,
239 AcousticEchoCanceler::echoDelayUs, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000240 return VALUE_OR_RETURN(convertReinterpret<uint32_t>(echoDelay));
241}
242
243ConversionResult<Parameter> legacy2aidl_uint32_echoDelay_Parameter_aec(uint32_t legacy) {
244 int delay = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy));
245 return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, echoDelayUs, delay);
246}
247
248ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_mobileMode(const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000249 bool mobileMode = VALUE_OR_RETURN(
250 GET_PARAMETER_SPECIFIC_FIELD(aidl, AcousticEchoCanceler, acousticEchoCanceler,
251 AcousticEchoCanceler::mobileMode, bool));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000252 return VALUE_OR_RETURN(convertIntegral<uint32_t>(mobileMode));
253}
254
255ConversionResult<Parameter> legacy2aidl_uint32_mobileMode_Parameter_aec(uint32_t legacy) {
256 bool mode = VALUE_OR_RETURN(convertIntegral<bool>(legacy));
257 return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, mobileMode, mode);
258}
259
260ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(
261 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000262 int gain = VALUE_OR_RETURN(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530263 GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
264 AutomaticGainControlV2::fixedDigitalGainMb, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000265 return VALUE_OR_RETURN(convertReinterpret<uint32_t>(gain));
266}
267
268ConversionResult<Parameter> legacy2aidl_uint32_fixedDigitalGain_Parameter_agc(uint32_t legacy) {
269 int gain = VALUE_OR_RETURN(convertReinterpret<int>(legacy));
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530270 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
271 fixedDigitalGainMb, gain);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000272}
273
274ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_levelEstimator(
275 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000276 const auto& le = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530277 aidl, AutomaticGainControlV2, automaticGainControlV2,
278 AutomaticGainControlV2::levelEstimator, AutomaticGainControlV2::LevelEstimator));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000279 return static_cast<uint32_t>(le);
280}
281
282ConversionResult<Parameter> legacy2aidl_uint32_levelEstimator_Parameter_agc(uint32_t legacy) {
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530283 if (legacy > (uint32_t)AutomaticGainControlV2::LevelEstimator::PEAK) {
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000284 return unexpected(BAD_VALUE);
285 }
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530286 AutomaticGainControlV2::LevelEstimator le =
287 static_cast<AutomaticGainControlV2::LevelEstimator>(legacy);
288 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2, levelEstimator,
289 le);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000290}
291
292ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_saturationMargin(
293 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000294 int saturationMargin = VALUE_OR_RETURN(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530295 GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
296 AutomaticGainControlV2::saturationMarginMb, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000297 return VALUE_OR_RETURN(convertIntegral<uint32_t>(saturationMargin));
298}
299
300ConversionResult<Parameter> legacy2aidl_uint32_saturationMargin_Parameter_agc(uint32_t legacy) {
301 int saturationMargin = VALUE_OR_RETURN(convertIntegral<int>(legacy));
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530302 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
303 saturationMarginMb, saturationMargin);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000304}
305
306ConversionResult<uint16_t> aidl2legacy_Parameter_BassBoost_uint16_strengthPm(
307 const Parameter& aidl) {
308 int strength = VALUE_OR_RETURN(
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000309 GET_PARAMETER_SPECIFIC_FIELD(aidl, BassBoost, bassBoost, BassBoost::strengthPm, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000310 return VALUE_OR_RETURN(convertIntegral<uint16_t>(strength));
311}
312
313ConversionResult<Parameter> legacy2aidl_uint16_strengthPm_Parameter_BassBoost(uint16_t legacy) {
314 int strength = VALUE_OR_RETURN(convertIntegral<int>(legacy));
315 return MAKE_SPECIFIC_PARAMETER(BassBoost, bassBoost, strengthPm, strength);
316}
317
318ConversionResult<int16_t> aidl2legacy_Parameter_Downmix_int16_type(const Parameter& aidl) {
319 Downmix::Type aidlType = VALUE_OR_RETURN(
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000320 GET_PARAMETER_SPECIFIC_FIELD(aidl, Downmix, downmix, Downmix::type, Downmix::Type));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000321 return VALUE_OR_RETURN(convertIntegral<int16_t>(static_cast<uint32_t>(aidlType)));
322}
323
324ConversionResult<Parameter> legacy2aidl_int16_type_Parameter_Downmix(int16_t legacy) {
325 if (legacy > (uint32_t) Downmix::Type::FOLD) {
326 return unexpected(BAD_VALUE);
327 }
328 Downmix::Type aidlType = static_cast<Downmix::Type>(legacy);
329 return MAKE_SPECIFIC_PARAMETER(Downmix, downmix, type, aidlType);
330}
331
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000332ConversionResult<int16_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_uint32_(
333 const Parameter& aidl) {
334 Downmix::Type aidlType = VALUE_OR_RETURN(
335 GET_PARAMETER_SPECIFIC_FIELD(aidl, Downmix, downmix, Downmix::type, Downmix::Type));
336 return VALUE_OR_RETURN(convertIntegral<int16_t>(static_cast<uint32_t>(aidlType)));
337}
338
339ConversionResult<DynamicsProcessing::ResolutionPreference>
340legacy2aidl_int32_DynamicsProcessing_ResolutionPreference(int32_t legacy) {
341 if (legacy > (int32_t)DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION) {
342 return unexpected(BAD_VALUE);
343 }
344 return static_cast<DynamicsProcessing::ResolutionPreference>(legacy);
345}
346
347ConversionResult<int32_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_int32(
348 DynamicsProcessing::ResolutionPreference aidl) {
349 return static_cast<int32_t>(aidl);
350}
351
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000352} // namespace android
353} // aidl