blob: 611cfab38821d029e751668728876a4b2e752159 [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
Shunkai Yao04b073a2023-02-17 06:17:12 +000017#include <cstdint>
18#include <inttypes.h>
Shunkai Yaoa03533e2023-01-25 06:38:10 +000019#include <utility>
20
21#define LOG_TAG "AidlConversionEffect"
22//#define LOG_NDEBUG 0
23#include <utils/Log.h>
24
Shunkai Yao04b073a2023-02-17 06:17:12 +000025#include <aidl/android/hardware/audio/effect/DefaultExtension.h>
26#include <aidl/android/hardware/audio/effect/VendorExtension.h>
Shunkai Yaoa03533e2023-01-25 06:38:10 +000027#include <media/AidlConversionCppNdk.h>
28#include <media/AidlConversionEffect.h>
29
30////////////////////////////////////////////////////////////////////////////////////////////////////
31// AIDL NDK backend to legacy audio data structure conversion utilities.
32
33namespace aidl {
34namespace android {
35
36using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
Shraddha Basantwani64db6d42023-02-01 16:24:19 +053037using ::aidl::android::hardware::audio::effect::AutomaticGainControlV2;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000038using ::aidl::android::hardware::audio::effect::BassBoost;
Shunkai Yao04b073a2023-02-17 06:17:12 +000039using ::aidl::android::hardware::audio::effect::DefaultExtension;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000040using ::aidl::android::hardware::audio::effect::Descriptor;
41using ::aidl::android::hardware::audio::effect::Downmix;
Shunkai Yaodba8ba32023-01-27 17:02:21 +000042using ::aidl::android::hardware::audio::effect::DynamicsProcessing;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000043using ::aidl::android::hardware::audio::effect::Flags;
44using ::aidl::android::hardware::audio::effect::Parameter;
Shunkai Yao242521c2023-01-29 18:08:09 +000045using ::aidl::android::hardware::audio::effect::PresetReverb;
Shunkai Yao04b073a2023-02-17 06:17:12 +000046using ::aidl::android::hardware::audio::effect::VendorExtension;
47using ::aidl::android::hardware::audio::effect::Visualizer;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000048using ::aidl::android::media::audio::common::AudioDeviceDescription;
49
50using ::android::BAD_VALUE;
Shunkai Yaoda4a6402023-03-03 19:38:17 +000051using ::android::OK;
Mikhail Naganov893b7c22023-03-13 15:48:11 -070052using ::android::status_t;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000053using ::android::base::unexpected;
Shunkai Yao04b073a2023-02-17 06:17:12 +000054using ::android::effect::utils::EffectParamReader;
55using ::android::effect::utils::EffectParamWriter;
Shunkai Yaoa03533e2023-01-25 06:38:10 +000056
57////////////////////////////////////////////////////////////////////////////////////////////////////
58// Converters
59
60ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(Flags::Type type) {
61 switch (type) {
62 case Flags::Type::INSERT:
63 return EFFECT_FLAG_TYPE_INSERT;
64 case Flags::Type::AUXILIARY:
65 return EFFECT_FLAG_TYPE_AUXILIARY;
66 case Flags::Type::REPLACE:
67 return EFFECT_FLAG_TYPE_REPLACE;
68 case Flags::Type::PRE_PROC:
69 return EFFECT_FLAG_TYPE_PRE_PROC;
70 case Flags::Type::POST_PROC:
71 return EFFECT_FLAG_TYPE_POST_PROC;
72 }
73 return unexpected(BAD_VALUE);
74}
75
76ConversionResult<Flags::Type> legacy2aidl_uint32_Flags_Type(uint32_t legacy) {
77 switch (legacy & EFFECT_FLAG_TYPE_MASK) {
78 case EFFECT_FLAG_TYPE_INSERT:
79 return Flags::Type::INSERT;
80 case EFFECT_FLAG_TYPE_AUXILIARY:
81 return Flags::Type::AUXILIARY;
82 case EFFECT_FLAG_TYPE_REPLACE:
83 return Flags::Type::REPLACE;
84 case EFFECT_FLAG_TYPE_PRE_PROC:
85 return Flags::Type::PRE_PROC;
86 case EFFECT_FLAG_TYPE_POST_PROC:
87 return Flags::Type::POST_PROC;
88 }
89 return unexpected(BAD_VALUE);
90}
91
92ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(Flags::Insert insert) {
93 switch (insert) {
94 case Flags::Insert::ANY:
95 return EFFECT_FLAG_INSERT_ANY;
96 case Flags::Insert::FIRST:
97 return EFFECT_FLAG_INSERT_FIRST;
98 case Flags::Insert::LAST:
99 return EFFECT_FLAG_INSERT_LAST;
100 case Flags::Insert::EXCLUSIVE:
101 return EFFECT_FLAG_INSERT_EXCLUSIVE;
102 }
103 return unexpected(BAD_VALUE);
104}
105
106ConversionResult<Flags::Insert> legacy2aidl_uint32_Flags_Insert(uint32_t legacy) {
107 switch (legacy & EFFECT_FLAG_INSERT_MASK) {
108 case EFFECT_FLAG_INSERT_ANY:
109 return Flags::Insert::ANY;
110 case EFFECT_FLAG_INSERT_FIRST:
111 return Flags::Insert::FIRST;
112 case EFFECT_FLAG_INSERT_LAST:
113 return Flags::Insert::LAST;
114 case EFFECT_FLAG_INSERT_EXCLUSIVE:
115 return Flags::Insert::EXCLUSIVE;
116 }
117 return unexpected(BAD_VALUE);
118}
119
120ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(Flags::Volume volume) {
121 switch (volume) {
122 case Flags::Volume::NONE:
123 return 0;
124 case Flags::Volume::CTRL:
125 return EFFECT_FLAG_VOLUME_CTRL;
126 case Flags::Volume::IND:
127 return EFFECT_FLAG_VOLUME_IND;
128 case Flags::Volume::MONITOR:
129 return EFFECT_FLAG_VOLUME_MONITOR;
130 }
131 return unexpected(BAD_VALUE);
132}
133
134ConversionResult<Flags::Volume> legacy2aidl_uint32_Flags_Volume(uint32_t legacy) {
135 switch (legacy & EFFECT_FLAG_VOLUME_MASK) {
136 case EFFECT_FLAG_VOLUME_CTRL:
137 return Flags::Volume::CTRL;
138 case EFFECT_FLAG_VOLUME_IND:
139 return Flags::Volume::IND;
140 case EFFECT_FLAG_VOLUME_MONITOR:
141 return Flags::Volume::MONITOR;
142 case EFFECT_FLAG_VOLUME_NONE:
143 return Flags::Volume::NONE;
144 }
145 return unexpected(BAD_VALUE);
146}
147
148ConversionResult<uint32_t> aidl2legacy_Flags_uint32(Flags aidl) {
149 uint32_t legacy = 0;
150 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Type_uint32(aidl.type));
151 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Insert_uint32(aidl.insert));
152 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Volume_uint32(aidl.volume));
153 legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_HardwareAccelerator_uint32(aidl.hwAcceleratorMode));
154
155 if (aidl.offloadIndication) {
156 legacy |= EFFECT_FLAG_OFFLOAD_SUPPORTED;
157 }
158 if (aidl.deviceIndication) {
159 legacy |= EFFECT_FLAG_DEVICE_IND;
160 }
161 if (aidl.audioModeIndication) {
162 legacy |= EFFECT_FLAG_AUDIO_MODE_IND;
163 }
164 if (aidl.audioSourceIndication) {
165 legacy |= EFFECT_FLAG_AUDIO_SOURCE_IND;
166 }
Shunkai Yaofba5c2d2023-02-02 22:50:00 +0000167 if (aidl.bypass) {
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000168 legacy |= EFFECT_FLAG_NO_PROCESS;
169 }
170 return legacy;
171}
172
173ConversionResult<Flags> legacy2aidl_uint32_Flags(uint32_t legacy) {
174 Flags aidl;
175
176 aidl.type = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Type(legacy));
177 aidl.insert = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Insert(legacy));
178 aidl.volume = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Volume(legacy));
179 aidl.hwAcceleratorMode = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_HardwareAccelerator(legacy));
180 aidl.offloadIndication = (legacy & EFFECT_FLAG_OFFLOAD_SUPPORTED);
181 aidl.deviceIndication = (legacy & EFFECT_FLAG_DEVICE_IND);
182 aidl.audioModeIndication = (legacy & EFFECT_FLAG_AUDIO_MODE_IND);
183 aidl.audioSourceIndication = (legacy & EFFECT_FLAG_AUDIO_SOURCE_IND);
Shunkai Yaofba5c2d2023-02-02 22:50:00 +0000184 aidl.bypass = (legacy & EFFECT_FLAG_NO_PROCESS);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000185 return aidl;
186}
187
188ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(
189 Flags::HardwareAccelerator hwAcceleratorMode) {
190 switch (hwAcceleratorMode) {
191 case Flags::HardwareAccelerator::NONE:
192 return 0;
193 case Flags::HardwareAccelerator::SIMPLE:
194 return EFFECT_FLAG_HW_ACC_SIMPLE;
195 case Flags::HardwareAccelerator::TUNNEL:
196 return EFFECT_FLAG_HW_ACC_TUNNEL;
197 }
198 return unexpected(BAD_VALUE);
199}
200
201ConversionResult<Flags::HardwareAccelerator> legacy2aidl_uint32_Flags_HardwareAccelerator(
202 uint32_t legacy) {
203 switch (legacy & EFFECT_FLAG_HW_ACC_MASK) {
204 case EFFECT_FLAG_HW_ACC_SIMPLE:
205 return Flags::HardwareAccelerator::SIMPLE;
206 case EFFECT_FLAG_HW_ACC_TUNNEL:
207 return Flags::HardwareAccelerator::TUNNEL;
208 case 0:
209 return Flags::HardwareAccelerator::NONE;
210 }
211 return unexpected(BAD_VALUE);
212}
213
214ConversionResult<effect_descriptor_t>
215aidl2legacy_Descriptor_effect_descriptor(const Descriptor& aidl) {
216 effect_descriptor_t legacy;
217 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.type));
218 legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.uuid));
219 // legacy descriptor doesn't have proxy information
220 // proxy = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.proxy));
221 legacy.apiVersion = EFFECT_CONTROL_API_VERSION;
222 legacy.flags = VALUE_OR_RETURN(aidl2legacy_Flags_uint32(aidl.common.flags));
223 legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.cpuLoad));
224 legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.memoryUsage));
225 RETURN_IF_ERROR(aidl2legacy_string(aidl.common.name, legacy.name, sizeof(legacy.name)));
226 RETURN_IF_ERROR(aidl2legacy_string(aidl.common.implementor, legacy.implementor,
227 sizeof(legacy.implementor)));
228 return legacy;
229}
230
231ConversionResult<Descriptor>
232legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& legacy) {
233 Descriptor aidl;
234 aidl.common.id.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));
235 aidl.common.id.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));
236 // legacy descriptor doesn't have proxy information
237 // aidl.common.id.proxy
238 aidl.common.flags = VALUE_OR_RETURN(legacy2aidl_uint32_Flags(legacy.flags));
239 aidl.common.cpuLoad = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.cpuLoad));
240 aidl.common.memoryUsage = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.memoryUsage));
241 aidl.common.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
242 aidl.common.implementor =
243 VALUE_OR_RETURN(legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));
244 return aidl;
245}
246
247ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_echoDelay(const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000248 int echoDelay = VALUE_OR_RETURN(
249 GET_PARAMETER_SPECIFIC_FIELD(aidl, AcousticEchoCanceler, acousticEchoCanceler,
250 AcousticEchoCanceler::echoDelayUs, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000251 return VALUE_OR_RETURN(convertReinterpret<uint32_t>(echoDelay));
252}
253
254ConversionResult<Parameter> legacy2aidl_uint32_echoDelay_Parameter_aec(uint32_t legacy) {
255 int delay = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy));
256 return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, echoDelayUs, delay);
257}
258
259ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_mobileMode(const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000260 bool mobileMode = VALUE_OR_RETURN(
261 GET_PARAMETER_SPECIFIC_FIELD(aidl, AcousticEchoCanceler, acousticEchoCanceler,
262 AcousticEchoCanceler::mobileMode, bool));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000263 return VALUE_OR_RETURN(convertIntegral<uint32_t>(mobileMode));
264}
265
266ConversionResult<Parameter> legacy2aidl_uint32_mobileMode_Parameter_aec(uint32_t legacy) {
267 bool mode = VALUE_OR_RETURN(convertIntegral<bool>(legacy));
268 return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, mobileMode, mode);
269}
270
271ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(
272 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000273 int gain = VALUE_OR_RETURN(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530274 GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
275 AutomaticGainControlV2::fixedDigitalGainMb, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000276 return VALUE_OR_RETURN(convertReinterpret<uint32_t>(gain));
277}
278
279ConversionResult<Parameter> legacy2aidl_uint32_fixedDigitalGain_Parameter_agc(uint32_t legacy) {
280 int gain = VALUE_OR_RETURN(convertReinterpret<int>(legacy));
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530281 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
282 fixedDigitalGainMb, gain);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000283}
284
285ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_levelEstimator(
286 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000287 const auto& le = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530288 aidl, AutomaticGainControlV2, automaticGainControlV2,
289 AutomaticGainControlV2::levelEstimator, AutomaticGainControlV2::LevelEstimator));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000290 return static_cast<uint32_t>(le);
291}
292
293ConversionResult<Parameter> legacy2aidl_uint32_levelEstimator_Parameter_agc(uint32_t legacy) {
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530294 if (legacy > (uint32_t)AutomaticGainControlV2::LevelEstimator::PEAK) {
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000295 return unexpected(BAD_VALUE);
296 }
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530297 AutomaticGainControlV2::LevelEstimator le =
298 static_cast<AutomaticGainControlV2::LevelEstimator>(legacy);
299 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2, levelEstimator,
300 le);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000301}
302
303ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_saturationMargin(
304 const Parameter& aidl) {
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000305 int saturationMargin = VALUE_OR_RETURN(
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530306 GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
307 AutomaticGainControlV2::saturationMarginMb, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000308 return VALUE_OR_RETURN(convertIntegral<uint32_t>(saturationMargin));
309}
310
311ConversionResult<Parameter> legacy2aidl_uint32_saturationMargin_Parameter_agc(uint32_t legacy) {
312 int saturationMargin = VALUE_OR_RETURN(convertIntegral<int>(legacy));
Shraddha Basantwani64db6d42023-02-01 16:24:19 +0530313 return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
314 saturationMarginMb, saturationMargin);
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000315}
316
317ConversionResult<uint16_t> aidl2legacy_Parameter_BassBoost_uint16_strengthPm(
318 const Parameter& aidl) {
319 int strength = VALUE_OR_RETURN(
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000320 GET_PARAMETER_SPECIFIC_FIELD(aidl, BassBoost, bassBoost, BassBoost::strengthPm, int));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000321 return VALUE_OR_RETURN(convertIntegral<uint16_t>(strength));
322}
323
324ConversionResult<Parameter> legacy2aidl_uint16_strengthPm_Parameter_BassBoost(uint16_t legacy) {
325 int strength = VALUE_OR_RETURN(convertIntegral<int>(legacy));
326 return MAKE_SPECIFIC_PARAMETER(BassBoost, bassBoost, strengthPm, strength);
327}
328
329ConversionResult<int16_t> aidl2legacy_Parameter_Downmix_int16_type(const Parameter& aidl) {
330 Downmix::Type aidlType = VALUE_OR_RETURN(
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000331 GET_PARAMETER_SPECIFIC_FIELD(aidl, Downmix, downmix, Downmix::type, Downmix::Type));
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000332 return VALUE_OR_RETURN(convertIntegral<int16_t>(static_cast<uint32_t>(aidlType)));
333}
334
335ConversionResult<Parameter> legacy2aidl_int16_type_Parameter_Downmix(int16_t legacy) {
336 if (legacy > (uint32_t) Downmix::Type::FOLD) {
337 return unexpected(BAD_VALUE);
338 }
339 Downmix::Type aidlType = static_cast<Downmix::Type>(legacy);
340 return MAKE_SPECIFIC_PARAMETER(Downmix, downmix, type, aidlType);
341}
342
Shunkai Yaodba8ba32023-01-27 17:02:21 +0000343ConversionResult<int16_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_uint32_(
344 const Parameter& aidl) {
345 Downmix::Type aidlType = VALUE_OR_RETURN(
346 GET_PARAMETER_SPECIFIC_FIELD(aidl, Downmix, downmix, Downmix::type, Downmix::Type));
347 return VALUE_OR_RETURN(convertIntegral<int16_t>(static_cast<uint32_t>(aidlType)));
348}
349
350ConversionResult<DynamicsProcessing::ResolutionPreference>
351legacy2aidl_int32_DynamicsProcessing_ResolutionPreference(int32_t legacy) {
352 if (legacy > (int32_t)DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION) {
353 return unexpected(BAD_VALUE);
354 }
355 return static_cast<DynamicsProcessing::ResolutionPreference>(legacy);
356}
357
358ConversionResult<int32_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_int32(
359 DynamicsProcessing::ResolutionPreference aidl) {
360 return static_cast<int32_t>(aidl);
361}
362
Shunkai Yao04b073a2023-02-17 06:17:12 +0000363ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_ScalingMode_uint32(
364 Visualizer::ScalingMode aidl) {
365 switch (aidl) {
366 case Visualizer::ScalingMode::NORMALIZED: {
367 return 0;
368 }
369 case Visualizer::ScalingMode::AS_PLAYED: {
370 return 1;
371 }
372 }
373 return unexpected(BAD_VALUE);
374}
375
376ConversionResult<Visualizer::ScalingMode> legacy2aidl_Parameter_Visualizer_uint32_ScalingMode(
377 uint32_t legacy) {
378 if (legacy == 0) {
379 return Visualizer::ScalingMode::NORMALIZED;
380 } else if (legacy == 1) {
381 return Visualizer::ScalingMode::AS_PLAYED;
382 } else {
383 return unexpected(BAD_VALUE);
384 }
385}
386
387ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_MeasurementMode_uint32(
388 Visualizer::MeasurementMode aidl) {
389 switch (aidl) {
390 case Visualizer::MeasurementMode::NONE: {
391 return 0;
392 }
393 case Visualizer::MeasurementMode::PEAK_RMS: {
394 return 1;
395 }
396 }
397 return unexpected(BAD_VALUE);
398}
399
400ConversionResult<Visualizer::MeasurementMode>
401legacy2aidl_Parameter_Visualizer_uint32_MeasurementMode(uint32_t legacy) {
402 if (legacy == 0) {
403 return Visualizer::MeasurementMode::NONE;
404 } else if (legacy == 1) {
405 return Visualizer::MeasurementMode::PEAK_RMS;
406 } else {
407 return unexpected(BAD_VALUE);
408 }
409}
410
411/**
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000412 * Copy the parameter area of effect_param_t to DefaultExtension::bytes.
Shunkai Yao04b073a2023-02-17 06:17:12 +0000413 */
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000414ConversionResult<VendorExtension> legacy2aidl_EffectParameterReader_Param_VendorExtension(
Shunkai Yao04b073a2023-02-17 06:17:12 +0000415 EffectParamReader& param) {
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000416 size_t len = param.getParameterSize();
417 DefaultExtension defaultExt;
418 defaultExt.bytes.resize(len);
419 RETURN_IF_ERROR(param.readFromParameter(defaultExt.bytes.data(), len));
Shunkai Yao04b073a2023-02-17 06:17:12 +0000420
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000421 VendorExtension ext;
422 ext.extension.setParcelable(defaultExt);
423 return ext;
Shunkai Yao04b073a2023-02-17 06:17:12 +0000424}
425
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000426/**
427 * Copy the data area of effect_param_t to DefaultExtension::bytes.
428 */
429ConversionResult<VendorExtension> legacy2aidl_EffectParameterReader_Data_VendorExtension(
430 EffectParamReader& param) {
431 size_t len = param.getValueSize();
432 DefaultExtension defaultExt;
433 defaultExt.bytes.resize(len);
434 RETURN_IF_ERROR(param.readFromValue(defaultExt.bytes.data(), len));
435
436 VendorExtension ext;
437 ext.extension.setParcelable(defaultExt);
438 return ext;
439}
440
441/**
442 * Copy DefaultExtension::bytes to the data area of effect_param_t.
443 */
444ConversionResult<status_t> aidl2legacy_VendorExtension_EffectParameterWriter_Data(
445 EffectParamWriter& param, VendorExtension ext) {
446 std::optional<DefaultExtension> defaultExt;
447 RETURN_IF_ERROR(ext.extension.getParcelable(&defaultExt));
448 if (!defaultExt.has_value()) {
Shunkai Yao04b073a2023-02-17 06:17:12 +0000449 return unexpected(BAD_VALUE);
450 }
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000451
452 RETURN_IF_ERROR(param.writeToValue(defaultExt->bytes.data(), defaultExt->bytes.size()));
453
454 return OK;
455}
456
457ConversionResult<Parameter> legacy2aidl_EffectParameterReader_ParameterExtension(
458 EffectParamReader& param) {
459 VendorExtension ext =
460 VALUE_OR_RETURN(legacy2aidl_EffectParameterReader_Data_VendorExtension(param));
461 return UNION_MAKE(Parameter, specific, UNION_MAKE(Parameter::Specific, vendorEffect, ext));
Shunkai Yao04b073a2023-02-17 06:17:12 +0000462}
463
464ConversionResult<::android::status_t> aidl2legacy_ParameterExtension_EffectParameterWriter(
465 const ::aidl::android::hardware::audio::effect::Parameter& aidl,
466 EffectParamWriter& legacy) {
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000467 VendorExtension ext = VALUE_OR_RETURN(
468 (::aidl::android::getParameterSpecific<Parameter, VendorExtension,
469 Parameter::Specific::vendorEffect>(aidl)));
470 return VALUE_OR_RETURN_STATUS(
471 aidl2legacy_VendorExtension_EffectParameterWriter_Data(legacy, ext));
Shunkai Yao04b073a2023-02-17 06:17:12 +0000472}
473
Shunkai Yaoa03533e2023-01-25 06:38:10 +0000474} // namespace android
475} // aidl