Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / 10dc0a6f628f2d216ce44ad9a6184af88a0f13d9 / . / media / libaudioclient / AidlConversion.cpp
blob: 95a6a4a0912c053dfd416c01c6427c5ff3ec2679 [file] [log] [blame]
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700[diff] [blame^]1/*
2 * Copyright (C) 2020 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 <limits>
18
19#define LOG_TAG "AidlConversion"
20//#define LOG_NDEBUG 0
21#include <system/audio.h>
22#include <utils/Log.h>
23
24#include "media/AidlConversion.h"
25
26#define VALUE_OR_RETURN(result) \
27 ({ \
28 auto _tmp = (result); \
29 if (!_tmp.ok()) return unexpected(_tmp.error()); \
30 _tmp.value(); \
31 })
32
33////////////////////////////////////////////////////////////////////////////////////////////////////
34// Utilities
35
36namespace android {
37
38using base::unexpected;
39
40namespace {
41
42////////////////////////////////////////////////////////////////////////////////////////////////////
43// The code below establishes:
44// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
45// enum types (in which case it evaluates to std::underlying_type_T<T>).
46
47template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
48struct IntegralTypeOfStruct {
49 using Type = T;
50};
51
52template<typename T>
53struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
54 using Type = std::underlying_type_t<T>;
55};
56
57template<typename T>
58using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;
59
60////////////////////////////////////////////////////////////////////////////////////////////////////
61// Utilities for handling bitmasks.
62
63template<typename Enum>
64Enum index2enum_index(int index) {
65 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
66 return static_cast<Enum>(index);
67}
68
69template<typename Enum>
70Enum index2enum_bitmask(int index) {
71 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
72 return static_cast<Enum>(1 << index);
73}
74
75template<typename Mask, typename Enum>
76Mask enumToMask_bitmask(Enum e) {
77 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
78 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
79 return static_cast<Mask>(e);
80}
81
82template<typename Mask, typename Enum>
83Mask enumToMask_index(Enum e) {
84 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
85 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
86 return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
87 << static_cast<int>(e));
88}
89
90template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
91ConversionResult<DestMask> convertBitmask(
92 SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
93 const std::function<SrcEnum(int)>& srcIndexToEnum,
94 const std::function<DestMask(DestEnum)>& destEnumToMask) {
95 using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
96 using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;
97
98 UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
99 UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);
100
101 int srcBitIndex = 0;
102 while (usrc != 0) {
103 if (usrc & 1) {
104 SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
105 DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
106 DestMask destMask = destEnumToMask(destEnum);
107 dest |= destMask;
108 }
109 ++srcBitIndex;
110 usrc >>= 1;
111 }
112 return static_cast<DestMask>(dest);
113}
114
115template<typename Mask, typename Enum>
116bool bitmaskIsSet(Mask mask, Enum index) {
117 return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
118}
119
120////////////////////////////////////////////////////////////////////////////////////////////////////
121
122template<typename To, typename From>
123ConversionResult<To> convertIntegral(From from) {
124 // Special handling is required for signed / vs. unsigned comparisons, since otherwise we may
125 // have the signed converted to unsigned and produce wrong results.
126 if (std::is_signed_v<From> && !std::is_signed_v<To>) {
127 if (from < 0 || from > std::numeric_limits<To>::max()) {
128 return unexpected(BAD_VALUE);
129 }
130 } else if (std::is_signed_v<To> && !std::is_signed_v<From>) {
131 if (from > std::numeric_limits<To>::max()) {
132 return unexpected(BAD_VALUE);
133 }
134 } else {
135 if (from < std::numeric_limits<To>::min() || from > std::numeric_limits<To>::max()) {
136 return unexpected(BAD_VALUE);
137 }
138 }
139 return static_cast<To>(from);
140}
141
142template<typename To, typename From>
143ConversionResult<To> convertReinterpret(From from) {
144 static_assert(sizeof(From) == sizeof(To));
145 return static_cast<To>(from);
146}
147
148enum class Direction {
149 INPUT, OUTPUT
150};
151
152ConversionResult<Direction> direction(media::AudioPortRole role, media::AudioPortType type) {
153 switch (type) {
154 case media::AudioPortType::DEVICE:
155 switch (role) {
156 case media::AudioPortRole::SOURCE:
157 return Direction::INPUT;
158 case media::AudioPortRole::SINK:
159 return Direction::OUTPUT;
160 default:
161 break;
162 }
163 break;
164 case media::AudioPortType::MIX:
165 switch (role) {
166 case media::AudioPortRole::SOURCE:
167 return Direction::OUTPUT;
168 case media::AudioPortRole::SINK:
169 return Direction::INPUT;
170 default:
171 break;
172 }
173 break;
174 default:
175 break;
176 }
177 return unexpected(BAD_VALUE);
178}
179
180ConversionResult<Direction> direction(audio_port_role_t role, audio_port_type_t type) {
181 switch (type) {
182 case AUDIO_PORT_TYPE_DEVICE:
183 switch (role) {
184 case AUDIO_PORT_ROLE_SOURCE:
185 return Direction::INPUT;
186 case AUDIO_PORT_ROLE_SINK:
187 return Direction::OUTPUT;
188 default:
189 break;
190 }
191 break;
192 case AUDIO_PORT_TYPE_MIX:
193 switch (role) {
194 case AUDIO_PORT_ROLE_SOURCE:
195 return Direction::OUTPUT;
196 case AUDIO_PORT_ROLE_SINK:
197 return Direction::INPUT;
198 default:
199 break;
200 }
201 break;
202 default:
203 break;
204 }
205 return unexpected(BAD_VALUE);
206}
207
208} // namespace
209
210////////////////////////////////////////////////////////////////////////////////////////////////////
211// Converters
212
213// The legacy enum is unnamed. Thus, we use int.
214ConversionResult<int> aidl2legacy_AudioPortConfigType(media::AudioPortConfigType aidl) {
215 switch (aidl) {
216 case media::AudioPortConfigType::SAMPLE_RATE:
217 return AUDIO_PORT_CONFIG_SAMPLE_RATE;
218 case media::AudioPortConfigType::CHANNEL_MASK:
219 return AUDIO_PORT_CONFIG_CHANNEL_MASK;
220 case media::AudioPortConfigType::FORMAT:
221 return AUDIO_PORT_CONFIG_FORMAT;
222 case media::AudioPortConfigType::FLAGS:
223 return AUDIO_PORT_CONFIG_FLAGS;
224 default:
225 return unexpected(BAD_VALUE);
226 }
227}
228
229// The legacy enum is unnamed. Thus, we use int.
230ConversionResult<media::AudioPortConfigType> legacy2aidl_AudioPortConfigType(int legacy) {
231 switch (legacy) {
232 case AUDIO_PORT_CONFIG_SAMPLE_RATE:
233 return media::AudioPortConfigType::SAMPLE_RATE;
234 case AUDIO_PORT_CONFIG_CHANNEL_MASK:
235 return media::AudioPortConfigType::CHANNEL_MASK;
236 case AUDIO_PORT_CONFIG_FORMAT:
237 return media::AudioPortConfigType::FORMAT;
238 case AUDIO_PORT_CONFIG_FLAGS:
239 return media::AudioPortConfigType::FLAGS;
240 default:
241 return unexpected(BAD_VALUE);
242 }
243}
244
245ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl) {
246 return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(
247 aidl, aidl2legacy_AudioPortConfigType,
248 // AudioPortConfigType enum is index-based.
249 index2enum_index<media::AudioPortConfigType>,
250 // AUDIO_PORT_CONFIG_* flags are mask-based.
251 enumToMask_bitmask<unsigned int, int>);
252}
253
254ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) {
255 return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(
256 legacy, legacy2aidl_AudioPortConfigType,
257 // AUDIO_PORT_CONFIG_* flags are mask-based.
258 index2enum_bitmask<unsigned>,
259 // AudioPortConfigType enum is index-based.
260 enumToMask_index<int32_t, media::AudioPortConfigType>);
261}
262
263ConversionResult<audio_channel_mask_t> aidl2legacy_int32_t_audio_channel_mask_t(int32_t aidl) {
264 // TODO(ytai): should we convert bit-by-bit?
265 // One problem here is that the representation is both opaque and is different based on the
266 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
267 return convertReinterpret<audio_channel_mask_t>(aidl);
268}
269
270ConversionResult<int32_t> legacy2aidl_audio_channel_mask_t_int32_t(audio_channel_mask_t legacy) {
271 // TODO(ytai): should we convert bit-by-bit?
272 // One problem here is that the representation is both opaque and is different based on the
273 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
274 return convertReinterpret<int32_t>(legacy);
275}
276
277ConversionResult<audio_io_config_event> aidl2legacy_AudioIoConfigEvent_audio_io_config_event(
278 media::AudioIoConfigEvent aidl) {
279 switch (aidl) {
280 case media::AudioIoConfigEvent::OUTPUT_REGISTERED:
281 return AUDIO_OUTPUT_REGISTERED;
282 case media::AudioIoConfigEvent::OUTPUT_OPENED:
283 return AUDIO_OUTPUT_OPENED;
284 case media::AudioIoConfigEvent::OUTPUT_CLOSED:
285 return AUDIO_OUTPUT_CLOSED;
286 case media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED:
287 return AUDIO_OUTPUT_CONFIG_CHANGED;
288 case media::AudioIoConfigEvent::INPUT_REGISTERED:
289 return AUDIO_INPUT_REGISTERED;
290 case media::AudioIoConfigEvent::INPUT_OPENED:
291 return AUDIO_INPUT_OPENED;
292 case media::AudioIoConfigEvent::INPUT_CLOSED:
293 return AUDIO_INPUT_CLOSED;
294 case media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED:
295 return AUDIO_INPUT_CONFIG_CHANGED;
296 case media::AudioIoConfigEvent::CLIENT_STARTED:
297 return AUDIO_CLIENT_STARTED;
298 default:
299 return unexpected(BAD_VALUE);
300 }
301}
302
303ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_AudioIoConfigEvent(
304 audio_io_config_event legacy) {
305 switch (legacy) {
306 case AUDIO_OUTPUT_REGISTERED:
307 return media::AudioIoConfigEvent::OUTPUT_REGISTERED;
308 case AUDIO_OUTPUT_OPENED:
309 return media::AudioIoConfigEvent::OUTPUT_OPENED;
310 case AUDIO_OUTPUT_CLOSED:
311 return media::AudioIoConfigEvent::OUTPUT_CLOSED;
312 case AUDIO_OUTPUT_CONFIG_CHANGED:
313 return media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED;
314 case AUDIO_INPUT_REGISTERED:
315 return media::AudioIoConfigEvent::INPUT_REGISTERED;
316 case AUDIO_INPUT_OPENED:
317 return media::AudioIoConfigEvent::INPUT_OPENED;
318 case AUDIO_INPUT_CLOSED:
319 return media::AudioIoConfigEvent::INPUT_CLOSED;
320 case AUDIO_INPUT_CONFIG_CHANGED:
321 return media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED;
322 case AUDIO_CLIENT_STARTED:
323 return media::AudioIoConfigEvent::CLIENT_STARTED;
324 default:
325 return unexpected(BAD_VALUE);
326 }
327}
328
329ConversionResult<audio_port_role_t> aidl2legacy_AudioPortRole_audio_port_role_t(
330 media::AudioPortRole aidl) {
331 switch (aidl) {
332 case media::AudioPortRole::NONE:
333 return AUDIO_PORT_ROLE_NONE;
334 case media::AudioPortRole::SOURCE:
335 return AUDIO_PORT_ROLE_SOURCE;
336 case media::AudioPortRole::SINK:
337 return AUDIO_PORT_ROLE_SINK;
338 default:
339 return unexpected(BAD_VALUE);
340 }
341}
342
343ConversionResult<media::AudioPortRole> legacy2aidl_audio_port_role_t_AudioPortRole(
344 audio_port_role_t legacy) {
345 switch (legacy) {
346 case AUDIO_PORT_ROLE_NONE:
347 return media::AudioPortRole::NONE;
348 case AUDIO_PORT_ROLE_SOURCE:
349 return media::AudioPortRole::SOURCE;
350 case AUDIO_PORT_ROLE_SINK:
351 return media::AudioPortRole::SINK;
352 default:
353 return unexpected(BAD_VALUE);
354 }
355}
356
357ConversionResult<audio_port_type_t> aidl2legacy_AudioPortType_audio_port_type_t(
358 media::AudioPortType aidl) {
359 switch (aidl) {
360 case media::AudioPortType::NONE:
361 return AUDIO_PORT_TYPE_NONE;
362 case media::AudioPortType::DEVICE:
363 return AUDIO_PORT_TYPE_DEVICE;
364 case media::AudioPortType::MIX:
365 return AUDIO_PORT_TYPE_MIX;
366 case media::AudioPortType::SESSION:
367 return AUDIO_PORT_TYPE_SESSION;
368 default:
369 return unexpected(BAD_VALUE);
370 }
371}
372
373ConversionResult<media::AudioPortType> legacy2aidl_audio_port_type_t_AudioPortType(
374 audio_port_type_t legacy) {
375 switch (legacy) {
376 case AUDIO_PORT_TYPE_NONE:
377 return media::AudioPortType::NONE;
378 case AUDIO_PORT_TYPE_DEVICE:
379 return media::AudioPortType::DEVICE;
380 case AUDIO_PORT_TYPE_MIX:
381 return media::AudioPortType::MIX;
382 case AUDIO_PORT_TYPE_SESSION:
383 return media::AudioPortType::SESSION;
384 default:
385 return unexpected(BAD_VALUE);
386 }
387}
388
389ConversionResult<audio_format_t> aidl2legacy_AudioFormat_audio_format_t(
390 media::audio::common::AudioFormat aidl) {
391 // This relies on AudioFormat being kept in sync with audio_format_t.
392 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
393 return static_cast<audio_format_t>(aidl);
394}
395
396ConversionResult<media::audio::common::AudioFormat> legacy2aidl_audio_format_t_AudioFormat(
397 audio_format_t legacy) {
398 // This relies on AudioFormat being kept in sync with audio_format_t.
399 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
400 return static_cast<media::audio::common::AudioFormat>(legacy);
401}
402
403ConversionResult<int> aidl2legacy_AudioGainMode_int(media::AudioGainMode aidl) {
404 switch (aidl) {
405 case media::AudioGainMode::JOINT:
406 return AUDIO_GAIN_MODE_JOINT;
407 case media::AudioGainMode::CHANNELS:
408 return AUDIO_GAIN_MODE_CHANNELS;
409 case media::AudioGainMode::RAMP:
410 return AUDIO_GAIN_MODE_RAMP;
411 default:
412 return unexpected(BAD_VALUE);
413 }
414}
415
416ConversionResult<media::AudioGainMode> legacy2aidl_int_AudioGainMode(int legacy) {
417 switch (legacy) {
418 case AUDIO_GAIN_MODE_JOINT:
419 return media::AudioGainMode::JOINT;
420 case AUDIO_GAIN_MODE_CHANNELS:
421 return media::AudioGainMode::CHANNELS;
422 case AUDIO_GAIN_MODE_RAMP:
423 return media::AudioGainMode::RAMP;
424 default:
425 return unexpected(BAD_VALUE);
426 }
427}
428
429ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t(int32_t aidl) {
430 return convertBitmask<audio_gain_mode_t, int32_t, int, media::AudioGainMode>(
431 aidl, aidl2legacy_AudioGainMode_int,
432 // AudioGainMode is index-based.
433 index2enum_index<media::AudioGainMode>,
434 // AUDIO_GAIN_MODE_* constants are mask-based.
435 enumToMask_bitmask<audio_gain_mode_t, int>);
436}
437
438ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t(audio_gain_mode_t legacy) {
439 return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, int>(
440 legacy, legacy2aidl_int_AudioGainMode,
441 // AUDIO_GAIN_MODE_* constants are mask-based.
442 index2enum_bitmask<int>,
443 // AudioGainMode is index-based.
444 enumToMask_index<int32_t, media::AudioGainMode>);
445}
446
447ConversionResult<audio_devices_t> aidl2legacy_int32_t_audio_devices_t(int32_t aidl) {
448 // TODO(ytai): bitfield?
449 return convertReinterpret<audio_devices_t>(aidl);
450}
451
452ConversionResult<int32_t> legacy2aidl_audio_devices_t_int32_t(audio_devices_t legacy) {
453 // TODO(ytai): bitfield?
454 return convertReinterpret<int32_t>(legacy);
455}
456
457ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
458 const media::AudioGainConfig& aidl, media::AudioPortRole role, media::AudioPortType type) {
459 audio_gain_config legacy;
460 legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
461 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t(aidl.mode));
462 legacy.channel_mask =
463 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
464 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
465 const bool isJoint = bitmaskIsSet(aidl.mode, media::AudioGainMode::JOINT);
466 size_t numValues = isJoint ? 1
467 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
468 : audio_channel_count_from_out_mask(legacy.channel_mask);
469 if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
470 return unexpected(BAD_VALUE);
471 }
472 for (size_t i = 0; i < numValues; ++i) {
473 legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
474 }
475 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
476 return legacy;
477}
478
479ConversionResult<media::AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
480 const audio_gain_config& legacy, audio_port_role_t role, audio_port_type_t type) {
481 media::AudioGainConfig aidl;
482 aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
483 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t(legacy.mode));
484 aidl.channelMask =
485 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
486 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
487 const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
488 size_t numValues = isJoint ? 1
489 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
490 : audio_channel_count_from_out_mask(legacy.channel_mask);
491 aidl.values.resize(numValues);
492 for (size_t i = 0; i < numValues; ++i) {
493 aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
494 }
495 aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
496 return aidl;
497}
498
499ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
500 media::AudioInputFlags aidl) {
501 switch (aidl) {
502 case media::AudioInputFlags::FAST:
503 return AUDIO_INPUT_FLAG_FAST;
504 case media::AudioInputFlags::HW_HOTWORD:
505 return AUDIO_INPUT_FLAG_HW_HOTWORD;
506 case media::AudioInputFlags::RAW:
507 return AUDIO_INPUT_FLAG_RAW;
508 case media::AudioInputFlags::SYNC:
509 return AUDIO_INPUT_FLAG_SYNC;
510 case media::AudioInputFlags::MMAP_NOIRQ:
511 return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
512 case media::AudioInputFlags::VOIP_TX:
513 return AUDIO_INPUT_FLAG_VOIP_TX;
514 case media::AudioInputFlags::HW_AV_SYNC:
515 return AUDIO_INPUT_FLAG_HW_AV_SYNC;
516 case media::AudioInputFlags::DIRECT:
517 return AUDIO_INPUT_FLAG_DIRECT;
518 default:
519 return unexpected(BAD_VALUE);
520 }
521}
522
523ConversionResult<media::AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
524 audio_input_flags_t legacy) {
525 switch (legacy) {
526 case AUDIO_INPUT_FLAG_FAST:
527 return media::AudioInputFlags::FAST;
528 case AUDIO_INPUT_FLAG_HW_HOTWORD:
529 return media::AudioInputFlags::HW_HOTWORD;
530 case AUDIO_INPUT_FLAG_RAW:
531 return media::AudioInputFlags::RAW;
532 case AUDIO_INPUT_FLAG_SYNC:
533 return media::AudioInputFlags::SYNC;
534 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
535 return media::AudioInputFlags::MMAP_NOIRQ;
536 case AUDIO_INPUT_FLAG_VOIP_TX:
537 return media::AudioInputFlags::VOIP_TX;
538 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
539 return media::AudioInputFlags::HW_AV_SYNC;
540 case AUDIO_INPUT_FLAG_DIRECT:
541 return media::AudioInputFlags::DIRECT;
542 default:
543 return unexpected(BAD_VALUE);
544 }
545}
546
547ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
548 media::AudioOutputFlags aidl) {
549 switch (aidl) {
550 case media::AudioOutputFlags::DIRECT:
551 return AUDIO_OUTPUT_FLAG_DIRECT;
552 case media::AudioOutputFlags::PRIMARY:
553 return AUDIO_OUTPUT_FLAG_PRIMARY;
554 case media::AudioOutputFlags::FAST:
555 return AUDIO_OUTPUT_FLAG_FAST;
556 case media::AudioOutputFlags::DEEP_BUFFER:
557 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
558 case media::AudioOutputFlags::COMPRESS_OFFLOAD:
559 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
560 case media::AudioOutputFlags::NON_BLOCKING:
561 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
562 case media::AudioOutputFlags::HW_AV_SYNC:
563 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
564 case media::AudioOutputFlags::TTS:
565 return AUDIO_OUTPUT_FLAG_TTS;
566 case media::AudioOutputFlags::RAW:
567 return AUDIO_OUTPUT_FLAG_RAW;
568 case media::AudioOutputFlags::SYNC:
569 return AUDIO_OUTPUT_FLAG_SYNC;
570 case media::AudioOutputFlags::IEC958_NONAUDIO:
571 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
572 case media::AudioOutputFlags::DIRECT_PCM:
573 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
574 case media::AudioOutputFlags::MMAP_NOIRQ:
575 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
576 case media::AudioOutputFlags::VOIP_RX:
577 return AUDIO_OUTPUT_FLAG_VOIP_RX;
578 case media::AudioOutputFlags::INCALL_MUSIC:
579 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
580 default:
581 return unexpected(BAD_VALUE);
582 }
583}
584
585ConversionResult<media::AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
586 audio_output_flags_t legacy) {
587 switch (legacy) {
588 case AUDIO_OUTPUT_FLAG_DIRECT:
589 return media::AudioOutputFlags::DIRECT;
590 case AUDIO_OUTPUT_FLAG_PRIMARY:
591 return media::AudioOutputFlags::PRIMARY;
592 case AUDIO_OUTPUT_FLAG_FAST:
593 return media::AudioOutputFlags::FAST;
594 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
595 return media::AudioOutputFlags::DEEP_BUFFER;
596 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
597 return media::AudioOutputFlags::COMPRESS_OFFLOAD;
598 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
599 return media::AudioOutputFlags::NON_BLOCKING;
600 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
601 return media::AudioOutputFlags::HW_AV_SYNC;
602 case AUDIO_OUTPUT_FLAG_TTS:
603 return media::AudioOutputFlags::TTS;
604 case AUDIO_OUTPUT_FLAG_RAW:
605 return media::AudioOutputFlags::RAW;
606 case AUDIO_OUTPUT_FLAG_SYNC:
607 return media::AudioOutputFlags::SYNC;
608 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
609 return media::AudioOutputFlags::IEC958_NONAUDIO;
610 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
611 return media::AudioOutputFlags::DIRECT_PCM;
612 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
613 return media::AudioOutputFlags::MMAP_NOIRQ;
614 case AUDIO_OUTPUT_FLAG_VOIP_RX:
615 return media::AudioOutputFlags::VOIP_RX;
616 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
617 return media::AudioOutputFlags::INCALL_MUSIC;
618 default:
619 return unexpected(BAD_VALUE);
620 }
621}
622
623ConversionResult<audio_input_flags_t> aidl2legacy_audio_input_flags_mask(int32_t aidl) {
624 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
625
626 LegacyMask converted = VALUE_OR_RETURN(
627 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(
628 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
629 index2enum_index<media::AudioInputFlags>,
630 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
631 return static_cast<audio_input_flags_t>(converted);
632}
633
634ConversionResult<int32_t> legacy2aidl_audio_input_flags_mask(audio_input_flags_t legacy) {
635 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
636
637 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
638 return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(
639 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
640 index2enum_bitmask<audio_input_flags_t>,
641 enumToMask_index<int32_t, media::AudioInputFlags>);
642}
643
644ConversionResult<audio_output_flags_t> aidl2legacy_audio_output_flags_mask(int32_t aidl) {
645 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
646
647 LegacyMask converted = VALUE_OR_RETURN(
648 (convertBitmask<LegacyMask, int32_t, audio_output_flags_t, media::AudioOutputFlags>(
649 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
650 index2enum_index<media::AudioOutputFlags>,
651 enumToMask_bitmask<LegacyMask, audio_output_flags_t>)));
652 return convertReinterpret<audio_output_flags_t>(converted);
653}
654
655ConversionResult<int32_t> legacy2aidl_audio_output_flags_mask(audio_output_flags_t legacy) {
656 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
657
658 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
659 return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(
660 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
661 index2enum_bitmask<audio_output_flags_t>,
662 enumToMask_index<int32_t, media::AudioOutputFlags>);
663}
664
665ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
666 const media::AudioIoFlags& aidl, media::AudioPortRole role, media::AudioPortType type) {
667 audio_io_flags legacy;
668 // Our way of representing a union in AIDL is to have multiple vectors and require that at most
669 // one of the them has size 1 and the rest are empty.
670 size_t totalSize = aidl.input.size() + aidl.output.size();
671 if (totalSize > 1) {
672 return unexpected(BAD_VALUE);
673 }
674
675 Direction dir = VALUE_OR_RETURN(direction(role, type));
676 switch (dir) {
677 case Direction::INPUT:
678 if (aidl.input.empty()) {
679 return unexpected(BAD_VALUE);
680 }
681 legacy.input = VALUE_OR_RETURN(aidl2legacy_audio_input_flags_mask(aidl.input[0]));
682 break;
683
684 case Direction::OUTPUT:
685 if (aidl.output.empty()) {
686 return unexpected(BAD_VALUE);
687 }
688 legacy.output = VALUE_OR_RETURN(aidl2legacy_audio_output_flags_mask(aidl.output[0]));
689 break;
690 }
691
692 return legacy;
693}
694
695ConversionResult<media::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
696 const audio_io_flags& legacy, audio_port_role_t role, audio_port_type_t type) {
697 media::AudioIoFlags aidl;
698
699 Direction dir = VALUE_OR_RETURN(direction(role, type));
700 switch (dir) {
701 case Direction::INPUT:
702 aidl.input.push_back(VALUE_OR_RETURN(legacy2aidl_audio_input_flags_mask(legacy.input)));
703 break;
704 case Direction::OUTPUT:
705 aidl.output.push_back(
706 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_mask(legacy.output)));
707 break;
708 }
709 return aidl;
710}
711
712ConversionResult<audio_port_config_device_ext> aidl2legacy_AudioPortConfigDeviceExt(
713 const media::AudioPortConfigDeviceExt& aidl) {
714 audio_port_config_device_ext legacy;
715 legacy.hw_module = VALUE_OR_RETURN(convertReinterpret<audio_module_handle_t>(aidl.hwModule));
716 legacy.type = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.type));
717 if (aidl.address.size() > AUDIO_DEVICE_MAX_ADDRESS_LEN - 1) {
718 return unexpected(BAD_VALUE);
719 }
720 std::strcpy(legacy.address, aidl.address.c_str());
721 return legacy;
722}
723
724ConversionResult<media::AudioPortConfigDeviceExt> legacy2aidl_AudioPortConfigDeviceExt(
725 const audio_port_config_device_ext& legacy) {
726 media::AudioPortConfigDeviceExt aidl;
727 aidl.hwModule = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.hw_module));
728 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.type));
729
730 if (strnlen(legacy.address, AUDIO_DEVICE_MAX_ADDRESS_LEN) == AUDIO_DEVICE_MAX_ADDRESS_LEN) {
731 // No null-terminator.
732 return unexpected(BAD_VALUE);
733 }
734 aidl.address = legacy.address;
735 return aidl;
736}
737
738ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
739 media::AudioStreamType aidl) {
740 switch (aidl) {
741 case media::AudioStreamType::DEFAULT:
742 return AUDIO_STREAM_DEFAULT;
743 case media::AudioStreamType::VOICE_CALL:
744 return AUDIO_STREAM_VOICE_CALL;
745 case media::AudioStreamType::SYSTEM:
746 return AUDIO_STREAM_SYSTEM;
747 case media::AudioStreamType::RING:
748 return AUDIO_STREAM_RING;
749 case media::AudioStreamType::MUSIC:
750 return AUDIO_STREAM_MUSIC;
751 case media::AudioStreamType::ALARM:
752 return AUDIO_STREAM_ALARM;
753 case media::AudioStreamType::NOTIFICATION:
754 return AUDIO_STREAM_NOTIFICATION;
755 case media::AudioStreamType::BLUETOOTH_SCO:
756 return AUDIO_STREAM_BLUETOOTH_SCO;
757 case media::AudioStreamType::ENFORCED_AUDIBLE:
758 return AUDIO_STREAM_ENFORCED_AUDIBLE;
759 case media::AudioStreamType::DTMF:
760 return AUDIO_STREAM_DTMF;
761 case media::AudioStreamType::TTS:
762 return AUDIO_STREAM_TTS;
763 case media::AudioStreamType::ACCESSIBILITY:
764 return AUDIO_STREAM_ACCESSIBILITY;
765 case media::AudioStreamType::ASSISTANT:
766 return AUDIO_STREAM_ASSISTANT;
767 case media::AudioStreamType::REROUTING:
768 return AUDIO_STREAM_REROUTING;
769 case media::AudioStreamType::PATCH:
770 return AUDIO_STREAM_PATCH;
771 case media::AudioStreamType::CALL_ASSISTANT:
772 return AUDIO_STREAM_CALL_ASSISTANT;
773 default:
774 return unexpected(BAD_VALUE);
775 }
776}
777
778ConversionResult<media::AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
779 audio_stream_type_t legacy) {
780 switch (legacy) {
781 case AUDIO_STREAM_DEFAULT:
782 return media::AudioStreamType::DEFAULT;
783 case AUDIO_STREAM_VOICE_CALL:
784 return media::AudioStreamType::VOICE_CALL;
785 case AUDIO_STREAM_SYSTEM:
786 return media::AudioStreamType::SYSTEM;
787 case AUDIO_STREAM_RING:
788 return media::AudioStreamType::RING;
789 case AUDIO_STREAM_MUSIC:
790 return media::AudioStreamType::MUSIC;
791 case AUDIO_STREAM_ALARM:
792 return media::AudioStreamType::ALARM;
793 case AUDIO_STREAM_NOTIFICATION:
794 return media::AudioStreamType::NOTIFICATION;
795 case AUDIO_STREAM_BLUETOOTH_SCO:
796 return media::AudioStreamType::BLUETOOTH_SCO;
797 case AUDIO_STREAM_ENFORCED_AUDIBLE:
798 return media::AudioStreamType::ENFORCED_AUDIBLE;
799 case AUDIO_STREAM_DTMF:
800 return media::AudioStreamType::DTMF;
801 case AUDIO_STREAM_TTS:
802 return media::AudioStreamType::TTS;
803 case AUDIO_STREAM_ACCESSIBILITY:
804 return media::AudioStreamType::ACCESSIBILITY;
805 case AUDIO_STREAM_ASSISTANT:
806 return media::AudioStreamType::ASSISTANT;
807 case AUDIO_STREAM_REROUTING:
808 return media::AudioStreamType::REROUTING;
809 case AUDIO_STREAM_PATCH:
810 return media::AudioStreamType::PATCH;
811 case AUDIO_STREAM_CALL_ASSISTANT:
812 return media::AudioStreamType::CALL_ASSISTANT;
813 default:
814 return unexpected(BAD_VALUE);
815 }
816}
817
818ConversionResult<audio_source_t> aidl2legacy_AudioSourceType_audio_source_t(
819 media::AudioSourceType aidl) {
820 switch (aidl) {
821 case media::AudioSourceType::DEFAULT:
822 return AUDIO_SOURCE_DEFAULT;
823 case media::AudioSourceType::MIC:
824 return AUDIO_SOURCE_MIC;
825 case media::AudioSourceType::VOICE_UPLINK:
826 return AUDIO_SOURCE_VOICE_UPLINK;
827 case media::AudioSourceType::VOICE_DOWNLINK:
828 return AUDIO_SOURCE_VOICE_DOWNLINK;
829 case media::AudioSourceType::VOICE_CALL:
830 return AUDIO_SOURCE_VOICE_CALL;
831 case media::AudioSourceType::CAMCORDER:
832 return AUDIO_SOURCE_CAMCORDER;
833 case media::AudioSourceType::VOICE_RECOGNITION:
834 return AUDIO_SOURCE_VOICE_RECOGNITION;
835 case media::AudioSourceType::VOICE_COMMUNICATION:
836 return AUDIO_SOURCE_VOICE_COMMUNICATION;
837 case media::AudioSourceType::REMOTE_SUBMIX:
838 return AUDIO_SOURCE_REMOTE_SUBMIX;
839 case media::AudioSourceType::UNPROCESSED:
840 return AUDIO_SOURCE_UNPROCESSED;
841 case media::AudioSourceType::VOICE_PERFORMANCE:
842 return AUDIO_SOURCE_VOICE_PERFORMANCE;
843 case media::AudioSourceType::ECHO_REFERENCE:
844 return AUDIO_SOURCE_ECHO_REFERENCE;
845 case media::AudioSourceType::FM_TUNER:
846 return AUDIO_SOURCE_FM_TUNER;
847 case media::AudioSourceType::HOTWORD:
848 return AUDIO_SOURCE_HOTWORD;
849 default:
850 return unexpected(BAD_VALUE);
851 }
852}
853
854ConversionResult<media::AudioSourceType> legacy2aidl_audio_source_t_AudioSourceType(
855 audio_source_t legacy) {
856 switch (legacy) {
857 case AUDIO_SOURCE_DEFAULT:
858 return media::AudioSourceType::DEFAULT;
859 case AUDIO_SOURCE_MIC:
860 return media::AudioSourceType::MIC;
861 case AUDIO_SOURCE_VOICE_UPLINK:
862 return media::AudioSourceType::VOICE_UPLINK;
863 case AUDIO_SOURCE_VOICE_DOWNLINK:
864 return media::AudioSourceType::VOICE_DOWNLINK;
865 case AUDIO_SOURCE_VOICE_CALL:
866 return media::AudioSourceType::VOICE_CALL;
867 case AUDIO_SOURCE_CAMCORDER:
868 return media::AudioSourceType::CAMCORDER;
869 case AUDIO_SOURCE_VOICE_RECOGNITION:
870 return media::AudioSourceType::VOICE_RECOGNITION;
871 case AUDIO_SOURCE_VOICE_COMMUNICATION:
872 return media::AudioSourceType::VOICE_COMMUNICATION;
873 case AUDIO_SOURCE_REMOTE_SUBMIX:
874 return media::AudioSourceType::REMOTE_SUBMIX;
875 case AUDIO_SOURCE_UNPROCESSED:
876 return media::AudioSourceType::UNPROCESSED;
877 case AUDIO_SOURCE_VOICE_PERFORMANCE:
878 return media::AudioSourceType::VOICE_PERFORMANCE;
879 case AUDIO_SOURCE_ECHO_REFERENCE:
880 return media::AudioSourceType::ECHO_REFERENCE;
881 case AUDIO_SOURCE_FM_TUNER:
882 return media::AudioSourceType::FM_TUNER;
883 case AUDIO_SOURCE_HOTWORD:
884 return media::AudioSourceType::HOTWORD;
885 default:
886 return unexpected(BAD_VALUE);
887 }
888}
889
890ConversionResult<audio_session_t> aidl2legacy_AudioSessionType_audio_session_t(
891 media::AudioSessionType aidl) {
892 switch (aidl) {
893 case media::AudioSessionType::DEVICE:
894 return AUDIO_SESSION_DEVICE;
895 case media::AudioSessionType::OUTPUT_STAGE:
896 return AUDIO_SESSION_OUTPUT_STAGE;
897 case media::AudioSessionType::OUTPUT_MIX:
898 return AUDIO_SESSION_OUTPUT_MIX;
899 default:
900 return unexpected(BAD_VALUE);
901 }
902}
903
904ConversionResult<media::AudioSessionType> legacy2aidl_audio_session_t_AudioSessionType(
905 audio_session_t legacy) {
906 switch (legacy) {
907 case AUDIO_SESSION_DEVICE:
908 return media::AudioSessionType::DEVICE;
909 case AUDIO_SESSION_OUTPUT_STAGE:
910 return media::AudioSessionType::OUTPUT_STAGE;
911 case AUDIO_SESSION_OUTPUT_MIX:
912 return media::AudioSessionType::OUTPUT_MIX;
913 default:
914 return unexpected(BAD_VALUE);
915 }
916}
917
918// This type is unnamed in the original definition, thus we name it here.
919using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);
920
921ConversionResult<audio_port_config_mix_ext_usecase> aidl2legacy_AudioPortConfigMixExtUseCase(
922 const media::AudioPortConfigMixExtUseCase& aidl, media::AudioPortRole role) {
923 audio_port_config_mix_ext_usecase legacy;
924
925 // Our way of representing a union in AIDL is to have multiple vectors and require that exactly
926 // one of the them has size 1 and the rest are empty.
927 size_t totalSize = aidl.stream.size() + aidl.source.size();
928 if (totalSize > 1) {
929 return unexpected(BAD_VALUE);
930 }
931
932 switch (role) {
933 case media::AudioPortRole::NONE:
934 if (totalSize != 0) {
935 return unexpected(BAD_VALUE);
936 }
937 break;
938
939 case media::AudioPortRole::SOURCE:
940 // This is not a bug. A SOURCE role corresponds to the stream field.
941 if (aidl.stream.empty()) {
942 return unexpected(BAD_VALUE);
943 }
944 legacy.stream = VALUE_OR_RETURN(
945 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.stream[0]));
946 break;
947
948 case media::AudioPortRole::SINK:
949 // This is not a bug. A SINK role corresponds to the source field.
950 if (aidl.source.empty()) {
951 return unexpected(BAD_VALUE);
952 }
953 legacy.source =
954 VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(aidl.source[0]));
955 break;
956
957 default:
958 LOG_ALWAYS_FATAL("Shouldn't get here");
959 }
960 return legacy;
961}
962
963ConversionResult<media::AudioPortConfigMixExtUseCase> legacy2aidl_AudioPortConfigMixExtUseCase(
964 const audio_port_config_mix_ext_usecase& legacy, audio_port_role_t role) {
965 media::AudioPortConfigMixExtUseCase aidl;
966
967 switch (role) {
968 case AUDIO_PORT_ROLE_NONE:
969 break;
970 case AUDIO_PORT_ROLE_SOURCE:
971 // This is not a bug. A SOURCE role corresponds to the stream field.
972 aidl.stream.push_back(VALUE_OR_RETURN(
973 legacy2aidl_audio_stream_type_t_AudioStreamType(
974 legacy.stream)));
975 break;
976 case AUDIO_PORT_ROLE_SINK:
977 // This is not a bug. A SINK role corresponds to the source field.
978 aidl.source.push_back(
979 VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source)));
980 break;
981 default:
982 LOG_ALWAYS_FATAL("Shouldn't get here");
983 }
984 return aidl;
985}
986
987ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortConfigMixExt(
988 const media::AudioPortConfigMixExt& aidl, media::AudioPortRole role) {
989 audio_port_config_mix_ext legacy;
990 legacy.hw_module = VALUE_OR_RETURN(convertReinterpret<audio_module_handle_t>(aidl.hwModule));
991 legacy.handle = VALUE_OR_RETURN(convertReinterpret<audio_io_handle_t>(aidl.handle));
992 legacy.usecase = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigMixExtUseCase(aidl.usecase, role));
993 return legacy;
994}
995
996ConversionResult<media::AudioPortConfigMixExt> legacy2aidl_AudioPortConfigMixExt(
997 const audio_port_config_mix_ext& legacy, audio_port_role_t role) {
998 media::AudioPortConfigMixExt aidl;
999 aidl.hwModule = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.hw_module));
1000 aidl.handle = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.handle));
1001 aidl.usecase = VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExtUseCase(legacy.usecase, role));
1002 return aidl;
1003}
1004
1005ConversionResult<audio_port_config_session_ext> aidl2legacy_AudioPortConfigSessionExt(
1006 const media::AudioPortConfigSessionExt& aidl) {
1007 audio_port_config_session_ext legacy;
1008 legacy.session = VALUE_OR_RETURN(aidl2legacy_AudioSessionType_audio_session_t(aidl.session));
1009 return legacy;
1010}
1011
1012ConversionResult<media::AudioPortConfigSessionExt> legacy2aidl_AudioPortConfigSessionExt(
1013 const audio_port_config_session_ext& legacy) {
1014 media::AudioPortConfigSessionExt aidl;
1015 aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_AudioSessionType(legacy.session));
1016 return aidl;
1017}
1018
1019// This type is unnamed in the original definition, thus we name it here.
1020using audio_port_config_ext = decltype(audio_port_config::ext);
1021
1022ConversionResult<audio_port_config_ext> aidl2legacy_AudioPortConfigExt(
1023 const media::AudioPortConfigExt& aidl, media::AudioPortType type,
1024 media::AudioPortRole role) {
1025 audio_port_config_ext legacy;
1026 // Our way of representing a union in AIDL is to have multiple vectors and require that at most
1027 // one of the them has size 1 and the rest are empty.
1028 size_t totalSize = aidl.device.size() + aidl.mix.size() + aidl.session.size();
1029 if (totalSize > 1) {
1030 return unexpected(BAD_VALUE);
1031 }
1032 switch (type) {
1033 case media::AudioPortType::NONE:
1034 if (totalSize != 0) {
1035 return unexpected(BAD_VALUE);
1036 }
1037 break;
1038 case media::AudioPortType::DEVICE:
1039 if (aidl.device.empty()) {
1040 return unexpected(BAD_VALUE);
1041 }
1042 legacy.device = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigDeviceExt(aidl.device[0]));
1043 break;
1044 case media::AudioPortType::MIX:
1045 if (aidl.mix.empty()) {
1046 return unexpected(BAD_VALUE);
1047 }
1048 legacy.mix = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigMixExt(aidl.mix[0], role));
1049 break;
1050 case media::AudioPortType::SESSION:
1051 if (aidl.session.empty()) {
1052 return unexpected(BAD_VALUE);
1053 }
1054 legacy.session =
1055 VALUE_OR_RETURN(aidl2legacy_AudioPortConfigSessionExt(aidl.session[0]));
1056 break;
1057 default:
1058 LOG_ALWAYS_FATAL("Shouldn't get here");
1059 }
1060 return legacy;
1061}
1062
1063ConversionResult<media::AudioPortConfigExt> legacy2aidl_AudioPortConfigExt(
1064 const audio_port_config_ext& legacy, audio_port_type_t type, audio_port_role_t role) {
1065 media::AudioPortConfigExt aidl;
1066
1067 switch (type) {
1068 case AUDIO_PORT_TYPE_NONE:
1069 break;
1070 case AUDIO_PORT_TYPE_DEVICE:
1071 aidl.device.push_back(
1072 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigDeviceExt(legacy.device)));
1073 break;
1074 case AUDIO_PORT_TYPE_MIX:
1075 aidl.mix.push_back(
1076 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExt(legacy.mix, role)));
1077 break;
1078 case AUDIO_PORT_TYPE_SESSION:
1079 aidl.session.push_back(
1080 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigSessionExt(legacy.session)));
1081 break;
1082 default:
1083 LOG_ALWAYS_FATAL("Shouldn't get here");
1084 }
1085 return aidl;
1086}
1087
1088ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_config(
1089 const media::AudioPortConfig& aidl) {
1090 audio_port_config legacy;
1091 legacy.id = VALUE_OR_RETURN(convertReinterpret<audio_port_handle_t>(aidl.id));
1092 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.role));
1093 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.type));
1094 legacy.config_mask = VALUE_OR_RETURN(aidl2legacy_int32_t_config_mask(aidl.configMask));
1095 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::SAMPLE_RATE)) {
1096 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sampleRate));
1097 }
1098 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::CHANNEL_MASK)) {
1099 legacy.channel_mask =
1100 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1101 }
1102 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FORMAT)) {
1103 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1104 }
1105 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::GAIN)) {
1106 legacy.gain = VALUE_OR_RETURN(
1107 aidl2legacy_AudioGainConfig_audio_gain_config(aidl.gain, aidl.role, aidl.type));
1108 }
1109 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FLAGS)) {
1110 legacy.flags = VALUE_OR_RETURN(
1111 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags, aidl.role, aidl.type));
1112 }
1113 legacy.ext = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigExt(aidl.ext, aidl.type, aidl.role));
1114 return legacy;
1115}
1116
1117ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPortConfig(
1118 const audio_port_config& legacy) {
1119 media::AudioPortConfig aidl;
1120 aidl.id = VALUE_OR_RETURN(convertReinterpret<audio_port_handle_t>(legacy.id));
1121 aidl.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
1122 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
1123 aidl.configMask = VALUE_OR_RETURN(legacy2aidl_config_mask_int32_t(legacy.config_mask));
1124 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
1125 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1126 }
1127 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
1128 aidl.channelMask =
1129 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
1130 }
1131 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
1132 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1133 }
1134 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
1135 aidl.gain = VALUE_OR_RETURN(legacy2aidl_audio_gain_config_AudioGainConfig(
1136 legacy.gain, legacy.role, legacy.type));
1137 }
1138 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
1139 aidl.flags = VALUE_OR_RETURN(
1140 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, legacy.role, legacy.type));
1141 }
1142 aidl.ext =
1143 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigExt(legacy.ext, legacy.type, legacy.role));
1144 return aidl;
1145}
1146
1147ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch(
1148 const media::AudioPatch& aidl) {
1149 struct audio_patch legacy;
1150 legacy.id = VALUE_OR_RETURN(convertReinterpret<audio_patch_handle_t>(aidl.id));
1151 legacy.num_sinks = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sinks.size()));
1152 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1153 return unexpected(BAD_VALUE);
1154 }
1155 for (size_t i = 0; i < legacy.num_sinks; ++i) {
1156 legacy.sinks[i] =
1157 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sinks[i]));
1158 }
1159 legacy.num_sources = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sources.size()));
1160 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1161 return unexpected(BAD_VALUE);
1162 }
1163 for (size_t i = 0; i < legacy.num_sources; ++i) {
1164 legacy.sources[i] =
1165 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sources[i]));
1166 }
1167 return legacy;
1168}
1169
1170ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch(
1171 const struct audio_patch& legacy) {
1172 media::AudioPatch aidl;
1173 aidl.id = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.id));
1174
1175 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1176 return unexpected(BAD_VALUE);
1177 }
1178 for (unsigned int i = 0; i < legacy.num_sinks; ++i) {
1179 aidl.sinks.push_back(
1180 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sinks[i])));
1181 }
1182 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1183 return unexpected(BAD_VALUE);
1184 }
1185 for (unsigned int i = 0; i < legacy.num_sources; ++i) {
1186 aidl.sources.push_back(
1187 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sources[i])));
1188 }
1189 return aidl;
1190}
1191
1192ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(
1193 const media::AudioIoDescriptor& aidl) {
1194 sp<AudioIoDescriptor> legacy(new AudioIoDescriptor());
1195 legacy->mIoHandle = VALUE_OR_RETURN(convertReinterpret<audio_io_handle_t>(aidl.ioHandle));
1196 legacy->mPatch = VALUE_OR_RETURN(aidl2legacy_AudioPatch_audio_patch(aidl.patch));
1197 legacy->mSamplingRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));
1198 legacy->mFormat = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1199 legacy->mChannelMask =
1200 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1201 legacy->mFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
1202 legacy->mFrameCountHAL = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));
1203 legacy->mLatency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));
1204 legacy->mPortId = VALUE_OR_RETURN(convertReinterpret<audio_port_handle_t>(aidl.portId));
1205 return legacy;
1206}
1207
1208ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(
1209 const sp<AudioIoDescriptor>& legacy) {
1210 media::AudioIoDescriptor aidl;
1211 aidl.ioHandle = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy->mIoHandle));
1212 aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->mPatch));
1213 aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mSamplingRate));
1214 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy->mFormat));
1215 aidl.channelMask = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy->mChannelMask));
1216 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCount));
1217 aidl.frameCountHAL = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCountHAL));
1218 aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mLatency));
1219 aidl.portId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy->mPortId));
1220 return aidl;
1221}
1222
1223} // namespace android