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 <algorithm>
18 #include <unordered_map>
19 #include <utility>
20 #include <vector>
21
22 #define LOG_TAG "AidlConversion"
23 //#define LOG_NDEBUG 0
24 #include <utils/Log.h>
25
26 #include "media/AidlConversion.h"
27
28 #include <media/ShmemCompat.h>
29 #include <media/stagefright/foundation/MediaDefs.h>
30
31 ////////////////////////////////////////////////////////////////////////////////////////////////////
32 // Utilities
33
34 namespace android {
35
36 using base::unexpected;
37 using media::audio::common::AudioChannelLayout;
38 using media::audio::common::AudioConfig;
39 using media::audio::common::AudioConfigBase;
40 using media::audio::common::AudioContentType;
41 using media::audio::common::AudioDevice;
42 using media::audio::common::AudioDeviceAddress;
43 using media::audio::common::AudioDeviceDescription;
44 using media::audio::common::AudioDeviceType;
45 using media::audio::common::AudioEncapsulationMetadataType;
46 using media::audio::common::AudioEncapsulationMode;
47 using media::audio::common::AudioEncapsulationType;
48 using media::audio::common::AudioFormatDescription;
49 using media::audio::common::AudioFormatType;
50 using media::audio::common::AudioGain;
51 using media::audio::common::AudioGainConfig;
52 using media::audio::common::AudioGainMode;
53 using media::audio::common::AudioInputFlags;
54 using media::audio::common::AudioIoFlags;
55 using media::audio::common::AudioMode;
56 using media::audio::common::AudioOffloadInfo;
57 using media::audio::common::AudioOutputFlags;
58 using media::audio::common::AudioPortDeviceExt;
59 using media::audio::common::AudioPortExt;
60 using media::audio::common::AudioPortMixExt;
61 using media::audio::common::AudioPortMixExtUseCase;
62 using media::audio::common::AudioProfile;
63 using media::audio::common::AudioSource;
64 using media::audio::common::AudioStandard;
65 using media::audio::common::AudioStreamType;
66 using media::audio::common::AudioUsage;
67 using media::audio::common::AudioUuid;
68 using media::audio::common::ExtraAudioDescriptor;
69 using media::audio::common::Int;
70 using media::audio::common::PcmType;
71
72 namespace {
73
74 enum class Direction {
75 INPUT, OUTPUT
76 };
77
direction(media::AudioPortRole role,media::AudioPortType type)78 ConversionResult<Direction> direction(media::AudioPortRole role, media::AudioPortType type) {
79 switch (type) {
80 case media::AudioPortType::NONE:
81 case media::AudioPortType::SESSION:
82 break; // must be listed -Werror,-Wswitch
83 case media::AudioPortType::DEVICE:
84 switch (role) {
85 case media::AudioPortRole::NONE:
86 break; // must be listed -Werror,-Wswitch
87 case media::AudioPortRole::SOURCE:
88 return Direction::INPUT;
89 case media::AudioPortRole::SINK:
90 return Direction::OUTPUT;
91 }
92 break;
93 case media::AudioPortType::MIX:
94 switch (role) {
95 case media::AudioPortRole::NONE:
96 break; // must be listed -Werror,-Wswitch
97 case media::AudioPortRole::SOURCE:
98 return Direction::OUTPUT;
99 case media::AudioPortRole::SINK:
100 return Direction::INPUT;
101 }
102 break;
103 }
104 return unexpected(BAD_VALUE);
105 }
106
direction(audio_port_role_t role,audio_port_type_t type)107 ConversionResult<Direction> direction(audio_port_role_t role, audio_port_type_t type) {
108 switch (type) {
109 case AUDIO_PORT_TYPE_NONE:
110 case AUDIO_PORT_TYPE_SESSION:
111 break; // must be listed -Werror,-Wswitch
112 case AUDIO_PORT_TYPE_DEVICE:
113 switch (role) {
114 case AUDIO_PORT_ROLE_NONE:
115 break; // must be listed -Werror,-Wswitch
116 case AUDIO_PORT_ROLE_SOURCE:
117 return Direction::INPUT;
118 case AUDIO_PORT_ROLE_SINK:
119 return Direction::OUTPUT;
120 }
121 break;
122 case AUDIO_PORT_TYPE_MIX:
123 switch (role) {
124 case AUDIO_PORT_ROLE_NONE:
125 break; // must be listed -Werror,-Wswitch
126 case AUDIO_PORT_ROLE_SOURCE:
127 return Direction::OUTPUT;
128 case AUDIO_PORT_ROLE_SINK:
129 return Direction::INPUT;
130 }
131 break;
132 }
133 return unexpected(BAD_VALUE);
134 }
135
136 } // namespace
137
138 ////////////////////////////////////////////////////////////////////////////////////////////////////
139 // Converters
140
aidl2legacy_string(std::string_view aidl,char * dest,size_t maxSize)141 status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
142 if (aidl.size() > maxSize - 1) {
143 return BAD_VALUE;
144 }
145 aidl.copy(dest, aidl.size());
146 dest[aidl.size()] = '\0';
147 return OK;
148 }
149
legacy2aidl_string(const char * legacy,size_t maxSize)150 ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
151 if (legacy == nullptr) {
152 return unexpected(BAD_VALUE);
153 }
154 if (strnlen(legacy, maxSize) == maxSize) {
155 // No null-terminator.
156 return unexpected(BAD_VALUE);
157 }
158 return std::string(legacy);
159 }
160
aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl)161 ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
162 return convertReinterpret<audio_module_handle_t>(aidl);
163 }
164
legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy)165 ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
166 return convertReinterpret<int32_t>(legacy);
167 }
168
aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl)169 ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
170 return convertReinterpret<audio_io_handle_t>(aidl);
171 }
172
legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy)173 ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
174 return convertReinterpret<int32_t>(legacy);
175 }
176
aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl)177 ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
178 return convertReinterpret<audio_port_handle_t>(aidl);
179 }
180
legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy)181 ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
182 return convertReinterpret<int32_t>(legacy);
183 }
184
aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl)185 ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
186 return convertReinterpret<audio_patch_handle_t>(aidl);
187 }
188
legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy)189 ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
190 return convertReinterpret<int32_t>(legacy);
191 }
192
aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl)193 ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
194 return convertReinterpret<audio_unique_id_t>(aidl);
195 }
196
legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy)197 ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
198 return convertReinterpret<int32_t>(legacy);
199 }
200
aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl)201 ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl) {
202 return convertReinterpret<audio_hw_sync_t>(aidl);
203 }
204
legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy)205 ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy) {
206 return convertReinterpret<int32_t>(legacy);
207 }
208
aidl2legacy_int32_t_pid_t(int32_t aidl)209 ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
210 return convertReinterpret<pid_t>(aidl);
211 }
212
legacy2aidl_pid_t_int32_t(pid_t legacy)213 ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
214 return convertReinterpret<int32_t>(legacy);
215 }
216
aidl2legacy_int32_t_uid_t(int32_t aidl)217 ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
218 return convertReinterpret<uid_t>(aidl);
219 }
220
legacy2aidl_uid_t_int32_t(uid_t legacy)221 ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
222 return convertReinterpret<int32_t>(legacy);
223 }
224
aidl2legacy_string_view_String16(std::string_view aidl)225 ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
226 return String16(aidl.data(), aidl.size());
227 }
228
legacy2aidl_String16_string(const String16 & legacy)229 ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
230 return std::string(String8(legacy).c_str());
231 }
232
233 // TODO b/182392769: create an optional -> optional util
234 ConversionResult<std::optional<String16>>
aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl)235 aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl) {
236 if (!aidl.has_value()) {
237 return std::nullopt;
238 }
239 ConversionResult<String16> conversion =
240 VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.value()));
241 return conversion.value();
242 }
243
244 ConversionResult<std::optional<std::string_view>>
legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy)245 legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy) {
246 if (!legacy.has_value()) {
247 return std::nullopt;
248 }
249 ConversionResult<std::string> conversion =
250 VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.value()));
251 return conversion.value();
252 }
253
aidl2legacy_string_view_String8(std::string_view aidl)254 ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {
255 return String8(aidl.data(), aidl.size());
256 }
257
legacy2aidl_String8_string(const String8 & legacy)258 ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {
259 return std::string(legacy.c_str());
260 }
261
aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(media::AudioIoConfigEvent aidl)262 ConversionResult<audio_io_config_event_t> aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(
263 media::AudioIoConfigEvent aidl) {
264 switch (aidl) {
265 case media::AudioIoConfigEvent::OUTPUT_REGISTERED:
266 return AUDIO_OUTPUT_REGISTERED;
267 case media::AudioIoConfigEvent::OUTPUT_OPENED:
268 return AUDIO_OUTPUT_OPENED;
269 case media::AudioIoConfigEvent::OUTPUT_CLOSED:
270 return AUDIO_OUTPUT_CLOSED;
271 case media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED:
272 return AUDIO_OUTPUT_CONFIG_CHANGED;
273 case media::AudioIoConfigEvent::INPUT_REGISTERED:
274 return AUDIO_INPUT_REGISTERED;
275 case media::AudioIoConfigEvent::INPUT_OPENED:
276 return AUDIO_INPUT_OPENED;
277 case media::AudioIoConfigEvent::INPUT_CLOSED:
278 return AUDIO_INPUT_CLOSED;
279 case media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED:
280 return AUDIO_INPUT_CONFIG_CHANGED;
281 case media::AudioIoConfigEvent::CLIENT_STARTED:
282 return AUDIO_CLIENT_STARTED;
283 }
284 return unexpected(BAD_VALUE);
285 }
286
legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(audio_io_config_event_t legacy)287 ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(
288 audio_io_config_event_t legacy) {
289 switch (legacy) {
290 case AUDIO_OUTPUT_REGISTERED:
291 return media::AudioIoConfigEvent::OUTPUT_REGISTERED;
292 case AUDIO_OUTPUT_OPENED:
293 return media::AudioIoConfigEvent::OUTPUT_OPENED;
294 case AUDIO_OUTPUT_CLOSED:
295 return media::AudioIoConfigEvent::OUTPUT_CLOSED;
296 case AUDIO_OUTPUT_CONFIG_CHANGED:
297 return media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED;
298 case AUDIO_INPUT_REGISTERED:
299 return media::AudioIoConfigEvent::INPUT_REGISTERED;
300 case AUDIO_INPUT_OPENED:
301 return media::AudioIoConfigEvent::INPUT_OPENED;
302 case AUDIO_INPUT_CLOSED:
303 return media::AudioIoConfigEvent::INPUT_CLOSED;
304 case AUDIO_INPUT_CONFIG_CHANGED:
305 return media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED;
306 case AUDIO_CLIENT_STARTED:
307 return media::AudioIoConfigEvent::CLIENT_STARTED;
308 }
309 return unexpected(BAD_VALUE);
310 }
311
aidl2legacy_AudioPortRole_audio_port_role_t(media::AudioPortRole aidl)312 ConversionResult<audio_port_role_t> aidl2legacy_AudioPortRole_audio_port_role_t(
313 media::AudioPortRole aidl) {
314 switch (aidl) {
315 case media::AudioPortRole::NONE:
316 return AUDIO_PORT_ROLE_NONE;
317 case media::AudioPortRole::SOURCE:
318 return AUDIO_PORT_ROLE_SOURCE;
319 case media::AudioPortRole::SINK:
320 return AUDIO_PORT_ROLE_SINK;
321 }
322 return unexpected(BAD_VALUE);
323 }
324
legacy2aidl_audio_port_role_t_AudioPortRole(audio_port_role_t legacy)325 ConversionResult<media::AudioPortRole> legacy2aidl_audio_port_role_t_AudioPortRole(
326 audio_port_role_t legacy) {
327 switch (legacy) {
328 case AUDIO_PORT_ROLE_NONE:
329 return media::AudioPortRole::NONE;
330 case AUDIO_PORT_ROLE_SOURCE:
331 return media::AudioPortRole::SOURCE;
332 case AUDIO_PORT_ROLE_SINK:
333 return media::AudioPortRole::SINK;
334 }
335 return unexpected(BAD_VALUE);
336 }
337
aidl2legacy_AudioPortType_audio_port_type_t(media::AudioPortType aidl)338 ConversionResult<audio_port_type_t> aidl2legacy_AudioPortType_audio_port_type_t(
339 media::AudioPortType aidl) {
340 switch (aidl) {
341 case media::AudioPortType::NONE:
342 return AUDIO_PORT_TYPE_NONE;
343 case media::AudioPortType::DEVICE:
344 return AUDIO_PORT_TYPE_DEVICE;
345 case media::AudioPortType::MIX:
346 return AUDIO_PORT_TYPE_MIX;
347 case media::AudioPortType::SESSION:
348 return AUDIO_PORT_TYPE_SESSION;
349 }
350 return unexpected(BAD_VALUE);
351 }
352
legacy2aidl_audio_port_type_t_AudioPortType(audio_port_type_t legacy)353 ConversionResult<media::AudioPortType> legacy2aidl_audio_port_type_t_AudioPortType(
354 audio_port_type_t legacy) {
355 switch (legacy) {
356 case AUDIO_PORT_TYPE_NONE:
357 return media::AudioPortType::NONE;
358 case AUDIO_PORT_TYPE_DEVICE:
359 return media::AudioPortType::DEVICE;
360 case AUDIO_PORT_TYPE_MIX:
361 return media::AudioPortType::MIX;
362 case AUDIO_PORT_TYPE_SESSION:
363 return media::AudioPortType::SESSION;
364 }
365 return unexpected(BAD_VALUE);
366 }
367
368 namespace {
369
370 namespace detail {
371 using AudioChannelBitPair = std::pair<audio_channel_mask_t, int>;
372 using AudioChannelBitPairs = std::vector<AudioChannelBitPair>;
373 using AudioChannelPair = std::pair<audio_channel_mask_t, AudioChannelLayout>;
374 using AudioChannelPairs = std::vector<AudioChannelPair>;
375 using AudioDevicePair = std::pair<audio_devices_t, AudioDeviceDescription>;
376 using AudioDevicePairs = std::vector<AudioDevicePair>;
377 using AudioFormatPair = std::pair<audio_format_t, AudioFormatDescription>;
378 using AudioFormatPairs = std::vector<AudioFormatPair>;
379 }
380
getInAudioChannelBits()381 const detail::AudioChannelBitPairs& getInAudioChannelBits() {
382 static const detail::AudioChannelBitPairs pairs = {
383 { AUDIO_CHANNEL_IN_LEFT, AudioChannelLayout::CHANNEL_FRONT_LEFT },
384 { AUDIO_CHANNEL_IN_RIGHT, AudioChannelLayout::CHANNEL_FRONT_RIGHT },
385 // AUDIO_CHANNEL_IN_FRONT is at the end
386 { AUDIO_CHANNEL_IN_BACK, AudioChannelLayout::CHANNEL_BACK_CENTER },
387 // AUDIO_CHANNEL_IN_*_PROCESSED not supported
388 // AUDIO_CHANNEL_IN_PRESSURE not supported
389 // AUDIO_CHANNEL_IN_*_AXIS not supported
390 // AUDIO_CHANNEL_IN_VOICE_* not supported
391 { AUDIO_CHANNEL_IN_BACK_LEFT, AudioChannelLayout::CHANNEL_BACK_LEFT },
392 { AUDIO_CHANNEL_IN_BACK_RIGHT, AudioChannelLayout::CHANNEL_BACK_RIGHT },
393 { AUDIO_CHANNEL_IN_CENTER, AudioChannelLayout::CHANNEL_FRONT_CENTER },
394 { AUDIO_CHANNEL_IN_LOW_FREQUENCY, AudioChannelLayout::CHANNEL_LOW_FREQUENCY },
395 { AUDIO_CHANNEL_IN_TOP_LEFT, AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT },
396 { AUDIO_CHANNEL_IN_TOP_RIGHT, AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT },
397 // When going from aidl to legacy, IN_CENTER is used
398 { AUDIO_CHANNEL_IN_FRONT, AudioChannelLayout::CHANNEL_FRONT_CENTER }
399 };
400 return pairs;
401 }
402
getInAudioChannelPairs()403 const detail::AudioChannelPairs& getInAudioChannelPairs() {
404 static const detail::AudioChannelPairs pairs = {
405 #define DEFINE_INPUT_LAYOUT(n) \
406 { \
407 AUDIO_CHANNEL_IN_##n, \
408 AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
409 AudioChannelLayout::LAYOUT_##n) \
410 }
411
412 DEFINE_INPUT_LAYOUT(MONO),
413 DEFINE_INPUT_LAYOUT(STEREO),
414 DEFINE_INPUT_LAYOUT(FRONT_BACK),
415 // AUDIO_CHANNEL_IN_6 not supported
416 DEFINE_INPUT_LAYOUT(2POINT0POINT2),
417 DEFINE_INPUT_LAYOUT(2POINT1POINT2),
418 DEFINE_INPUT_LAYOUT(3POINT0POINT2),
419 DEFINE_INPUT_LAYOUT(3POINT1POINT2),
420 DEFINE_INPUT_LAYOUT(5POINT1)
421 #undef DEFINE_INPUT_LAYOUT
422 };
423 return pairs;
424 }
425
getOutAudioChannelBits()426 const detail::AudioChannelBitPairs& getOutAudioChannelBits() {
427 static const detail::AudioChannelBitPairs pairs = {
428 #define DEFINE_OUTPUT_BITS(n) \
429 { AUDIO_CHANNEL_OUT_##n, AudioChannelLayout::CHANNEL_##n }
430
431 DEFINE_OUTPUT_BITS(FRONT_LEFT),
432 DEFINE_OUTPUT_BITS(FRONT_RIGHT),
433 DEFINE_OUTPUT_BITS(FRONT_CENTER),
434 DEFINE_OUTPUT_BITS(LOW_FREQUENCY),
435 DEFINE_OUTPUT_BITS(BACK_LEFT),
436 DEFINE_OUTPUT_BITS(BACK_RIGHT),
437 DEFINE_OUTPUT_BITS(FRONT_LEFT_OF_CENTER),
438 DEFINE_OUTPUT_BITS(FRONT_RIGHT_OF_CENTER),
439 DEFINE_OUTPUT_BITS(BACK_CENTER),
440 DEFINE_OUTPUT_BITS(SIDE_LEFT),
441 DEFINE_OUTPUT_BITS(SIDE_RIGHT),
442 DEFINE_OUTPUT_BITS(TOP_CENTER),
443 DEFINE_OUTPUT_BITS(TOP_FRONT_LEFT),
444 DEFINE_OUTPUT_BITS(TOP_FRONT_CENTER),
445 DEFINE_OUTPUT_BITS(TOP_FRONT_RIGHT),
446 DEFINE_OUTPUT_BITS(TOP_BACK_LEFT),
447 DEFINE_OUTPUT_BITS(TOP_BACK_CENTER),
448 DEFINE_OUTPUT_BITS(TOP_BACK_RIGHT),
449 DEFINE_OUTPUT_BITS(TOP_SIDE_LEFT),
450 DEFINE_OUTPUT_BITS(TOP_SIDE_RIGHT),
451 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_LEFT),
452 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_CENTER),
453 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_RIGHT),
454 DEFINE_OUTPUT_BITS(LOW_FREQUENCY_2),
455 DEFINE_OUTPUT_BITS(FRONT_WIDE_LEFT),
456 DEFINE_OUTPUT_BITS(FRONT_WIDE_RIGHT),
457 #undef DEFINE_OUTPUT_BITS
458 { AUDIO_CHANNEL_OUT_HAPTIC_A, AudioChannelLayout::CHANNEL_HAPTIC_A },
459 { AUDIO_CHANNEL_OUT_HAPTIC_B, AudioChannelLayout::CHANNEL_HAPTIC_B }
460 };
461 return pairs;
462 }
463
getOutAudioChannelPairs()464 const detail::AudioChannelPairs& getOutAudioChannelPairs() {
465 static const detail::AudioChannelPairs pairs = {
466 #define DEFINE_OUTPUT_LAYOUT(n) \
467 { \
468 AUDIO_CHANNEL_OUT_##n, \
469 AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
470 AudioChannelLayout::LAYOUT_##n) \
471 }
472
473 DEFINE_OUTPUT_LAYOUT(MONO),
474 DEFINE_OUTPUT_LAYOUT(STEREO),
475 DEFINE_OUTPUT_LAYOUT(2POINT1),
476 DEFINE_OUTPUT_LAYOUT(TRI),
477 DEFINE_OUTPUT_LAYOUT(TRI_BACK),
478 DEFINE_OUTPUT_LAYOUT(3POINT1),
479 DEFINE_OUTPUT_LAYOUT(2POINT0POINT2),
480 DEFINE_OUTPUT_LAYOUT(2POINT1POINT2),
481 DEFINE_OUTPUT_LAYOUT(3POINT0POINT2),
482 DEFINE_OUTPUT_LAYOUT(3POINT1POINT2),
483 DEFINE_OUTPUT_LAYOUT(QUAD),
484 DEFINE_OUTPUT_LAYOUT(QUAD_SIDE),
485 DEFINE_OUTPUT_LAYOUT(SURROUND),
486 DEFINE_OUTPUT_LAYOUT(PENTA),
487 DEFINE_OUTPUT_LAYOUT(5POINT1),
488 DEFINE_OUTPUT_LAYOUT(5POINT1_SIDE),
489 DEFINE_OUTPUT_LAYOUT(5POINT1POINT2),
490 DEFINE_OUTPUT_LAYOUT(5POINT1POINT4),
491 DEFINE_OUTPUT_LAYOUT(6POINT1),
492 DEFINE_OUTPUT_LAYOUT(7POINT1),
493 DEFINE_OUTPUT_LAYOUT(7POINT1POINT2),
494 DEFINE_OUTPUT_LAYOUT(7POINT1POINT4),
495 DEFINE_OUTPUT_LAYOUT(13POINT_360RA),
496 DEFINE_OUTPUT_LAYOUT(22POINT2),
497 DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_A),
498 DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_A),
499 DEFINE_OUTPUT_LAYOUT(HAPTIC_AB),
500 DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_AB),
501 DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_AB)
502 #undef DEFINE_OUTPUT_LAYOUT
503 };
504 return pairs;
505 }
506
getVoiceAudioChannelPairs()507 const detail::AudioChannelPairs& getVoiceAudioChannelPairs() {
508 static const detail::AudioChannelPairs pairs = {
509 #define DEFINE_VOICE_LAYOUT(n) \
510 { \
511 AUDIO_CHANNEL_IN_VOICE_##n, \
512 AudioChannelLayout::make<AudioChannelLayout::Tag::voiceMask>( \
513 AudioChannelLayout::VOICE_##n) \
514 }
515 DEFINE_VOICE_LAYOUT(UPLINK_MONO),
516 DEFINE_VOICE_LAYOUT(DNLINK_MONO),
517 DEFINE_VOICE_LAYOUT(CALL_MONO)
518 #undef DEFINE_VOICE_LAYOUT
519 };
520 return pairs;
521 }
522
make_AudioDeviceDescription(AudioDeviceType type,const std::string & connection="")523 AudioDeviceDescription make_AudioDeviceDescription(AudioDeviceType type,
524 const std::string& connection = "") {
525 AudioDeviceDescription result;
526 result.type = type;
527 result.connection = connection;
528 return result;
529 }
530
append_AudioDeviceDescription(detail::AudioDevicePairs & pairs,audio_devices_t inputType,audio_devices_t outputType,AudioDeviceType inType,AudioDeviceType outType,const std::string & connection="")531 void append_AudioDeviceDescription(detail::AudioDevicePairs& pairs,
532 audio_devices_t inputType, audio_devices_t outputType,
533 AudioDeviceType inType, AudioDeviceType outType,
534 const std::string& connection = "") {
535 pairs.push_back(std::make_pair(inputType, make_AudioDeviceDescription(inType, connection)));
536 pairs.push_back(std::make_pair(outputType, make_AudioDeviceDescription(outType, connection)));
537 }
538
getAudioDevicePairs()539 const detail::AudioDevicePairs& getAudioDevicePairs() {
540 static const detail::AudioDevicePairs pairs = []() {
541 detail::AudioDevicePairs pairs = {{
542 {
543 AUDIO_DEVICE_NONE, AudioDeviceDescription{}
544 },
545 {
546 AUDIO_DEVICE_OUT_EARPIECE, make_AudioDeviceDescription(
547 AudioDeviceType::OUT_SPEAKER_EARPIECE)
548 },
549 {
550 AUDIO_DEVICE_OUT_SPEAKER, make_AudioDeviceDescription(
551 AudioDeviceType::OUT_SPEAKER)
552 },
553 {
554 AUDIO_DEVICE_OUT_WIRED_HEADPHONE, make_AudioDeviceDescription(
555 AudioDeviceType::OUT_HEADPHONE,
556 AudioDeviceDescription::CONNECTION_ANALOG())
557 },
558 {
559 AUDIO_DEVICE_OUT_BLUETOOTH_SCO, make_AudioDeviceDescription(
560 AudioDeviceType::OUT_DEVICE,
561 AudioDeviceDescription::CONNECTION_BT_SCO())
562 },
563 {
564 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, make_AudioDeviceDescription(
565 AudioDeviceType::OUT_CARKIT,
566 AudioDeviceDescription::CONNECTION_BT_SCO())
567 },
568 {
569 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, make_AudioDeviceDescription(
570 AudioDeviceType::OUT_HEADPHONE,
571 AudioDeviceDescription::CONNECTION_BT_A2DP())
572 },
573 {
574 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, make_AudioDeviceDescription(
575 AudioDeviceType::OUT_SPEAKER,
576 AudioDeviceDescription::CONNECTION_BT_A2DP())
577 },
578 {
579 AUDIO_DEVICE_OUT_TELEPHONY_TX, make_AudioDeviceDescription(
580 AudioDeviceType::OUT_TELEPHONY_TX)
581 },
582 {
583 AUDIO_DEVICE_OUT_AUX_LINE, make_AudioDeviceDescription(
584 AudioDeviceType::OUT_LINE_AUX)
585 },
586 {
587 AUDIO_DEVICE_OUT_SPEAKER_SAFE, make_AudioDeviceDescription(
588 AudioDeviceType::OUT_SPEAKER_SAFE)
589 },
590 {
591 AUDIO_DEVICE_OUT_HEARING_AID, make_AudioDeviceDescription(
592 AudioDeviceType::OUT_HEARING_AID,
593 AudioDeviceDescription::CONNECTION_WIRELESS())
594 },
595 {
596 AUDIO_DEVICE_OUT_ECHO_CANCELLER, make_AudioDeviceDescription(
597 AudioDeviceType::OUT_ECHO_CANCELLER)
598 },
599 {
600 AUDIO_DEVICE_OUT_BLE_SPEAKER, make_AudioDeviceDescription(
601 AudioDeviceType::OUT_SPEAKER,
602 AudioDeviceDescription::CONNECTION_BT_LE())
603 },
604 {
605 AUDIO_DEVICE_OUT_BLE_BROADCAST, make_AudioDeviceDescription(
606 AudioDeviceType::OUT_BROADCAST,
607 AudioDeviceDescription::CONNECTION_BT_LE())
608 },
609 // AUDIO_DEVICE_IN_AMBIENT and IN_COMMUNICATION are removed since they were deprecated.
610 {
611 AUDIO_DEVICE_IN_BUILTIN_MIC, make_AudioDeviceDescription(
612 AudioDeviceType::IN_MICROPHONE)
613 },
614 {
615 AUDIO_DEVICE_IN_BACK_MIC, make_AudioDeviceDescription(
616 AudioDeviceType::IN_MICROPHONE_BACK)
617 },
618 {
619 AUDIO_DEVICE_IN_TELEPHONY_RX, make_AudioDeviceDescription(
620 AudioDeviceType::IN_TELEPHONY_RX)
621 },
622 {
623 AUDIO_DEVICE_IN_TV_TUNER, make_AudioDeviceDescription(
624 AudioDeviceType::IN_TV_TUNER)
625 },
626 {
627 AUDIO_DEVICE_IN_LOOPBACK, make_AudioDeviceDescription(
628 AudioDeviceType::IN_LOOPBACK)
629 },
630 {
631 AUDIO_DEVICE_IN_BLUETOOTH_BLE, make_AudioDeviceDescription(
632 AudioDeviceType::IN_DEVICE,
633 AudioDeviceDescription::CONNECTION_BT_LE())
634 },
635 {
636 AUDIO_DEVICE_IN_ECHO_REFERENCE, make_AudioDeviceDescription(
637 AudioDeviceType::IN_ECHO_REFERENCE)
638 }
639 }};
640 append_AudioDeviceDescription(pairs,
641 AUDIO_DEVICE_IN_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT,
642 AudioDeviceType::IN_DEFAULT, AudioDeviceType::OUT_DEFAULT);
643 append_AudioDeviceDescription(pairs,
644 AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET,
645 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
646 AudioDeviceDescription::CONNECTION_ANALOG());
647 append_AudioDeviceDescription(pairs,
648 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
649 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
650 AudioDeviceDescription::CONNECTION_BT_SCO());
651 append_AudioDeviceDescription(pairs,
652 AUDIO_DEVICE_IN_HDMI, AUDIO_DEVICE_OUT_HDMI,
653 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
654 AudioDeviceDescription::CONNECTION_HDMI());
655 append_AudioDeviceDescription(pairs,
656 AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
657 AudioDeviceType::IN_SUBMIX, AudioDeviceType::OUT_SUBMIX);
658 append_AudioDeviceDescription(pairs,
659 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,
660 AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
661 AudioDeviceDescription::CONNECTION_ANALOG());
662 append_AudioDeviceDescription(pairs,
663 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,
664 AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
665 AudioDeviceDescription::CONNECTION_USB());
666 append_AudioDeviceDescription(pairs,
667 AUDIO_DEVICE_IN_USB_ACCESSORY, AUDIO_DEVICE_OUT_USB_ACCESSORY,
668 AudioDeviceType::IN_ACCESSORY, AudioDeviceType::OUT_ACCESSORY,
669 AudioDeviceDescription::CONNECTION_USB());
670 append_AudioDeviceDescription(pairs,
671 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_OUT_USB_DEVICE,
672 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
673 AudioDeviceDescription::CONNECTION_USB());
674 append_AudioDeviceDescription(pairs,
675 AUDIO_DEVICE_IN_FM_TUNER, AUDIO_DEVICE_OUT_FM,
676 AudioDeviceType::IN_FM_TUNER, AudioDeviceType::OUT_FM);
677 append_AudioDeviceDescription(pairs,
678 AUDIO_DEVICE_IN_LINE, AUDIO_DEVICE_OUT_LINE,
679 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
680 AudioDeviceDescription::CONNECTION_ANALOG());
681 append_AudioDeviceDescription(pairs,
682 AUDIO_DEVICE_IN_SPDIF, AUDIO_DEVICE_OUT_SPDIF,
683 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
684 AudioDeviceDescription::CONNECTION_SPDIF());
685 append_AudioDeviceDescription(pairs,
686 AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
687 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
688 AudioDeviceDescription::CONNECTION_BT_A2DP());
689 append_AudioDeviceDescription(pairs,
690 AUDIO_DEVICE_IN_IP, AUDIO_DEVICE_OUT_IP,
691 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
692 AudioDeviceDescription::CONNECTION_IP_V4());
693 append_AudioDeviceDescription(pairs,
694 AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_OUT_BUS,
695 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
696 AudioDeviceDescription::CONNECTION_BUS());
697 append_AudioDeviceDescription(pairs,
698 AUDIO_DEVICE_IN_PROXY, AUDIO_DEVICE_OUT_PROXY,
699 AudioDeviceType::IN_AFE_PROXY, AudioDeviceType::OUT_AFE_PROXY);
700 append_AudioDeviceDescription(pairs,
701 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_OUT_USB_HEADSET,
702 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
703 AudioDeviceDescription::CONNECTION_USB());
704 append_AudioDeviceDescription(pairs,
705 AUDIO_DEVICE_IN_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_ARC,
706 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
707 AudioDeviceDescription::CONNECTION_HDMI_ARC());
708 append_AudioDeviceDescription(pairs,
709 AUDIO_DEVICE_IN_HDMI_EARC, AUDIO_DEVICE_OUT_HDMI_EARC,
710 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
711 AudioDeviceDescription::CONNECTION_HDMI_EARC());
712 append_AudioDeviceDescription(pairs,
713 AUDIO_DEVICE_IN_BLE_HEADSET, AUDIO_DEVICE_OUT_BLE_HEADSET,
714 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
715 AudioDeviceDescription::CONNECTION_BT_LE());
716 return pairs;
717 }();
718 return pairs;
719 }
720
make_AudioFormatDescription(AudioFormatType type)721 AudioFormatDescription make_AudioFormatDescription(AudioFormatType type) {
722 AudioFormatDescription result;
723 result.type = type;
724 return result;
725 }
726
make_AudioFormatDescription(PcmType pcm)727 AudioFormatDescription make_AudioFormatDescription(PcmType pcm) {
728 auto result = make_AudioFormatDescription(AudioFormatType::PCM);
729 result.pcm = pcm;
730 return result;
731 }
732
make_AudioFormatDescription(const std::string & encoding)733 AudioFormatDescription make_AudioFormatDescription(const std::string& encoding) {
734 AudioFormatDescription result;
735 result.encoding = encoding;
736 return result;
737 }
738
make_AudioFormatDescription(PcmType transport,const std::string & encoding)739 AudioFormatDescription make_AudioFormatDescription(PcmType transport,
740 const std::string& encoding) {
741 auto result = make_AudioFormatDescription(encoding);
742 result.pcm = transport;
743 return result;
744 }
745
getAudioFormatPairs()746 const detail::AudioFormatPairs& getAudioFormatPairs() {
747 static const detail::AudioFormatPairs pairs = {{
748 {
749 AUDIO_FORMAT_INVALID,
750 make_AudioFormatDescription(AudioFormatType::SYS_RESERVED_INVALID)
751 },
752 {
753 AUDIO_FORMAT_DEFAULT, AudioFormatDescription{}
754 },
755 {
756 AUDIO_FORMAT_PCM_16_BIT, make_AudioFormatDescription(PcmType::INT_16_BIT)
757 },
758 {
759 AUDIO_FORMAT_PCM_8_BIT, make_AudioFormatDescription(PcmType::UINT_8_BIT)
760 },
761 {
762 AUDIO_FORMAT_PCM_32_BIT, make_AudioFormatDescription(PcmType::INT_32_BIT)
763 },
764 {
765 AUDIO_FORMAT_PCM_8_24_BIT, make_AudioFormatDescription(PcmType::FIXED_Q_8_24)
766 },
767 {
768 AUDIO_FORMAT_PCM_FLOAT, make_AudioFormatDescription(PcmType::FLOAT_32_BIT)
769 },
770 {
771 AUDIO_FORMAT_PCM_24_BIT_PACKED, make_AudioFormatDescription(PcmType::INT_24_BIT)
772 },
773 {
774 AUDIO_FORMAT_MP3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEG)
775 },
776 {
777 AUDIO_FORMAT_AMR_NB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_NB)
778 },
779 {
780 AUDIO_FORMAT_AMR_WB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_WB)
781 },
782 {
783 AUDIO_FORMAT_AAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_MP4)
784 },
785 {
786 AUDIO_FORMAT_AAC_MAIN, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_MAIN)
787 },
788 {
789 AUDIO_FORMAT_AAC_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LC)
790 },
791 {
792 AUDIO_FORMAT_AAC_SSR, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_SSR)
793 },
794 {
795 AUDIO_FORMAT_AAC_LTP, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LTP)
796 },
797 {
798 AUDIO_FORMAT_AAC_HE_V1, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_HE_V1)
799 },
800 {
801 AUDIO_FORMAT_AAC_SCALABLE,
802 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_SCALABLE)
803 },
804 {
805 AUDIO_FORMAT_AAC_ERLC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ERLC)
806 },
807 {
808 AUDIO_FORMAT_AAC_LD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LD)
809 },
810 {
811 AUDIO_FORMAT_AAC_HE_V2, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_HE_V2)
812 },
813 {
814 AUDIO_FORMAT_AAC_ELD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ELD)
815 },
816 {
817 AUDIO_FORMAT_AAC_XHE, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_XHE)
818 },
819 // AUDIO_FORMAT_HE_AAC_V1 and HE_AAC_V2 are removed since they were deprecated long time
820 // ago.
821 {
822 AUDIO_FORMAT_VORBIS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_VORBIS)
823 },
824 {
825 AUDIO_FORMAT_OPUS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_OPUS)
826 },
827 {
828 AUDIO_FORMAT_AC3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AC3)
829 },
830 {
831 AUDIO_FORMAT_E_AC3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EAC3)
832 },
833 {
834 AUDIO_FORMAT_E_AC3_JOC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EAC3_JOC)
835 },
836 {
837 AUDIO_FORMAT_DTS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS)
838 },
839 {
840 AUDIO_FORMAT_DTS_HD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_HD)
841 },
842 // In the future, we would like to represent encapsulated bitstreams as
843 // nested AudioFormatDescriptions. The legacy 'AUDIO_FORMAT_IEC61937' type doesn't
844 // specify the format of the encapsulated bitstream.
845 {
846 AUDIO_FORMAT_IEC61937,
847 make_AudioFormatDescription(PcmType::INT_16_BIT, MEDIA_MIMETYPE_AUDIO_IEC61937)
848 },
849 {
850 AUDIO_FORMAT_DOLBY_TRUEHD,
851 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_TRUEHD)
852 },
853 {
854 AUDIO_FORMAT_EVRC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRC)
855 },
856 {
857 AUDIO_FORMAT_EVRCB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCB)
858 },
859 {
860 AUDIO_FORMAT_EVRCWB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCWB)
861 },
862 {
863 AUDIO_FORMAT_EVRCNW, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCNW)
864 },
865 {
866 AUDIO_FORMAT_AAC_ADIF, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADIF)
867 },
868 {
869 AUDIO_FORMAT_WMA, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_WMA)
870 },
871 {
872 // Note: not in the IANA registry.
873 AUDIO_FORMAT_WMA_PRO, make_AudioFormatDescription("audio/x-ms-wma.pro")
874 },
875 {
876 AUDIO_FORMAT_AMR_WB_PLUS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_WB_PLUS)
877 },
878 {
879 AUDIO_FORMAT_MP2, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II)
880 },
881 {
882 AUDIO_FORMAT_QCELP, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_QCELP)
883 },
884 {
885 // Note: not in the IANA registry.
886 AUDIO_FORMAT_DSD, make_AudioFormatDescription("audio/vnd.sony.dsd")
887 },
888 {
889 AUDIO_FORMAT_FLAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_FLAC)
890 },
891 {
892 AUDIO_FORMAT_ALAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_ALAC)
893 },
894 {
895 // Note: not in the IANA registry.
896 AUDIO_FORMAT_APE, make_AudioFormatDescription("audio/x-ape")
897 },
898 {
899 AUDIO_FORMAT_AAC_ADTS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS)
900 },
901 {
902 AUDIO_FORMAT_AAC_ADTS_MAIN,
903 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_MAIN)
904 },
905 {
906 AUDIO_FORMAT_AAC_ADTS_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LC)
907 },
908 {
909 AUDIO_FORMAT_AAC_ADTS_SSR,
910 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SSR)
911 },
912 {
913 AUDIO_FORMAT_AAC_ADTS_LTP,
914 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LTP)
915 },
916 {
917 AUDIO_FORMAT_AAC_ADTS_HE_V1,
918 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V1)
919 },
920 {
921 AUDIO_FORMAT_AAC_ADTS_SCALABLE,
922 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SCALABLE)
923 },
924 {
925 AUDIO_FORMAT_AAC_ADTS_ERLC,
926 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ERLC)
927 },
928 {
929 AUDIO_FORMAT_AAC_ADTS_LD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LD)
930 },
931 {
932 AUDIO_FORMAT_AAC_ADTS_HE_V2,
933 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V2)
934 },
935 {
936 AUDIO_FORMAT_AAC_ADTS_ELD,
937 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ELD)
938 },
939 {
940 AUDIO_FORMAT_AAC_ADTS_XHE,
941 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_XHE)
942 },
943 {
944 // Note: not in the IANA registry. "vnd.octel.sbc" is not BT SBC.
945 AUDIO_FORMAT_SBC, make_AudioFormatDescription("audio/x-sbc")
946 },
947 {
948 AUDIO_FORMAT_APTX, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_APTX)
949 },
950 {
951 // Note: not in the IANA registry.
952 AUDIO_FORMAT_APTX_HD, make_AudioFormatDescription("audio/vnd.qcom.aptx.hd")
953 },
954 {
955 AUDIO_FORMAT_AC4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AC4)
956 },
957 {
958 // Note: not in the IANA registry.
959 AUDIO_FORMAT_LDAC, make_AudioFormatDescription("audio/vnd.sony.ldac")
960 },
961 {
962 AUDIO_FORMAT_MAT, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT)
963 },
964 {
965 // Note: not in the IANA registry.
966 AUDIO_FORMAT_MAT_1_0,
967 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".1.0"))
968 },
969 {
970 // Note: not in the IANA registry.
971 AUDIO_FORMAT_MAT_2_0,
972 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".2.0"))
973 },
974 {
975 // Note: not in the IANA registry.
976 AUDIO_FORMAT_MAT_2_1,
977 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".2.1"))
978 },
979 {
980 AUDIO_FORMAT_AAC_LATM, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC)
981 },
982 {
983 AUDIO_FORMAT_AAC_LATM_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_LC)
984 },
985 {
986 AUDIO_FORMAT_AAC_LATM_HE_V1,
987 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V1)
988 },
989 {
990 AUDIO_FORMAT_AAC_LATM_HE_V2,
991 make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V2)
992 },
993 {
994 // Note: not in the IANA registry.
995 AUDIO_FORMAT_CELT, make_AudioFormatDescription("audio/x-celt")
996 },
997 {
998 // Note: not in the IANA registry.
999 AUDIO_FORMAT_APTX_ADAPTIVE, make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive")
1000 },
1001 {
1002 // Note: not in the IANA registry.
1003 AUDIO_FORMAT_LHDC, make_AudioFormatDescription("audio/vnd.savitech.lhdc")
1004 },
1005 {
1006 // Note: not in the IANA registry.
1007 AUDIO_FORMAT_LHDC_LL, make_AudioFormatDescription("audio/vnd.savitech.lhdc.ll")
1008 },
1009 {
1010 // Note: not in the IANA registry.
1011 AUDIO_FORMAT_APTX_TWSP, make_AudioFormatDescription("audio/vnd.qcom.aptx.twsp")
1012 },
1013 {
1014 // Note: not in the IANA registry.
1015 AUDIO_FORMAT_LC3, make_AudioFormatDescription("audio/x-lc3")
1016 },
1017 {
1018 AUDIO_FORMAT_MPEGH, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1)
1019 },
1020 {
1021 AUDIO_FORMAT_MPEGH_BL_L3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L3)
1022 },
1023 {
1024 AUDIO_FORMAT_MPEGH_BL_L4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L4)
1025 },
1026 {
1027 AUDIO_FORMAT_MPEGH_LC_L3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L3)
1028 },
1029 {
1030 AUDIO_FORMAT_MPEGH_LC_L4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L4)
1031 },
1032 {
1033 AUDIO_FORMAT_IEC60958,
1034 make_AudioFormatDescription(PcmType::INT_24_BIT, MEDIA_MIMETYPE_AUDIO_IEC60958)
1035 },
1036 {
1037 AUDIO_FORMAT_DTS_UHD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_UHD)
1038 },
1039 {
1040 AUDIO_FORMAT_DRA, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DRA)
1041 },
1042 }};
1043 return pairs;
1044 }
1045
1046 template<typename S, typename T>
make_DirectMap(const std::vector<std::pair<S,T>> & v)1047 std::unordered_map<S, T> make_DirectMap(const std::vector<std::pair<S, T>>& v) {
1048 std::unordered_map<S, T> result(v.begin(), v.end());
1049 LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
1050 return result;
1051 }
1052
1053 template<typename S, typename T>
make_DirectMap(const std::vector<std::pair<S,T>> & v1,const std::vector<std::pair<S,T>> & v2)1054 std::unordered_map<S, T> make_DirectMap(
1055 const std::vector<std::pair<S, T>>& v1, const std::vector<std::pair<S, T>>& v2) {
1056 std::unordered_map<S, T> result(v1.begin(), v1.end());
1057 LOG_ALWAYS_FATAL_IF(result.size() != v1.size(), "Duplicate key elements detected in v1");
1058 result.insert(v2.begin(), v2.end());
1059 LOG_ALWAYS_FATAL_IF(result.size() != v1.size() + v2.size(),
1060 "Duplicate key elements detected in v1+v2");
1061 return result;
1062 }
1063
1064 template<typename S, typename T>
make_ReverseMap(const std::vector<std::pair<S,T>> & v)1065 std::unordered_map<T, S> make_ReverseMap(const std::vector<std::pair<S, T>>& v) {
1066 std::unordered_map<T, S> result;
1067 std::transform(v.begin(), v.end(), std::inserter(result, result.begin()),
1068 [](const std::pair<S, T>& p) {
1069 return std::make_pair(p.second, p.first);
1070 });
1071 LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
1072 return result;
1073 }
1074
1075 } // namespace
1076
aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(int aidlLayout,bool isInput)1077 audio_channel_mask_t aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
1078 int aidlLayout, bool isInput) {
1079 auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
1080 const int aidlLayoutInitial = aidlLayout; // for error message
1081 audio_channel_mask_t legacy = AUDIO_CHANNEL_NONE;
1082 for (const auto& bitPair : bitMapping) {
1083 if ((aidlLayout & bitPair.second) == bitPair.second) {
1084 legacy = static_cast<audio_channel_mask_t>(legacy | bitPair.first);
1085 aidlLayout &= ~bitPair.second;
1086 if (aidlLayout == 0) {
1087 return legacy;
1088 }
1089 }
1090 }
1091 ALOGE("%s: aidl layout 0x%x contains bits 0x%x that have no match to legacy %s bits",
1092 __func__, aidlLayoutInitial, aidlLayout, isInput ? "input" : "output");
1093 return AUDIO_CHANNEL_NONE;
1094 }
1095
aidl2legacy_AudioChannelLayout_audio_channel_mask_t(const AudioChannelLayout & aidl,bool isInput)1096 ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
1097 const AudioChannelLayout& aidl, bool isInput) {
1098 using ReverseMap = std::unordered_map<AudioChannelLayout, audio_channel_mask_t>;
1099 using Tag = AudioChannelLayout::Tag;
1100 static const ReverseMap mIn = make_ReverseMap(getInAudioChannelPairs());
1101 static const ReverseMap mOut = make_ReverseMap(getOutAudioChannelPairs());
1102 static const ReverseMap mVoice = make_ReverseMap(getVoiceAudioChannelPairs());
1103
1104 auto convert = [](const AudioChannelLayout& aidl, const ReverseMap& m,
1105 const char* func, const char* type) -> ConversionResult<audio_channel_mask_t> {
1106 if (auto it = m.find(aidl); it != m.end()) {
1107 return it->second;
1108 } else {
1109 ALOGW("%s: no legacy %s audio_channel_mask_t found for %s", func, type,
1110 aidl.toString().c_str());
1111 return unexpected(BAD_VALUE);
1112 }
1113 };
1114
1115 switch (aidl.getTag()) {
1116 case Tag::none:
1117 return AUDIO_CHANNEL_NONE;
1118 case Tag::invalid:
1119 return AUDIO_CHANNEL_INVALID;
1120 case Tag::indexMask:
1121 // Index masks do not have pre-defined values.
1122 if (const int bits = aidl.get<Tag::indexMask>();
1123 __builtin_popcount(bits) != 0 &&
1124 __builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {
1125 return audio_channel_mask_from_representation_and_bits(
1126 AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
1127 } else {
1128 ALOGE("%s: invalid indexMask value 0x%x in %s",
1129 __func__, bits, aidl.toString().c_str());
1130 return unexpected(BAD_VALUE);
1131 }
1132 case Tag::layoutMask:
1133 // The fast path is to find a direct match for some known layout mask.
1134 if (const auto layoutMatch = convert(aidl, isInput ? mIn : mOut, __func__,
1135 isInput ? "input" : "output");
1136 layoutMatch.ok()) {
1137 return layoutMatch;
1138 }
1139 // If a match for a predefined layout wasn't found, make a custom one from bits.
1140 if (audio_channel_mask_t bitMask =
1141 aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
1142 aidl.get<Tag::layoutMask>(), isInput);
1143 bitMask != AUDIO_CHANNEL_NONE) {
1144 return bitMask;
1145 }
1146 return unexpected(BAD_VALUE);
1147 case Tag::voiceMask:
1148 return convert(aidl, mVoice, __func__, "voice");
1149 }
1150 ALOGE("%s: unexpected tag value %d", __func__, aidl.getTag());
1151 return unexpected(BAD_VALUE);
1152 }
1153
legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(audio_channel_mask_t legacy,bool isInput)1154 int legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
1155 audio_channel_mask_t legacy, bool isInput) {
1156 auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
1157 const int legacyInitial = legacy; // for error message
1158 int aidlLayout = 0;
1159 for (const auto& bitPair : bitMapping) {
1160 if ((legacy & bitPair.first) == bitPair.first) {
1161 aidlLayout |= bitPair.second;
1162 legacy = static_cast<audio_channel_mask_t>(legacy & ~bitPair.first);
1163 if (legacy == 0) {
1164 return aidlLayout;
1165 }
1166 }
1167 }
1168 ALOGE("%s: legacy %s audio_channel_mask_t 0x%x contains unrecognized bits 0x%x",
1169 __func__, isInput ? "input" : "output", legacyInitial, legacy);
1170 return 0;
1171 }
1172
legacy2aidl_audio_channel_mask_t_AudioChannelLayout(audio_channel_mask_t legacy,bool isInput)1173 ConversionResult<AudioChannelLayout> legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
1174 audio_channel_mask_t legacy, bool isInput) {
1175 using DirectMap = std::unordered_map<audio_channel_mask_t, AudioChannelLayout>;
1176 using Tag = AudioChannelLayout::Tag;
1177 static const DirectMap mInAndVoice = make_DirectMap(
1178 getInAudioChannelPairs(), getVoiceAudioChannelPairs());
1179 static const DirectMap mOut = make_DirectMap(getOutAudioChannelPairs());
1180
1181 auto convert = [](const audio_channel_mask_t legacy, const DirectMap& m,
1182 const char* func, const char* type) -> ConversionResult<AudioChannelLayout> {
1183 if (auto it = m.find(legacy); it != m.end()) {
1184 return it->second;
1185 } else {
1186 ALOGW("%s: no AudioChannelLayout found for legacy %s audio_channel_mask_t value 0x%x",
1187 func, type, legacy);
1188 return unexpected(BAD_VALUE);
1189 }
1190 };
1191
1192 if (legacy == AUDIO_CHANNEL_NONE) {
1193 return AudioChannelLayout{};
1194 } else if (legacy == AUDIO_CHANNEL_INVALID) {
1195 return AudioChannelLayout::make<Tag::invalid>(0);
1196 }
1197
1198 const audio_channel_representation_t repr = audio_channel_mask_get_representation(legacy);
1199 if (repr == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
1200 if (audio_channel_mask_is_valid(legacy)) {
1201 const int indexMask = VALUE_OR_RETURN(
1202 convertIntegral<int>(audio_channel_mask_get_bits(legacy)));
1203 return AudioChannelLayout::make<Tag::indexMask>(indexMask);
1204 } else {
1205 ALOGE("%s: legacy audio_channel_mask_t value 0x%x is invalid", __func__, legacy);
1206 return unexpected(BAD_VALUE);
1207 }
1208 } else if (repr == AUDIO_CHANNEL_REPRESENTATION_POSITION) {
1209 // The fast path is to find a direct match for some known layout mask.
1210 if (const auto layoutMatch = convert(legacy, isInput ? mInAndVoice : mOut, __func__,
1211 isInput ? "input / voice" : "output");
1212 layoutMatch.ok()) {
1213 return layoutMatch;
1214 }
1215 // If a match for a predefined layout wasn't found, make a custom one from bits,
1216 // rejecting those with voice channel bits.
1217 if (!isInput ||
1218 (legacy & (AUDIO_CHANNEL_IN_VOICE_UPLINK | AUDIO_CHANNEL_IN_VOICE_DNLINK)) == 0) {
1219 if (int bitMaskLayout =
1220 legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
1221 legacy, isInput);
1222 bitMaskLayout != 0) {
1223 return AudioChannelLayout::make<Tag::layoutMask>(bitMaskLayout);
1224 }
1225 } else {
1226 ALOGE("%s: legacy audio_channel_mask_t value 0x%x contains voice bits",
1227 __func__, legacy);
1228 }
1229 return unexpected(BAD_VALUE);
1230 }
1231
1232 ALOGE("%s: unknown representation %d in audio_channel_mask_t value 0x%x",
1233 __func__, repr, legacy);
1234 return unexpected(BAD_VALUE);
1235 }
1236
aidl2legacy_AudioDeviceDescription_audio_devices_t(const AudioDeviceDescription & aidl)1237 ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
1238 const AudioDeviceDescription& aidl) {
1239 static const std::unordered_map<AudioDeviceDescription, audio_devices_t> m =
1240 make_ReverseMap(getAudioDevicePairs());
1241 if (auto it = m.find(aidl); it != m.end()) {
1242 return it->second;
1243 } else {
1244 ALOGE("%s: no legacy audio_devices_t found for %s", __func__, aidl.toString().c_str());
1245 return unexpected(BAD_VALUE);
1246 }
1247 }
1248
legacy2aidl_audio_devices_t_AudioDeviceDescription(audio_devices_t legacy)1249 ConversionResult<AudioDeviceDescription> legacy2aidl_audio_devices_t_AudioDeviceDescription(
1250 audio_devices_t legacy) {
1251 static const std::unordered_map<audio_devices_t, AudioDeviceDescription> m =
1252 make_DirectMap(getAudioDevicePairs());
1253 if (auto it = m.find(legacy); it != m.end()) {
1254 return it->second;
1255 } else {
1256 ALOGE("%s: no AudioDeviceDescription found for legacy audio_devices_t value 0x%x",
1257 __func__, legacy);
1258 return unexpected(BAD_VALUE);
1259 }
1260 }
1261
aidl2legacy_AudioDevice_audio_device(const AudioDevice & aidl,audio_devices_t * legacyType,char * legacyAddress)1262 status_t aidl2legacy_AudioDevice_audio_device(
1263 const AudioDevice& aidl,
1264 audio_devices_t* legacyType, char* legacyAddress) {
1265 *legacyType = VALUE_OR_RETURN_STATUS(
1266 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
1267 return aidl2legacy_string(
1268 aidl.address.get<AudioDeviceAddress::id>(),
1269 legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN);
1270 }
1271
aidl2legacy_AudioDevice_audio_device(const AudioDevice & aidl,audio_devices_t * legacyType,String8 * legacyAddress)1272 status_t aidl2legacy_AudioDevice_audio_device(
1273 const AudioDevice& aidl,
1274 audio_devices_t* legacyType, String8* legacyAddress) {
1275 *legacyType = VALUE_OR_RETURN_STATUS(
1276 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
1277 *legacyAddress = VALUE_OR_RETURN_STATUS(aidl2legacy_string_view_String8(
1278 aidl.address.get<AudioDeviceAddress::id>()));
1279 return OK;
1280 }
1281
aidl2legacy_AudioDevice_audio_device(const AudioDevice & aidl,audio_devices_t * legacyType,std::string * legacyAddress)1282 status_t aidl2legacy_AudioDevice_audio_device(
1283 const AudioDevice& aidl,
1284 audio_devices_t* legacyType, std::string* legacyAddress) {
1285 *legacyType = VALUE_OR_RETURN_STATUS(
1286 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
1287 *legacyAddress = aidl.address.get<AudioDeviceAddress::id>();
1288 return OK;
1289 }
1290
legacy2aidl_audio_device_AudioDevice(audio_devices_t legacyType,const char * legacyAddress)1291 ConversionResult<AudioDevice> legacy2aidl_audio_device_AudioDevice(
1292 audio_devices_t legacyType, const char* legacyAddress) {
1293 AudioDevice aidl;
1294 aidl.type = VALUE_OR_RETURN(
1295 legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
1296 const std::string aidl_id = VALUE_OR_RETURN(
1297 legacy2aidl_string(legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
1298 aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
1299 return aidl;
1300 }
1301
1302 ConversionResult<AudioDevice>
legacy2aidl_audio_device_AudioDevice(audio_devices_t legacyType,const String8 & legacyAddress)1303 legacy2aidl_audio_device_AudioDevice(
1304 audio_devices_t legacyType, const String8& legacyAddress) {
1305 AudioDevice aidl;
1306 aidl.type = VALUE_OR_RETURN(
1307 legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
1308 const std::string aidl_id = VALUE_OR_RETURN(
1309 legacy2aidl_String8_string(legacyAddress));
1310 aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
1311 return aidl;
1312 }
1313
aidl2legacy_AudioFormatDescription_audio_format_t(const AudioFormatDescription & aidl)1314 ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
1315 const AudioFormatDescription& aidl) {
1316 static const std::unordered_map<AudioFormatDescription, audio_format_t> m =
1317 make_ReverseMap(getAudioFormatPairs());
1318 if (auto it = m.find(aidl); it != m.end()) {
1319 return it->second;
1320 } else {
1321 ALOGE("%s: no legacy audio_format_t found for %s", __func__, aidl.toString().c_str());
1322 return unexpected(BAD_VALUE);
1323 }
1324 }
1325
legacy2aidl_audio_format_t_AudioFormatDescription(audio_format_t legacy)1326 ConversionResult<AudioFormatDescription> legacy2aidl_audio_format_t_AudioFormatDescription(
1327 audio_format_t legacy) {
1328 static const std::unordered_map<audio_format_t, AudioFormatDescription> m =
1329 make_DirectMap(getAudioFormatPairs());
1330 if (auto it = m.find(legacy); it != m.end()) {
1331 return it->second;
1332 } else {
1333 ALOGE("%s: no AudioFormatDescription found for legacy audio_format_t value 0x%x",
1334 __func__, legacy);
1335 return unexpected(BAD_VALUE);
1336 }
1337 }
1338
aidl2legacy_AudioGainMode_audio_gain_mode_t(AudioGainMode aidl)1339 ConversionResult<audio_gain_mode_t> aidl2legacy_AudioGainMode_audio_gain_mode_t(
1340 AudioGainMode aidl) {
1341 switch (aidl) {
1342 case AudioGainMode::JOINT:
1343 return AUDIO_GAIN_MODE_JOINT;
1344 case AudioGainMode::CHANNELS:
1345 return AUDIO_GAIN_MODE_CHANNELS;
1346 case AudioGainMode::RAMP:
1347 return AUDIO_GAIN_MODE_RAMP;
1348 }
1349 return unexpected(BAD_VALUE);
1350 }
1351
legacy2aidl_audio_gain_mode_t_AudioGainMode(audio_gain_mode_t legacy)1352 ConversionResult<AudioGainMode> legacy2aidl_audio_gain_mode_t_AudioGainMode(
1353 audio_gain_mode_t legacy) {
1354 switch (legacy) {
1355 case AUDIO_GAIN_MODE_JOINT:
1356 return AudioGainMode::JOINT;
1357 case AUDIO_GAIN_MODE_CHANNELS:
1358 return AudioGainMode::CHANNELS;
1359 case AUDIO_GAIN_MODE_RAMP:
1360 return AudioGainMode::RAMP;
1361 }
1362 return unexpected(BAD_VALUE);
1363 }
1364
aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl)1365 ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl) {
1366 return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, AudioGainMode>(
1367 aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
1368 // AudioGainMode is index-based.
1369 indexToEnum_index<AudioGainMode>,
1370 // AUDIO_GAIN_MODE_* constants are mask-based.
1371 enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
1372 }
1373
legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy)1374 ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy) {
1375 return convertBitmask<int32_t, audio_gain_mode_t, AudioGainMode, audio_gain_mode_t>(
1376 legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
1377 // AUDIO_GAIN_MODE_* constants are mask-based.
1378 indexToEnum_bitmask<audio_gain_mode_t>,
1379 // AudioGainMode is index-based.
1380 enumToMask_index<int32_t, AudioGainMode>);
1381 }
1382
aidl2legacy_AudioGainConfig_audio_gain_config(const AudioGainConfig & aidl,bool isInput)1383 ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
1384 const AudioGainConfig& aidl, bool isInput) {
1385 audio_gain_config legacy;
1386 legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
1387 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
1388 legacy.channel_mask = VALUE_OR_RETURN(
1389 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
1390 const bool isJoint = bitmaskIsSet(aidl.mode, AudioGainMode::JOINT);
1391 size_t numValues = isJoint ? 1
1392 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
1393 : audio_channel_count_from_out_mask(legacy.channel_mask);
1394 if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
1395 return unexpected(BAD_VALUE);
1396 }
1397 for (size_t i = 0; i < numValues; ++i) {
1398 legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
1399 }
1400 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
1401 return legacy;
1402 }
1403
legacy2aidl_audio_gain_config_AudioGainConfig(const audio_gain_config & legacy,bool isInput)1404 ConversionResult<AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
1405 const audio_gain_config& legacy, bool isInput) {
1406 AudioGainConfig aidl;
1407 aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
1408 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
1409 aidl.channelMask = VALUE_OR_RETURN(
1410 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1411 const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
1412 size_t numValues = isJoint ? 1
1413 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
1414 : audio_channel_count_from_out_mask(legacy.channel_mask);
1415 aidl.values.resize(numValues);
1416 for (size_t i = 0; i < numValues; ++i) {
1417 aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
1418 }
1419 aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
1420 return aidl;
1421 }
1422
aidl2legacy_AudioInputFlags_audio_input_flags_t(AudioInputFlags aidl)1423 ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
1424 AudioInputFlags aidl) {
1425 switch (aidl) {
1426 case AudioInputFlags::FAST:
1427 return AUDIO_INPUT_FLAG_FAST;
1428 case AudioInputFlags::HW_HOTWORD:
1429 return AUDIO_INPUT_FLAG_HW_HOTWORD;
1430 case AudioInputFlags::RAW:
1431 return AUDIO_INPUT_FLAG_RAW;
1432 case AudioInputFlags::SYNC:
1433 return AUDIO_INPUT_FLAG_SYNC;
1434 case AudioInputFlags::MMAP_NOIRQ:
1435 return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
1436 case AudioInputFlags::VOIP_TX:
1437 return AUDIO_INPUT_FLAG_VOIP_TX;
1438 case AudioInputFlags::HW_AV_SYNC:
1439 return AUDIO_INPUT_FLAG_HW_AV_SYNC;
1440 case AudioInputFlags::DIRECT:
1441 return AUDIO_INPUT_FLAG_DIRECT;
1442 case AudioInputFlags::ULTRASOUND:
1443 return AUDIO_INPUT_FLAG_ULTRASOUND;
1444 }
1445 return unexpected(BAD_VALUE);
1446 }
1447
legacy2aidl_audio_input_flags_t_AudioInputFlags(audio_input_flags_t legacy)1448 ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
1449 audio_input_flags_t legacy) {
1450 switch (legacy) {
1451 case AUDIO_INPUT_FLAG_NONE:
1452 break; // shouldn't get here. must be listed -Werror,-Wswitch
1453 case AUDIO_INPUT_FLAG_FAST:
1454 return AudioInputFlags::FAST;
1455 case AUDIO_INPUT_FLAG_HW_HOTWORD:
1456 return AudioInputFlags::HW_HOTWORD;
1457 case AUDIO_INPUT_FLAG_RAW:
1458 return AudioInputFlags::RAW;
1459 case AUDIO_INPUT_FLAG_SYNC:
1460 return AudioInputFlags::SYNC;
1461 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
1462 return AudioInputFlags::MMAP_NOIRQ;
1463 case AUDIO_INPUT_FLAG_VOIP_TX:
1464 return AudioInputFlags::VOIP_TX;
1465 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
1466 return AudioInputFlags::HW_AV_SYNC;
1467 case AUDIO_INPUT_FLAG_DIRECT:
1468 return AudioInputFlags::DIRECT;
1469 case AUDIO_INPUT_FLAG_ULTRASOUND:
1470 return AudioInputFlags::ULTRASOUND;
1471 }
1472 return unexpected(BAD_VALUE);
1473 }
1474
aidl2legacy_AudioOutputFlags_audio_output_flags_t(AudioOutputFlags aidl)1475 ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
1476 AudioOutputFlags aidl) {
1477 switch (aidl) {
1478 case AudioOutputFlags::DIRECT:
1479 return AUDIO_OUTPUT_FLAG_DIRECT;
1480 case AudioOutputFlags::PRIMARY:
1481 return AUDIO_OUTPUT_FLAG_PRIMARY;
1482 case AudioOutputFlags::FAST:
1483 return AUDIO_OUTPUT_FLAG_FAST;
1484 case AudioOutputFlags::DEEP_BUFFER:
1485 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
1486 case AudioOutputFlags::COMPRESS_OFFLOAD:
1487 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1488 case AudioOutputFlags::NON_BLOCKING:
1489 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
1490 case AudioOutputFlags::HW_AV_SYNC:
1491 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
1492 case AudioOutputFlags::TTS:
1493 return AUDIO_OUTPUT_FLAG_TTS;
1494 case AudioOutputFlags::RAW:
1495 return AUDIO_OUTPUT_FLAG_RAW;
1496 case AudioOutputFlags::SYNC:
1497 return AUDIO_OUTPUT_FLAG_SYNC;
1498 case AudioOutputFlags::IEC958_NONAUDIO:
1499 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
1500 case AudioOutputFlags::DIRECT_PCM:
1501 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
1502 case AudioOutputFlags::MMAP_NOIRQ:
1503 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
1504 case AudioOutputFlags::VOIP_RX:
1505 return AUDIO_OUTPUT_FLAG_VOIP_RX;
1506 case AudioOutputFlags::INCALL_MUSIC:
1507 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
1508 case AudioOutputFlags::GAPLESS_OFFLOAD:
1509 return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
1510 case AudioOutputFlags::ULTRASOUND:
1511 return AUDIO_OUTPUT_FLAG_ULTRASOUND;
1512 case AudioOutputFlags::SPATIALIZER:
1513 return AUDIO_OUTPUT_FLAG_SPATIALIZER;
1514 }
1515 return unexpected(BAD_VALUE);
1516 }
1517
legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_t legacy)1518 ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
1519 audio_output_flags_t legacy) {
1520 switch (legacy) {
1521 case AUDIO_OUTPUT_FLAG_NONE:
1522 break; // shouldn't get here. must be listed -Werror,-Wswitch
1523 case AUDIO_OUTPUT_FLAG_DIRECT:
1524 return AudioOutputFlags::DIRECT;
1525 case AUDIO_OUTPUT_FLAG_PRIMARY:
1526 return AudioOutputFlags::PRIMARY;
1527 case AUDIO_OUTPUT_FLAG_FAST:
1528 return AudioOutputFlags::FAST;
1529 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
1530 return AudioOutputFlags::DEEP_BUFFER;
1531 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
1532 return AudioOutputFlags::COMPRESS_OFFLOAD;
1533 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
1534 return AudioOutputFlags::NON_BLOCKING;
1535 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
1536 return AudioOutputFlags::HW_AV_SYNC;
1537 case AUDIO_OUTPUT_FLAG_TTS:
1538 return AudioOutputFlags::TTS;
1539 case AUDIO_OUTPUT_FLAG_RAW:
1540 return AudioOutputFlags::RAW;
1541 case AUDIO_OUTPUT_FLAG_SYNC:
1542 return AudioOutputFlags::SYNC;
1543 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
1544 return AudioOutputFlags::IEC958_NONAUDIO;
1545 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
1546 return AudioOutputFlags::DIRECT_PCM;
1547 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
1548 return AudioOutputFlags::MMAP_NOIRQ;
1549 case AUDIO_OUTPUT_FLAG_VOIP_RX:
1550 return AudioOutputFlags::VOIP_RX;
1551 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
1552 return AudioOutputFlags::INCALL_MUSIC;
1553 case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
1554 return AudioOutputFlags::GAPLESS_OFFLOAD;
1555 case AUDIO_OUTPUT_FLAG_ULTRASOUND:
1556 return AudioOutputFlags::ULTRASOUND;
1557 case AUDIO_OUTPUT_FLAG_SPATIALIZER:
1558 return AudioOutputFlags::SPATIALIZER;
1559 }
1560 return unexpected(BAD_VALUE);
1561 }
1562
aidl2legacy_int32_t_audio_input_flags_t_mask(int32_t aidl)1563 ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
1564 int32_t aidl) {
1565 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1566
1567 LegacyMask converted = VALUE_OR_RETURN(
1568 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
1569 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
1570 indexToEnum_index<AudioInputFlags>,
1571 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
1572 return static_cast<audio_input_flags_t>(converted);
1573 }
1574
legacy2aidl_audio_input_flags_t_int32_t_mask(audio_input_flags_t legacy)1575 ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
1576 audio_input_flags_t legacy) {
1577 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1578
1579 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1580 return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
1581 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
1582 indexToEnum_bitmask<audio_input_flags_t>,
1583 enumToMask_index<int32_t, AudioInputFlags>);
1584 }
1585
aidl2legacy_int32_t_audio_output_flags_t_mask(int32_t aidl)1586 ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
1587 int32_t aidl) {
1588 return convertBitmask<audio_output_flags_t,
1589 int32_t,
1590 audio_output_flags_t,
1591 AudioOutputFlags>(
1592 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
1593 indexToEnum_index<AudioOutputFlags>,
1594 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
1595 }
1596
legacy2aidl_audio_output_flags_t_int32_t_mask(audio_output_flags_t legacy)1597 ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
1598 audio_output_flags_t legacy) {
1599 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
1600
1601 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1602 return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
1603 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
1604 indexToEnum_bitmask<audio_output_flags_t>,
1605 enumToMask_index<int32_t, AudioOutputFlags>);
1606 }
1607
aidl2legacy_AudioIoFlags_audio_io_flags(const AudioIoFlags & aidl,bool isInput)1608 ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
1609 const AudioIoFlags& aidl, bool isInput) {
1610 audio_io_flags legacy;
1611 if (isInput) {
1612 legacy.input = VALUE_OR_RETURN(
1613 aidl2legacy_int32_t_audio_input_flags_t_mask(
1614 VALUE_OR_RETURN(UNION_GET(aidl, input))));
1615 } else {
1616 legacy.output = VALUE_OR_RETURN(
1617 aidl2legacy_int32_t_audio_output_flags_t_mask(
1618 VALUE_OR_RETURN(UNION_GET(aidl, output))));
1619 }
1620 return legacy;
1621 }
1622
legacy2aidl_audio_io_flags_AudioIoFlags(const audio_io_flags & legacy,bool isInput)1623 ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
1624 const audio_io_flags& legacy, bool isInput) {
1625 AudioIoFlags aidl;
1626 if (isInput) {
1627 UNION_SET(aidl, input,
1628 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
1629 } else {
1630 UNION_SET(aidl, output,
1631 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
1632 }
1633 return aidl;
1634 }
1635
1636 ConversionResult<audio_port_config_device_ext>
aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(const AudioPortDeviceExt & aidl,const media::AudioPortDeviceExtSys & aidlDeviceExt)1637 aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
1638 const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlDeviceExt) {
1639 audio_port_config_device_ext legacy;
1640 legacy.hw_module = VALUE_OR_RETURN(
1641 aidl2legacy_int32_t_audio_module_handle_t(aidlDeviceExt.hwModule));
1642 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
1643 aidl.device, &legacy.type, legacy.address));
1644 return legacy;
1645 }
1646
legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(const audio_port_config_device_ext & legacy,AudioPortDeviceExt * aidl,media::AudioPortDeviceExtSys * aidlDeviceExt)1647 status_t legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
1648 const audio_port_config_device_ext& legacy,
1649 AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {
1650 aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(
1651 legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1652 aidl->device = VALUE_OR_RETURN_STATUS(
1653 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
1654 return OK;
1655 }
1656
aidl2legacy_AudioStreamType_audio_stream_type_t(AudioStreamType aidl)1657 ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
1658 AudioStreamType aidl) {
1659 switch (aidl) {
1660 case AudioStreamType::INVALID:
1661 break; // return error
1662 case AudioStreamType::SYS_RESERVED_DEFAULT:
1663 return AUDIO_STREAM_DEFAULT;
1664 case AudioStreamType::VOICE_CALL:
1665 return AUDIO_STREAM_VOICE_CALL;
1666 case AudioStreamType::SYSTEM:
1667 return AUDIO_STREAM_SYSTEM;
1668 case AudioStreamType::RING:
1669 return AUDIO_STREAM_RING;
1670 case AudioStreamType::MUSIC:
1671 return AUDIO_STREAM_MUSIC;
1672 case AudioStreamType::ALARM:
1673 return AUDIO_STREAM_ALARM;
1674 case AudioStreamType::NOTIFICATION:
1675 return AUDIO_STREAM_NOTIFICATION;
1676 case AudioStreamType::BLUETOOTH_SCO:
1677 return AUDIO_STREAM_BLUETOOTH_SCO;
1678 case AudioStreamType::ENFORCED_AUDIBLE:
1679 return AUDIO_STREAM_ENFORCED_AUDIBLE;
1680 case AudioStreamType::DTMF:
1681 return AUDIO_STREAM_DTMF;
1682 case AudioStreamType::TTS:
1683 return AUDIO_STREAM_TTS;
1684 case AudioStreamType::ACCESSIBILITY:
1685 return AUDIO_STREAM_ACCESSIBILITY;
1686 case AudioStreamType::ASSISTANT:
1687 return AUDIO_STREAM_ASSISTANT;
1688 case AudioStreamType::SYS_RESERVED_REROUTING:
1689 return AUDIO_STREAM_REROUTING;
1690 case AudioStreamType::SYS_RESERVED_PATCH:
1691 return AUDIO_STREAM_PATCH;
1692 case AudioStreamType::CALL_ASSISTANT:
1693 return AUDIO_STREAM_CALL_ASSISTANT;
1694 }
1695 return unexpected(BAD_VALUE);
1696 }
1697
legacy2aidl_audio_stream_type_t_AudioStreamType(audio_stream_type_t legacy)1698 ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
1699 audio_stream_type_t legacy) {
1700 switch (legacy) {
1701 case AUDIO_STREAM_DEFAULT:
1702 return AudioStreamType::SYS_RESERVED_DEFAULT;
1703 case AUDIO_STREAM_VOICE_CALL:
1704 return AudioStreamType::VOICE_CALL;
1705 case AUDIO_STREAM_SYSTEM:
1706 return AudioStreamType::SYSTEM;
1707 case AUDIO_STREAM_RING:
1708 return AudioStreamType::RING;
1709 case AUDIO_STREAM_MUSIC:
1710 return AudioStreamType::MUSIC;
1711 case AUDIO_STREAM_ALARM:
1712 return AudioStreamType::ALARM;
1713 case AUDIO_STREAM_NOTIFICATION:
1714 return AudioStreamType::NOTIFICATION;
1715 case AUDIO_STREAM_BLUETOOTH_SCO:
1716 return AudioStreamType::BLUETOOTH_SCO;
1717 case AUDIO_STREAM_ENFORCED_AUDIBLE:
1718 return AudioStreamType::ENFORCED_AUDIBLE;
1719 case AUDIO_STREAM_DTMF:
1720 return AudioStreamType::DTMF;
1721 case AUDIO_STREAM_TTS:
1722 return AudioStreamType::TTS;
1723 case AUDIO_STREAM_ACCESSIBILITY:
1724 return AudioStreamType::ACCESSIBILITY;
1725 case AUDIO_STREAM_ASSISTANT:
1726 return AudioStreamType::ASSISTANT;
1727 case AUDIO_STREAM_REROUTING:
1728 return AudioStreamType::SYS_RESERVED_REROUTING;
1729 case AUDIO_STREAM_PATCH:
1730 return AudioStreamType::SYS_RESERVED_PATCH;
1731 case AUDIO_STREAM_CALL_ASSISTANT:
1732 return AudioStreamType::CALL_ASSISTANT;
1733 }
1734 return unexpected(BAD_VALUE);
1735 }
1736
aidl2legacy_AudioSource_audio_source_t(AudioSource aidl)1737 ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
1738 AudioSource aidl) {
1739 switch (aidl) {
1740 case AudioSource::SYS_RESERVED_INVALID:
1741 return AUDIO_SOURCE_INVALID;
1742 case AudioSource::DEFAULT:
1743 return AUDIO_SOURCE_DEFAULT;
1744 case AudioSource::MIC:
1745 return AUDIO_SOURCE_MIC;
1746 case AudioSource::VOICE_UPLINK:
1747 return AUDIO_SOURCE_VOICE_UPLINK;
1748 case AudioSource::VOICE_DOWNLINK:
1749 return AUDIO_SOURCE_VOICE_DOWNLINK;
1750 case AudioSource::VOICE_CALL:
1751 return AUDIO_SOURCE_VOICE_CALL;
1752 case AudioSource::CAMCORDER:
1753 return AUDIO_SOURCE_CAMCORDER;
1754 case AudioSource::VOICE_RECOGNITION:
1755 return AUDIO_SOURCE_VOICE_RECOGNITION;
1756 case AudioSource::VOICE_COMMUNICATION:
1757 return AUDIO_SOURCE_VOICE_COMMUNICATION;
1758 case AudioSource::REMOTE_SUBMIX:
1759 return AUDIO_SOURCE_REMOTE_SUBMIX;
1760 case AudioSource::UNPROCESSED:
1761 return AUDIO_SOURCE_UNPROCESSED;
1762 case AudioSource::VOICE_PERFORMANCE:
1763 return AUDIO_SOURCE_VOICE_PERFORMANCE;
1764 case AudioSource::ULTRASOUND:
1765 return AUDIO_SOURCE_ULTRASOUND;
1766 case AudioSource::ECHO_REFERENCE:
1767 return AUDIO_SOURCE_ECHO_REFERENCE;
1768 case AudioSource::FM_TUNER:
1769 return AUDIO_SOURCE_FM_TUNER;
1770 case AudioSource::HOTWORD:
1771 return AUDIO_SOURCE_HOTWORD;
1772 }
1773 return unexpected(BAD_VALUE);
1774 }
1775
legacy2aidl_audio_source_t_AudioSource(audio_source_t legacy)1776 ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
1777 audio_source_t legacy) {
1778 switch (legacy) {
1779 case AUDIO_SOURCE_INVALID:
1780 return AudioSource::SYS_RESERVED_INVALID;
1781 case AUDIO_SOURCE_DEFAULT:
1782 return AudioSource::DEFAULT;
1783 case AUDIO_SOURCE_MIC:
1784 return AudioSource::MIC;
1785 case AUDIO_SOURCE_VOICE_UPLINK:
1786 return AudioSource::VOICE_UPLINK;
1787 case AUDIO_SOURCE_VOICE_DOWNLINK:
1788 return AudioSource::VOICE_DOWNLINK;
1789 case AUDIO_SOURCE_VOICE_CALL:
1790 return AudioSource::VOICE_CALL;
1791 case AUDIO_SOURCE_CAMCORDER:
1792 return AudioSource::CAMCORDER;
1793 case AUDIO_SOURCE_VOICE_RECOGNITION:
1794 return AudioSource::VOICE_RECOGNITION;
1795 case AUDIO_SOURCE_VOICE_COMMUNICATION:
1796 return AudioSource::VOICE_COMMUNICATION;
1797 case AUDIO_SOURCE_REMOTE_SUBMIX:
1798 return AudioSource::REMOTE_SUBMIX;
1799 case AUDIO_SOURCE_UNPROCESSED:
1800 return AudioSource::UNPROCESSED;
1801 case AUDIO_SOURCE_VOICE_PERFORMANCE:
1802 return AudioSource::VOICE_PERFORMANCE;
1803 case AUDIO_SOURCE_ULTRASOUND:
1804 return AudioSource::ULTRASOUND;
1805 case AUDIO_SOURCE_ECHO_REFERENCE:
1806 return AudioSource::ECHO_REFERENCE;
1807 case AUDIO_SOURCE_FM_TUNER:
1808 return AudioSource::FM_TUNER;
1809 case AUDIO_SOURCE_HOTWORD:
1810 return AudioSource::HOTWORD;
1811 }
1812 return unexpected(BAD_VALUE);
1813 }
1814
aidl2legacy_int32_t_audio_session_t(int32_t aidl)1815 ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
1816 return convertReinterpret<audio_session_t>(aidl);
1817 }
1818
legacy2aidl_audio_session_t_int32_t(audio_session_t legacy)1819 ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
1820 return convertReinterpret<int32_t>(legacy);
1821 }
1822
1823 // This type is unnamed in the original definition, thus we name it here.
1824 using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);
1825
aidl2legacy_AudioPortMixExtUseCase(const AudioPortMixExtUseCase & aidl,media::AudioPortRole role)1826 ConversionResult<audio_port_config_mix_ext_usecase> aidl2legacy_AudioPortMixExtUseCase(
1827 const AudioPortMixExtUseCase& aidl, media::AudioPortRole role) {
1828 audio_port_config_mix_ext_usecase legacy;
1829
1830 switch (role) {
1831 case media::AudioPortRole::NONE:
1832 // Just verify that the union is empty.
1833 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
1834 return legacy;
1835
1836 case media::AudioPortRole::SOURCE:
1837 // This is not a bug. A SOURCE role corresponds to the stream field.
1838 legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
1839 VALUE_OR_RETURN(UNION_GET(aidl, stream))));
1840 return legacy;
1841
1842 case media::AudioPortRole::SINK:
1843 // This is not a bug. A SINK role corresponds to the source field.
1844 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(
1845 VALUE_OR_RETURN(UNION_GET(aidl, source))));
1846 return legacy;
1847 }
1848 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
1849 }
1850
legacy2aidl_AudioPortMixExtUseCase(const audio_port_config_mix_ext_usecase & legacy,audio_port_role_t role)1851 ConversionResult<AudioPortMixExtUseCase> legacy2aidl_AudioPortMixExtUseCase(
1852 const audio_port_config_mix_ext_usecase& legacy, audio_port_role_t role) {
1853 AudioPortMixExtUseCase aidl;
1854
1855 switch (role) {
1856 case AUDIO_PORT_ROLE_NONE:
1857 UNION_SET(aidl, unspecified, false);
1858 return aidl;
1859 case AUDIO_PORT_ROLE_SOURCE:
1860 // This is not a bug. A SOURCE role corresponds to the stream field.
1861 UNION_SET(aidl, stream, VALUE_OR_RETURN(
1862 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));
1863 return aidl;
1864 case AUDIO_PORT_ROLE_SINK:
1865 // This is not a bug. A SINK role corresponds to the source field.
1866 UNION_SET(aidl, source,
1867 VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSource(legacy.source)));
1868 return aidl;
1869 }
1870 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
1871 }
1872
aidl2legacy_AudioPortMixExt(const AudioPortMixExt & aidl,media::AudioPortRole role,const media::AudioPortMixExtSys & aidlMixExt)1873 ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt(
1874 const AudioPortMixExt& aidl, media::AudioPortRole role,
1875 const media::AudioPortMixExtSys& aidlMixExt) {
1876 audio_port_config_mix_ext legacy;
1877 legacy.hw_module = VALUE_OR_RETURN(
1878 aidl2legacy_int32_t_audio_module_handle_t(aidlMixExt.hwModule));
1879 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
1880 legacy.usecase = VALUE_OR_RETURN(aidl2legacy_AudioPortMixExtUseCase(aidl.usecase, role));
1881 return legacy;
1882 }
1883
legacy2aidl_AudioPortMixExt(const audio_port_config_mix_ext & legacy,audio_port_role_t role,AudioPortMixExt * aidl,media::AudioPortMixExtSys * aidlMixExt)1884 status_t legacy2aidl_AudioPortMixExt(
1885 const audio_port_config_mix_ext& legacy, audio_port_role_t role,
1886 AudioPortMixExt* aidl, media::AudioPortMixExtSys* aidlMixExt) {
1887 aidlMixExt->hwModule = VALUE_OR_RETURN_STATUS(
1888 legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1889 aidl->handle = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
1890 aidl->usecase = VALUE_OR_RETURN_STATUS(
1891 legacy2aidl_AudioPortMixExtUseCase(legacy.usecase, role));
1892 return OK;
1893 }
1894
1895 ConversionResult<audio_port_config_session_ext>
aidl2legacy_int32_t_audio_port_config_session_ext(int32_t aidl)1896 aidl2legacy_int32_t_audio_port_config_session_ext(int32_t aidl) {
1897 audio_port_config_session_ext legacy;
1898 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl));
1899 return legacy;
1900 }
1901
1902 ConversionResult<int32_t>
legacy2aidl_audio_port_config_session_ext_int32_t(const audio_port_config_session_ext & legacy)1903 legacy2aidl_audio_port_config_session_ext_int32_t(
1904 const audio_port_config_session_ext& legacy) {
1905 return legacy2aidl_audio_session_t_int32_t(legacy.session);
1906 }
1907
1908 // This type is unnamed in the original definition, thus we name it here.
1909 using audio_port_config_ext = decltype(audio_port_config::ext);
1910
aidl2legacy_AudioPortExt_audio_port_config_ext(const AudioPortExt & aidl,media::AudioPortType type,media::AudioPortRole role,const media::AudioPortExtSys & aidlSys)1911 ConversionResult<audio_port_config_ext> aidl2legacy_AudioPortExt_audio_port_config_ext(
1912 const AudioPortExt& aidl, media::AudioPortType type,
1913 media::AudioPortRole role, const media::AudioPortExtSys& aidlSys) {
1914 audio_port_config_ext legacy;
1915 switch (type) {
1916 case media::AudioPortType::NONE:
1917 // Just verify that the union is empty.
1918 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
1919 return legacy;
1920 case media::AudioPortType::DEVICE:
1921 legacy.device = VALUE_OR_RETURN(
1922 aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
1923 VALUE_OR_RETURN(UNION_GET(aidl, device)),
1924 VALUE_OR_RETURN(UNION_GET(aidlSys, device))));
1925 return legacy;
1926 case media::AudioPortType::MIX:
1927 legacy.mix = VALUE_OR_RETURN(
1928 aidl2legacy_AudioPortMixExt(
1929 VALUE_OR_RETURN(UNION_GET(aidl, mix)), role,
1930 VALUE_OR_RETURN(UNION_GET(aidlSys, mix))));
1931 return legacy;
1932 case media::AudioPortType::SESSION:
1933 legacy.session = VALUE_OR_RETURN(
1934 aidl2legacy_int32_t_audio_port_config_session_ext(
1935 VALUE_OR_RETURN(UNION_GET(aidl, session))));
1936 return legacy;
1937
1938 }
1939 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
1940 }
1941
legacy2aidl_AudioPortExt(const audio_port_config_ext & legacy,audio_port_type_t type,audio_port_role_t role,AudioPortExt * aidl,media::AudioPortExtSys * aidlSys)1942 status_t legacy2aidl_AudioPortExt(
1943 const audio_port_config_ext& legacy, audio_port_type_t type, audio_port_role_t role,
1944 AudioPortExt* aidl, media::AudioPortExtSys* aidlSys) {
1945 switch (type) {
1946 case AUDIO_PORT_TYPE_NONE:
1947 UNION_SET(*aidl, unspecified, false);
1948 UNION_SET(*aidlSys, unspecified, false);
1949 return OK;
1950 case AUDIO_PORT_TYPE_DEVICE: {
1951 AudioPortDeviceExt device;
1952 media::AudioPortDeviceExtSys deviceSys;
1953 RETURN_STATUS_IF_ERROR(
1954 legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
1955 legacy.device, &device, &deviceSys));
1956 UNION_SET(*aidl, device, device);
1957 UNION_SET(*aidlSys, device, deviceSys);
1958 return OK;
1959 }
1960 case AUDIO_PORT_TYPE_MIX: {
1961 AudioPortMixExt mix;
1962 media::AudioPortMixExtSys mixSys;
1963 RETURN_STATUS_IF_ERROR(legacy2aidl_AudioPortMixExt(legacy.mix, role, &mix, &mixSys));
1964 UNION_SET(*aidl, mix, mix);
1965 UNION_SET(*aidlSys, mix, mixSys);
1966 return OK;
1967 }
1968 case AUDIO_PORT_TYPE_SESSION:
1969 UNION_SET(*aidl, session, VALUE_OR_RETURN_STATUS(
1970 legacy2aidl_audio_port_config_session_ext_int32_t(legacy.session)));
1971 UNION_SET(*aidlSys, unspecified, false);
1972 return OK;
1973 }
1974 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
1975 }
1976
aidl2legacy_AudioPortConfig_audio_port_config(const media::AudioPortConfig & aidl)1977 ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_config(
1978 const media::AudioPortConfig& aidl) {
1979 audio_port_config legacy{};
1980 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.hal.id));
1981 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.sys.role));
1982 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.sys.type));
1983 const bool isInput =
1984 VALUE_OR_RETURN(direction(aidl.sys.role, aidl.sys.type)) == Direction::INPUT;
1985 if (aidl.hal.sampleRate.has_value()) {
1986 legacy.sample_rate = VALUE_OR_RETURN(
1987 convertIntegral<unsigned int>(aidl.hal.sampleRate.value().value));
1988 legacy.config_mask |= AUDIO_PORT_CONFIG_SAMPLE_RATE;
1989 }
1990 if (aidl.hal.channelMask.has_value()) {
1991 legacy.channel_mask =
1992 VALUE_OR_RETURN(
1993 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
1994 aidl.hal.channelMask.value(), isInput));
1995 legacy.config_mask |= AUDIO_PORT_CONFIG_CHANNEL_MASK;
1996 }
1997 if (aidl.hal.format.has_value()) {
1998 legacy.format = VALUE_OR_RETURN(
1999 aidl2legacy_AudioFormatDescription_audio_format_t(aidl.hal.format.value()));
2000 legacy.config_mask |= AUDIO_PORT_CONFIG_FORMAT;
2001 }
2002 if (aidl.hal.gain.has_value()) {
2003 legacy.gain = VALUE_OR_RETURN(aidl2legacy_AudioGainConfig_audio_gain_config(
2004 aidl.hal.gain.value(), isInput));
2005 legacy.config_mask |= AUDIO_PORT_CONFIG_GAIN;
2006 }
2007 if (aidl.hal.flags.has_value()) {
2008 legacy.flags = VALUE_OR_RETURN(
2009 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.hal.flags.value(), isInput));
2010 legacy.config_mask |= AUDIO_PORT_CONFIG_FLAGS;
2011 }
2012 legacy.ext = VALUE_OR_RETURN(
2013 aidl2legacy_AudioPortExt_audio_port_config_ext(
2014 aidl.hal.ext, aidl.sys.type, aidl.sys.role, aidl.sys.ext));
2015 return legacy;
2016 }
2017
legacy2aidl_audio_port_config_AudioPortConfig(const audio_port_config & legacy)2018 ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPortConfig(
2019 const audio_port_config& legacy) {
2020 media::AudioPortConfig aidl;
2021 aidl.hal.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2022 aidl.sys.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
2023 aidl.sys.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
2024 const bool isInput = VALUE_OR_RETURN(
2025 direction(legacy.role, legacy.type)) == Direction::INPUT;
2026 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
2027 Int aidl_sampleRate;
2028 aidl_sampleRate.value = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
2029 aidl.hal.sampleRate = aidl_sampleRate;
2030 }
2031 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
2032 aidl.hal.channelMask = VALUE_OR_RETURN(
2033 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2034 }
2035 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
2036 aidl.hal.format = VALUE_OR_RETURN(
2037 legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2038 }
2039 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
2040 aidl.hal.gain = VALUE_OR_RETURN(
2041 legacy2aidl_audio_gain_config_AudioGainConfig(legacy.gain, isInput));
2042 }
2043 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
2044 aidl.hal.flags = VALUE_OR_RETURN(
2045 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, isInput));
2046 }
2047 RETURN_IF_ERROR(legacy2aidl_AudioPortExt(legacy.ext, legacy.type, legacy.role,
2048 &aidl.hal.ext, &aidl.sys.ext));
2049 return aidl;
2050 }
2051
aidl2legacy_AudioPatch_audio_patch(const media::AudioPatch & aidl)2052 ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch(
2053 const media::AudioPatch& aidl) {
2054 struct audio_patch legacy;
2055 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_patch_handle_t(aidl.id));
2056 legacy.num_sinks = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sinks.size()));
2057 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
2058 return unexpected(BAD_VALUE);
2059 }
2060 for (size_t i = 0; i < legacy.num_sinks; ++i) {
2061 legacy.sinks[i] =
2062 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sinks[i]));
2063 }
2064 legacy.num_sources = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sources.size()));
2065 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
2066 return unexpected(BAD_VALUE);
2067 }
2068 for (size_t i = 0; i < legacy.num_sources; ++i) {
2069 legacy.sources[i] =
2070 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sources[i]));
2071 }
2072 return legacy;
2073 }
2074
legacy2aidl_audio_patch_AudioPatch(const struct audio_patch & legacy)2075 ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch(
2076 const struct audio_patch& legacy) {
2077 media::AudioPatch aidl;
2078 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_patch_handle_t_int32_t(legacy.id));
2079
2080 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
2081 return unexpected(BAD_VALUE);
2082 }
2083 for (unsigned int i = 0; i < legacy.num_sinks; ++i) {
2084 aidl.sinks.push_back(
2085 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sinks[i])));
2086 }
2087 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
2088 return unexpected(BAD_VALUE);
2089 }
2090 for (unsigned int i = 0; i < legacy.num_sources; ++i) {
2091 aidl.sources.push_back(
2092 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sources[i])));
2093 }
2094 return aidl;
2095 }
2096
aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(const media::AudioIoDescriptor & aidl)2097 ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(
2098 const media::AudioIoDescriptor& aidl) {
2099 const audio_io_handle_t io_handle = VALUE_OR_RETURN(
2100 aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));
2101 const struct audio_patch patch = VALUE_OR_RETURN(
2102 aidl2legacy_AudioPatch_audio_patch(aidl.patch));
2103 const bool isInput = aidl.isInput;
2104 const uint32_t sampling_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));
2105 const audio_format_t format = VALUE_OR_RETURN(
2106 aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
2107 const audio_channel_mask_t channel_mask = VALUE_OR_RETURN(
2108 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
2109 const size_t frame_count = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
2110 const size_t frame_count_hal = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));
2111 const uint32_t latency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));
2112 const audio_port_handle_t port_id = VALUE_OR_RETURN(
2113 aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
2114 return sp<AudioIoDescriptor>::make(io_handle, patch, isInput, sampling_rate, format,
2115 channel_mask, frame_count, frame_count_hal, latency, port_id);
2116 }
2117
legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(const sp<AudioIoDescriptor> & legacy)2118 ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(
2119 const sp<AudioIoDescriptor>& legacy) {
2120 media::AudioIoDescriptor aidl;
2121 aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->getIoHandle()));
2122 aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->getPatch()));
2123 aidl.isInput = legacy->getIsInput();
2124 aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getSamplingRate()));
2125 aidl.format = VALUE_OR_RETURN(
2126 legacy2aidl_audio_format_t_AudioFormatDescription(legacy->getFormat()));
2127 aidl.channelMask = VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
2128 legacy->getChannelMask(), legacy->getIsInput()));
2129 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->getFrameCount()));
2130 aidl.frameCountHAL = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->getFrameCountHAL()));
2131 aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getLatency()));
2132 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy->getPortId()));
2133 return aidl;
2134 }
2135
aidl2legacy_AudioClient_AudioClient(const media::AudioClient & aidl)2136 ConversionResult<AudioClient> aidl2legacy_AudioClient_AudioClient(
2137 const media::AudioClient& aidl) {
2138 AudioClient legacy;
2139 legacy.clientTid = VALUE_OR_RETURN(aidl2legacy_int32_t_pid_t(aidl.clientTid));
2140 legacy.attributionSource = aidl.attributionSource;
2141 return legacy;
2142 }
2143
legacy2aidl_AudioClient_AudioClient(const AudioClient & legacy)2144 ConversionResult<media::AudioClient> legacy2aidl_AudioClient_AudioClient(
2145 const AudioClient& legacy) {
2146 media::AudioClient aidl;
2147 aidl.clientTid = VALUE_OR_RETURN(legacy2aidl_pid_t_int32_t(legacy.clientTid));
2148 aidl.attributionSource = legacy.attributionSource;
2149 return aidl;
2150 }
2151
2152 ConversionResult<audio_content_type_t>
aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl)2153 aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
2154 switch (aidl) {
2155 case AudioContentType::UNKNOWN:
2156 return AUDIO_CONTENT_TYPE_UNKNOWN;
2157 case AudioContentType::SPEECH:
2158 return AUDIO_CONTENT_TYPE_SPEECH;
2159 case AudioContentType::MUSIC:
2160 return AUDIO_CONTENT_TYPE_MUSIC;
2161 case AudioContentType::MOVIE:
2162 return AUDIO_CONTENT_TYPE_MOVIE;
2163 case AudioContentType::SONIFICATION:
2164 return AUDIO_CONTENT_TYPE_SONIFICATION;
2165 case AudioContentType::ULTRASOUND:
2166 return AUDIO_CONTENT_TYPE_ULTRASOUND;
2167 }
2168 return unexpected(BAD_VALUE);
2169 }
2170
2171 ConversionResult<AudioContentType>
legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy)2172 legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
2173 switch (legacy) {
2174 case AUDIO_CONTENT_TYPE_UNKNOWN:
2175 return AudioContentType::UNKNOWN;
2176 case AUDIO_CONTENT_TYPE_SPEECH:
2177 return AudioContentType::SPEECH;
2178 case AUDIO_CONTENT_TYPE_MUSIC:
2179 return AudioContentType::MUSIC;
2180 case AUDIO_CONTENT_TYPE_MOVIE:
2181 return AudioContentType::MOVIE;
2182 case AUDIO_CONTENT_TYPE_SONIFICATION:
2183 return AudioContentType::SONIFICATION;
2184 case AUDIO_CONTENT_TYPE_ULTRASOUND:
2185 return AudioContentType::ULTRASOUND;
2186 }
2187 return unexpected(BAD_VALUE);
2188 }
2189
2190 ConversionResult<audio_usage_t>
aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl)2191 aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
2192 switch (aidl) {
2193 case AudioUsage::INVALID:
2194 break; // return error
2195 case AudioUsage::UNKNOWN:
2196 return AUDIO_USAGE_UNKNOWN;
2197 case AudioUsage::MEDIA:
2198 return AUDIO_USAGE_MEDIA;
2199 case AudioUsage::VOICE_COMMUNICATION:
2200 return AUDIO_USAGE_VOICE_COMMUNICATION;
2201 case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
2202 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
2203 case AudioUsage::ALARM:
2204 return AUDIO_USAGE_ALARM;
2205 case AudioUsage::NOTIFICATION:
2206 return AUDIO_USAGE_NOTIFICATION;
2207 case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
2208 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
2209 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
2210 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
2211 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
2212 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
2213 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
2214 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
2215 case AudioUsage::NOTIFICATION_EVENT:
2216 return AUDIO_USAGE_NOTIFICATION_EVENT;
2217 case AudioUsage::ASSISTANCE_ACCESSIBILITY:
2218 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
2219 case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
2220 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
2221 case AudioUsage::ASSISTANCE_SONIFICATION:
2222 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
2223 case AudioUsage::GAME:
2224 return AUDIO_USAGE_GAME;
2225 case AudioUsage::VIRTUAL_SOURCE:
2226 return AUDIO_USAGE_VIRTUAL_SOURCE;
2227 case AudioUsage::ASSISTANT:
2228 return AUDIO_USAGE_ASSISTANT;
2229 case AudioUsage::CALL_ASSISTANT:
2230 return AUDIO_USAGE_CALL_ASSISTANT;
2231 case AudioUsage::EMERGENCY:
2232 return AUDIO_USAGE_EMERGENCY;
2233 case AudioUsage::SAFETY:
2234 return AUDIO_USAGE_SAFETY;
2235 case AudioUsage::VEHICLE_STATUS:
2236 return AUDIO_USAGE_VEHICLE_STATUS;
2237 case AudioUsage::ANNOUNCEMENT:
2238 return AUDIO_USAGE_ANNOUNCEMENT;
2239 }
2240 return unexpected(BAD_VALUE);
2241 }
2242
2243 ConversionResult<AudioUsage>
legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy)2244 legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
2245 switch (legacy) {
2246 case AUDIO_USAGE_UNKNOWN:
2247 return AudioUsage::UNKNOWN;
2248 case AUDIO_USAGE_MEDIA:
2249 return AudioUsage::MEDIA;
2250 case AUDIO_USAGE_VOICE_COMMUNICATION:
2251 return AudioUsage::VOICE_COMMUNICATION;
2252 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
2253 return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
2254 case AUDIO_USAGE_ALARM:
2255 return AudioUsage::ALARM;
2256 case AUDIO_USAGE_NOTIFICATION:
2257 return AudioUsage::NOTIFICATION;
2258 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
2259 return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
2260 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
2261 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
2262 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
2263 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
2264 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
2265 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
2266 case AUDIO_USAGE_NOTIFICATION_EVENT:
2267 return AudioUsage::NOTIFICATION_EVENT;
2268 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
2269 return AudioUsage::ASSISTANCE_ACCESSIBILITY;
2270 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
2271 return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
2272 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
2273 return AudioUsage::ASSISTANCE_SONIFICATION;
2274 case AUDIO_USAGE_GAME:
2275 return AudioUsage::GAME;
2276 case AUDIO_USAGE_VIRTUAL_SOURCE:
2277 return AudioUsage::VIRTUAL_SOURCE;
2278 case AUDIO_USAGE_ASSISTANT:
2279 return AudioUsage::ASSISTANT;
2280 case AUDIO_USAGE_CALL_ASSISTANT:
2281 return AudioUsage::CALL_ASSISTANT;
2282 case AUDIO_USAGE_EMERGENCY:
2283 return AudioUsage::EMERGENCY;
2284 case AUDIO_USAGE_SAFETY:
2285 return AudioUsage::SAFETY;
2286 case AUDIO_USAGE_VEHICLE_STATUS:
2287 return AudioUsage::VEHICLE_STATUS;
2288 case AUDIO_USAGE_ANNOUNCEMENT:
2289 return AudioUsage::ANNOUNCEMENT;
2290 }
2291 return unexpected(BAD_VALUE);
2292 }
2293
2294 ConversionResult<audio_flags_mask_t>
aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl)2295 aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl) {
2296 switch (aidl) {
2297 case media::AudioFlag::AUDIBILITY_ENFORCED:
2298 return AUDIO_FLAG_AUDIBILITY_ENFORCED;
2299 case media::AudioFlag::SECURE:
2300 return AUDIO_FLAG_SECURE;
2301 case media::AudioFlag::SCO:
2302 return AUDIO_FLAG_SCO;
2303 case media::AudioFlag::BEACON:
2304 return AUDIO_FLAG_BEACON;
2305 case media::AudioFlag::HW_AV_SYNC:
2306 return AUDIO_FLAG_HW_AV_SYNC;
2307 case media::AudioFlag::HW_HOTWORD:
2308 return AUDIO_FLAG_HW_HOTWORD;
2309 case media::AudioFlag::BYPASS_INTERRUPTION_POLICY:
2310 return AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY;
2311 case media::AudioFlag::BYPASS_MUTE:
2312 return AUDIO_FLAG_BYPASS_MUTE;
2313 case media::AudioFlag::LOW_LATENCY:
2314 return AUDIO_FLAG_LOW_LATENCY;
2315 case media::AudioFlag::DEEP_BUFFER:
2316 return AUDIO_FLAG_DEEP_BUFFER;
2317 case media::AudioFlag::NO_MEDIA_PROJECTION:
2318 return AUDIO_FLAG_NO_MEDIA_PROJECTION;
2319 case media::AudioFlag::MUTE_HAPTIC:
2320 return AUDIO_FLAG_MUTE_HAPTIC;
2321 case media::AudioFlag::NO_SYSTEM_CAPTURE:
2322 return AUDIO_FLAG_NO_SYSTEM_CAPTURE;
2323 case media::AudioFlag::CAPTURE_PRIVATE:
2324 return AUDIO_FLAG_CAPTURE_PRIVATE;
2325 case media::AudioFlag::CONTENT_SPATIALIZED:
2326 return AUDIO_FLAG_CONTENT_SPATIALIZED;
2327 case media::AudioFlag::NEVER_SPATIALIZE:
2328 return AUDIO_FLAG_NEVER_SPATIALIZE;
2329 case media::AudioFlag::CALL_REDIRECTION:
2330 return AUDIO_FLAG_CALL_REDIRECTION;
2331 }
2332 return unexpected(BAD_VALUE);
2333 }
2334
2335 ConversionResult<media::AudioFlag>
legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy)2336 legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy) {
2337 switch (legacy) {
2338 case AUDIO_FLAG_NONE:
2339 return unexpected(BAD_VALUE);
2340 case AUDIO_FLAG_AUDIBILITY_ENFORCED:
2341 return media::AudioFlag::AUDIBILITY_ENFORCED;
2342 case AUDIO_FLAG_SECURE:
2343 return media::AudioFlag::SECURE;
2344 case AUDIO_FLAG_SCO:
2345 return media::AudioFlag::SCO;
2346 case AUDIO_FLAG_BEACON:
2347 return media::AudioFlag::BEACON;
2348 case AUDIO_FLAG_HW_AV_SYNC:
2349 return media::AudioFlag::HW_AV_SYNC;
2350 case AUDIO_FLAG_HW_HOTWORD:
2351 return media::AudioFlag::HW_HOTWORD;
2352 case AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY:
2353 return media::AudioFlag::BYPASS_INTERRUPTION_POLICY;
2354 case AUDIO_FLAG_BYPASS_MUTE:
2355 return media::AudioFlag::BYPASS_MUTE;
2356 case AUDIO_FLAG_LOW_LATENCY:
2357 return media::AudioFlag::LOW_LATENCY;
2358 case AUDIO_FLAG_DEEP_BUFFER:
2359 return media::AudioFlag::DEEP_BUFFER;
2360 case AUDIO_FLAG_NO_MEDIA_PROJECTION:
2361 return media::AudioFlag::NO_MEDIA_PROJECTION;
2362 case AUDIO_FLAG_MUTE_HAPTIC:
2363 return media::AudioFlag::MUTE_HAPTIC;
2364 case AUDIO_FLAG_NO_SYSTEM_CAPTURE:
2365 return media::AudioFlag::NO_SYSTEM_CAPTURE;
2366 case AUDIO_FLAG_CAPTURE_PRIVATE:
2367 return media::AudioFlag::CAPTURE_PRIVATE;
2368 case AUDIO_FLAG_CONTENT_SPATIALIZED:
2369 return media::AudioFlag::CONTENT_SPATIALIZED;
2370 case AUDIO_FLAG_NEVER_SPATIALIZE:
2371 return media::AudioFlag::NEVER_SPATIALIZE;
2372 case AUDIO_FLAG_CALL_REDIRECTION:
2373 return media::AudioFlag::CALL_REDIRECTION;
2374 }
2375 return unexpected(BAD_VALUE);
2376 }
2377
2378 ConversionResult<audio_flags_mask_t>
aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl)2379 aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {
2380 return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(
2381 aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, indexToEnum_index<media::AudioFlag>,
2382 enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);
2383 }
2384
2385 ConversionResult<int32_t>
legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy)2386 legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {
2387 return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(
2388 legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,
2389 indexToEnum_bitmask<audio_flags_mask_t>,
2390 enumToMask_index<int32_t, media::AudioFlag>);
2391 }
2392
2393 ConversionResult<audio_attributes_t>
aidl2legacy_AudioAttributesInternal_audio_attributes_t(const media::AudioAttributesInternal & aidl)2394 aidl2legacy_AudioAttributesInternal_audio_attributes_t(const media::AudioAttributesInternal& aidl) {
2395 audio_attributes_t legacy;
2396 legacy.content_type = VALUE_OR_RETURN(
2397 aidl2legacy_AudioContentType_audio_content_type_t(aidl.contentType));
2398 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
2399 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(aidl.source));
2400 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_flags_mask_t_mask(aidl.flags));
2401 RETURN_IF_ERROR(aidl2legacy_string(aidl.tags, legacy.tags, sizeof(legacy.tags)));
2402 return legacy;
2403 }
2404
2405 ConversionResult<media::AudioAttributesInternal>
legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t & legacy)2406 legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t& legacy) {
2407 media::AudioAttributesInternal aidl;
2408 aidl.contentType = VALUE_OR_RETURN(
2409 legacy2aidl_audio_content_type_t_AudioContentType(legacy.content_type));
2410 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
2411 aidl.source = VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSource(legacy.source));
2412 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_flags_mask_t_int32_t_mask(legacy.flags));
2413 aidl.tags = VALUE_OR_RETURN(legacy2aidl_string(legacy.tags, sizeof(legacy.tags)));
2414 return aidl;
2415 }
2416
2417 ConversionResult<audio_encapsulation_mode_t>
aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl)2418 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
2419 switch (aidl) {
2420 case AudioEncapsulationMode::INVALID:
2421 break; // return error
2422 case AudioEncapsulationMode::NONE:
2423 return AUDIO_ENCAPSULATION_MODE_NONE;
2424 case AudioEncapsulationMode::ELEMENTARY_STREAM:
2425 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
2426 case AudioEncapsulationMode::HANDLE:
2427 return AUDIO_ENCAPSULATION_MODE_HANDLE;
2428 }
2429 return unexpected(BAD_VALUE);
2430 }
2431
2432 ConversionResult<AudioEncapsulationMode>
legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy)2433 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
2434 switch (legacy) {
2435 case AUDIO_ENCAPSULATION_MODE_NONE:
2436 return AudioEncapsulationMode::NONE;
2437 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
2438 return AudioEncapsulationMode::ELEMENTARY_STREAM;
2439 case AUDIO_ENCAPSULATION_MODE_HANDLE:
2440 return AudioEncapsulationMode::HANDLE;
2441 }
2442 return unexpected(BAD_VALUE);
2443 }
2444
2445 ConversionResult<audio_offload_info_t>
aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo & aidl)2446 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
2447 audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
2448 audio_config_base_t base = VALUE_OR_RETURN(
2449 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
2450 legacy.sample_rate = base.sample_rate;
2451 legacy.channel_mask = base.channel_mask;
2452 legacy.format = base.format;
2453 legacy.stream_type = VALUE_OR_RETURN(
2454 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
2455 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));
2456 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
2457 legacy.has_video = aidl.hasVideo;
2458 legacy.is_streaming = aidl.isStreaming;
2459 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
2460 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
2461 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
2462 legacy.encapsulation_mode = VALUE_OR_RETURN(
2463 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
2464 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
2465 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
2466 return legacy;
2467 }
2468
2469 ConversionResult<AudioOffloadInfo>
legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t & legacy)2470 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
2471 AudioOffloadInfo aidl;
2472 // Version 0.1 fields.
2473 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
2474 return unexpected(BAD_VALUE);
2475 }
2476 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
2477 .channel_mask = legacy.channel_mask, .format = legacy.format };
2478 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
2479 base, false /*isInput*/));
2480 aidl.streamType = VALUE_OR_RETURN(
2481 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
2482 aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
2483 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
2484 aidl.hasVideo = legacy.has_video;
2485 aidl.isStreaming = legacy.is_streaming;
2486 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
2487 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
2488 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
2489
2490 // Version 0.2 fields.
2491 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
2492 if (legacy.size <
2493 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
2494 return unexpected(BAD_VALUE);
2495 }
2496 aidl.encapsulationMode = VALUE_OR_RETURN(
2497 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
2498 legacy.encapsulation_mode));
2499 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
2500 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
2501 }
2502 return aidl;
2503 }
2504
2505 ConversionResult<audio_config_t>
aidl2legacy_AudioConfig_audio_config_t(const AudioConfig & aidl,bool isInput)2506 aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
2507 const audio_config_base_t legacyBase = VALUE_OR_RETURN(
2508 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
2509 audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
2510 legacy.sample_rate = legacyBase.sample_rate;
2511 legacy.channel_mask = legacyBase.channel_mask;
2512 legacy.format = legacyBase.format;
2513 legacy.offload_info = VALUE_OR_RETURN(
2514 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
2515 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
2516 return legacy;
2517 }
2518
2519 ConversionResult<AudioConfig>
legacy2aidl_audio_config_t_AudioConfig(const audio_config_t & legacy,bool isInput)2520 legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
2521 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
2522 .channel_mask = legacy.channel_mask, .format = legacy.format };
2523 AudioConfig aidl;
2524 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
2525 aidl.offloadInfo = VALUE_OR_RETURN(
2526 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
2527 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
2528 return aidl;
2529 }
2530
2531 ConversionResult<audio_config_base_t>
aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase & aidl,bool isInput)2532 aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
2533 audio_config_base_t legacy;
2534 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
2535 legacy.channel_mask = VALUE_OR_RETURN(
2536 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
2537 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
2538 return legacy;
2539 }
2540
2541 ConversionResult<AudioConfigBase>
legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t & legacy,bool isInput)2542 legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
2543 AudioConfigBase aidl;
2544 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
2545 aidl.channelMask = VALUE_OR_RETURN(
2546 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2547 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2548 return aidl;
2549 }
2550
2551 ConversionResult<sp<IMemory>>
aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion & aidl)2552 aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion& aidl) {
2553 sp<IMemory> legacy;
2554 if (!convertSharedFileRegionToIMemory(aidl, &legacy)) {
2555 return unexpected(BAD_VALUE);
2556 }
2557 return legacy;
2558 }
2559
2560 ConversionResult<media::SharedFileRegion>
legacy2aidl_IMemory_SharedFileRegion(const sp<IMemory> & legacy)2561 legacy2aidl_IMemory_SharedFileRegion(const sp<IMemory>& legacy) {
2562 media::SharedFileRegion aidl;
2563 if (!convertIMemoryToSharedFileRegion(legacy, &aidl)) {
2564 return unexpected(BAD_VALUE);
2565 }
2566 return aidl;
2567 }
2568
2569 ConversionResult<sp<IMemory>>
aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion> & aidl)2570 aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion>& aidl) {
2571 sp<IMemory> legacy;
2572 if (!convertNullableSharedFileRegionToIMemory(aidl, &legacy)) {
2573 return unexpected(BAD_VALUE);
2574 }
2575 return legacy;
2576 }
2577
2578 ConversionResult<std::optional<media::SharedFileRegion>>
legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory> & legacy)2579 legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy) {
2580 std::optional<media::SharedFileRegion> aidl;
2581 if (!convertNullableIMemoryToSharedFileRegion(legacy, &aidl)) {
2582 return unexpected(BAD_VALUE);
2583 }
2584 return aidl;
2585 }
2586
2587 ConversionResult<AudioTimestamp>
aidl2legacy_AudioTimestampInternal_AudioTimestamp(const media::AudioTimestampInternal & aidl)2588 aidl2legacy_AudioTimestampInternal_AudioTimestamp(const media::AudioTimestampInternal& aidl) {
2589 AudioTimestamp legacy;
2590 legacy.mPosition = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.position));
2591 legacy.mTime.tv_sec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sec));
2592 legacy.mTime.tv_nsec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.nsec));
2593 return legacy;
2594 }
2595
2596 ConversionResult<media::AudioTimestampInternal>
legacy2aidl_AudioTimestamp_AudioTimestampInternal(const AudioTimestamp & legacy)2597 legacy2aidl_AudioTimestamp_AudioTimestampInternal(const AudioTimestamp& legacy) {
2598 media::AudioTimestampInternal aidl;
2599 aidl.position = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mPosition));
2600 aidl.sec = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.mTime.tv_sec));
2601 aidl.nsec = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mTime.tv_nsec));
2602 return aidl;
2603 }
2604
2605 ConversionResult<audio_uuid_t>
aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid & aidl)2606 aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
2607 audio_uuid_t legacy;
2608 legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
2609 legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
2610 legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
2611 legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
2612 if (aidl.node.size() != std::size(legacy.node)) {
2613 return unexpected(BAD_VALUE);
2614 }
2615 std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
2616 return legacy;
2617 }
2618
2619 ConversionResult<AudioUuid>
legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t & legacy)2620 legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
2621 AudioUuid aidl;
2622 aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
2623 aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
2624 aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
2625 aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
2626 std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
2627 return aidl;
2628 }
2629
2630 ConversionResult<effect_descriptor_t>
aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor & aidl)2631 aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor& aidl) {
2632 effect_descriptor_t legacy;
2633 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.type));
2634 legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.uuid));
2635 legacy.apiVersion = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.apiVersion));
2636 legacy.flags = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.flags));
2637 legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.cpuLoad));
2638 legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.memoryUsage));
2639 RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));
2640 RETURN_IF_ERROR(
2641 aidl2legacy_string(aidl.implementor, legacy.implementor, sizeof(legacy.implementor)));
2642 return legacy;
2643 }
2644
2645 ConversionResult<media::EffectDescriptor>
legacy2aidl_effect_descriptor_t_EffectDescriptor(const effect_descriptor_t & legacy)2646 legacy2aidl_effect_descriptor_t_EffectDescriptor(const effect_descriptor_t& legacy) {
2647 media::EffectDescriptor aidl;
2648 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));
2649 aidl.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));
2650 aidl.apiVersion = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.apiVersion));
2651 aidl.flags = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.flags));
2652 aidl.cpuLoad = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.cpuLoad));
2653 aidl.memoryUsage = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.memoryUsage));
2654 aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
2655 aidl.implementor = VALUE_OR_RETURN(
2656 legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));
2657 return aidl;
2658 }
2659
2660 ConversionResult<audio_encapsulation_metadata_type_t>
aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(AudioEncapsulationMetadataType aidl)2661 aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
2662 AudioEncapsulationMetadataType aidl) {
2663 switch (aidl) {
2664 case AudioEncapsulationMetadataType::NONE:
2665 return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
2666 case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
2667 return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
2668 case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
2669 return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
2670 }
2671 return unexpected(BAD_VALUE);
2672 }
2673
2674 ConversionResult<AudioEncapsulationMetadataType>
legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(audio_encapsulation_metadata_type_t legacy)2675 legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
2676 audio_encapsulation_metadata_type_t legacy) {
2677 switch (legacy) {
2678 case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
2679 return AudioEncapsulationMetadataType::NONE;
2680 case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
2681 return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
2682 case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
2683 return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
2684 }
2685 return unexpected(BAD_VALUE);
2686 }
2687
2688 ConversionResult<uint32_t>
aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl)2689 aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
2690 return convertBitmask<uint32_t,
2691 int32_t,
2692 audio_encapsulation_mode_t,
2693 AudioEncapsulationMode>(
2694 aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
2695 indexToEnum_index<AudioEncapsulationMode>,
2696 enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
2697 }
2698
2699 ConversionResult<int32_t>
legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy)2700 legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
2701 return convertBitmask<int32_t,
2702 uint32_t,
2703 AudioEncapsulationMode,
2704 audio_encapsulation_mode_t>(
2705 legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
2706 indexToEnum_index<audio_encapsulation_mode_t>,
2707 enumToMask_index<int32_t, AudioEncapsulationMode>);
2708 }
2709
2710 ConversionResult<uint32_t>
aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl)2711 aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
2712 return convertBitmask<uint32_t,
2713 int32_t,
2714 audio_encapsulation_metadata_type_t,
2715 AudioEncapsulationMetadataType>(
2716 aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
2717 indexToEnum_index<AudioEncapsulationMetadataType>,
2718 enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
2719 }
2720
2721 ConversionResult<int32_t>
legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy)2722 legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
2723 return convertBitmask<int32_t,
2724 uint32_t,
2725 AudioEncapsulationMetadataType,
2726 audio_encapsulation_metadata_type_t>(
2727 legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
2728 indexToEnum_index<audio_encapsulation_metadata_type_t>,
2729 enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
2730 }
2731
2732 ConversionResult<audio_port_device_ext>
aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(const AudioPortDeviceExt & aidl,const media::AudioPortDeviceExtSys & aidlSys)2733 aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
2734 const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlSys) {
2735 audio_port_device_ext legacy;
2736 legacy.hw_module = VALUE_OR_RETURN(
2737 aidl2legacy_int32_t_audio_module_handle_t(aidlSys.hwModule));
2738 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2739 aidl.device, &legacy.type, legacy.address));
2740 legacy.encapsulation_modes = VALUE_OR_RETURN(
2741 aidl2legacy_AudioEncapsulationMode_mask(aidlSys.encapsulationModes));
2742 legacy.encapsulation_metadata_types = VALUE_OR_RETURN(
2743 aidl2legacy_AudioEncapsulationMetadataType_mask(
2744 aidlSys.encapsulationMetadataTypes));
2745 return legacy;
2746 }
2747
legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(const audio_port_device_ext & legacy,AudioPortDeviceExt * aidl,media::AudioPortDeviceExtSys * aidlDeviceExt)2748 status_t legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(
2749 const audio_port_device_ext& legacy,
2750 AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {
2751 aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(
2752 legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
2753 aidl->device = VALUE_OR_RETURN_STATUS(
2754 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
2755 aidlDeviceExt->encapsulationModes = VALUE_OR_RETURN_STATUS(
2756 legacy2aidl_AudioEncapsulationMode_mask(legacy.encapsulation_modes));
2757 aidlDeviceExt->encapsulationMetadataTypes = VALUE_OR_RETURN_STATUS(
2758 legacy2aidl_AudioEncapsulationMetadataType_mask(legacy.encapsulation_metadata_types));
2759 return OK;
2760 }
2761
2762 ConversionResult<audio_port_mix_ext>
aidl2legacy_AudioPortMixExt_audio_port_mix_ext(const AudioPortMixExt & aidl,const media::AudioPortMixExtSys & aidlSys)2763 aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2764 const AudioPortMixExt& aidl, const media::AudioPortMixExtSys& aidlSys) {
2765 audio_port_mix_ext legacy{};
2766 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidlSys.hwModule));
2767 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
2768 return legacy;
2769 }
2770
2771 status_t
legacy2aidl_audio_port_mix_ext_AudioPortMixExt(const audio_port_mix_ext & legacy,AudioPortMixExt * aidl,media::AudioPortMixExtSys * aidlMixExt)2772 legacy2aidl_audio_port_mix_ext_AudioPortMixExt(const audio_port_mix_ext& legacy,
2773 AudioPortMixExt* aidl, media::AudioPortMixExtSys* aidlMixExt) {
2774 aidlMixExt->hwModule = VALUE_OR_RETURN_STATUS(
2775 legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
2776 aidl->handle = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
2777 return OK;
2778 }
2779
2780 ConversionResult<audio_port_session_ext>
aidl2legacy_int32_t_audio_port_session_ext(int32_t aidl)2781 aidl2legacy_int32_t_audio_port_session_ext(int32_t aidl) {
2782 audio_port_session_ext legacy;
2783 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl));
2784 return legacy;
2785 }
2786
2787 ConversionResult<int32_t>
legacy2aidl_audio_port_session_ext_int32_t(const audio_port_session_ext & legacy)2788 legacy2aidl_audio_port_session_ext_int32_t(const audio_port_session_ext& legacy) {
2789 return legacy2aidl_audio_session_t_int32_t(legacy.session);
2790 }
2791
2792 // This type is unnamed in the original definition, thus we name it here.
2793 using audio_port_v7_ext = decltype(audio_port_v7::ext);
2794
aidl2legacy_AudioPortExt_audio_port_v7_ext(const AudioPortExt & aidl,media::AudioPortType type,const media::AudioPortExtSys & aidlSys)2795 ConversionResult<audio_port_v7_ext> aidl2legacy_AudioPortExt_audio_port_v7_ext(
2796 const AudioPortExt& aidl, media::AudioPortType type,
2797 const media::AudioPortExtSys& aidlSys) {
2798 audio_port_v7_ext legacy;
2799 switch (type) {
2800 case media::AudioPortType::NONE:
2801 // Just verify that the union is empty.
2802 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
2803 return legacy;
2804 case media::AudioPortType::DEVICE:
2805 legacy.device = VALUE_OR_RETURN(
2806 aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
2807 VALUE_OR_RETURN(UNION_GET(aidl, device)),
2808 VALUE_OR_RETURN(UNION_GET(aidlSys, device))));
2809 return legacy;
2810 case media::AudioPortType::MIX:
2811 legacy.mix = VALUE_OR_RETURN(
2812 aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2813 VALUE_OR_RETURN(UNION_GET(aidl, mix)),
2814 VALUE_OR_RETURN(UNION_GET(aidlSys, mix))));
2815 return legacy;
2816 case media::AudioPortType::SESSION:
2817 legacy.session = VALUE_OR_RETURN(
2818 aidl2legacy_int32_t_audio_port_session_ext(
2819 VALUE_OR_RETURN(UNION_GET(aidl, session))));
2820 return legacy;
2821
2822 }
2823 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2824 }
2825
legacy2aidl_AudioPortExt(const audio_port_v7_ext & legacy,audio_port_type_t type,AudioPortExt * aidl,media::AudioPortExtSys * aidlSys)2826 status_t legacy2aidl_AudioPortExt(
2827 const audio_port_v7_ext& legacy, audio_port_type_t type,
2828 AudioPortExt* aidl, media::AudioPortExtSys* aidlSys) {
2829 switch (type) {
2830 case AUDIO_PORT_TYPE_NONE:
2831 UNION_SET(*aidl, unspecified, false);
2832 UNION_SET(*aidlSys, unspecified, false);
2833 return OK;
2834 case AUDIO_PORT_TYPE_DEVICE: {
2835 AudioPortDeviceExt device;
2836 media::AudioPortDeviceExtSys deviceSys;
2837 RETURN_STATUS_IF_ERROR(
2838 legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(
2839 legacy.device, &device, &deviceSys));
2840 UNION_SET(*aidl, device, device);
2841 UNION_SET(*aidlSys, device, deviceSys);
2842 return OK;
2843 }
2844 case AUDIO_PORT_TYPE_MIX: {
2845 AudioPortMixExt mix;
2846 media::AudioPortMixExtSys mixSys;
2847 RETURN_STATUS_IF_ERROR(
2848 legacy2aidl_audio_port_mix_ext_AudioPortMixExt(
2849 legacy.mix, &mix, &mixSys));
2850 UNION_SET(*aidl, mix, mix);
2851 UNION_SET(*aidlSys, mix, mixSys);
2852 return OK;
2853 }
2854 case AUDIO_PORT_TYPE_SESSION:
2855 UNION_SET(*aidl, session, VALUE_OR_RETURN_STATUS(
2856 legacy2aidl_audio_port_session_ext_int32_t(legacy.session)));
2857 UNION_SET(*aidlSys, unspecified, false);
2858 return OK;
2859 }
2860 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2861 }
2862
2863 ConversionResult<audio_profile>
aidl2legacy_AudioProfile_audio_profile(const AudioProfile & aidl,bool isInput)2864 aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
2865 audio_profile legacy;
2866 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
2867
2868 if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
2869 return unexpected(BAD_VALUE);
2870 }
2871 RETURN_IF_ERROR(
2872 convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
2873 convertIntegral<int32_t, unsigned int>));
2874 legacy.num_sample_rates = aidl.sampleRates.size();
2875
2876 if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
2877 return unexpected(BAD_VALUE);
2878 }
2879 RETURN_IF_ERROR(
2880 convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
2881 [isInput](const AudioChannelLayout& l) {
2882 return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
2883 }));
2884 legacy.num_channel_masks = aidl.channelMasks.size();
2885
2886 legacy.encapsulation_type = VALUE_OR_RETURN(
2887 aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
2888 return legacy;
2889 }
2890
2891 ConversionResult<AudioProfile>
legacy2aidl_audio_profile_AudioProfile(const audio_profile & legacy,bool isInput)2892 legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
2893 AudioProfile aidl;
2894 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2895
2896 if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
2897 return unexpected(BAD_VALUE);
2898 }
2899 RETURN_IF_ERROR(
2900 convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
2901 std::back_inserter(aidl.sampleRates),
2902 convertIntegral<unsigned int, int32_t>));
2903
2904 if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
2905 return unexpected(BAD_VALUE);
2906 }
2907 RETURN_IF_ERROR(
2908 convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
2909 std::back_inserter(aidl.channelMasks),
2910 [isInput](audio_channel_mask_t m) {
2911 return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
2912 }));
2913
2914 aidl.encapsulationType = VALUE_OR_RETURN(
2915 legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2916 legacy.encapsulation_type));
2917 return aidl;
2918 }
2919
2920 ConversionResult<audio_gain>
aidl2legacy_AudioGain_audio_gain(const AudioGain & aidl,bool isInput)2921 aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
2922 audio_gain legacy;
2923 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
2924 legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
2925 aidl.channelMask, isInput));
2926 legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
2927 legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
2928 legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
2929 legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
2930 legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
2931 legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
2932 return legacy;
2933 }
2934
2935 ConversionResult<AudioGain>
legacy2aidl_audio_gain_AudioGain(const audio_gain & legacy,bool isInput)2936 legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
2937 AudioGain aidl;
2938 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
2939 aidl.channelMask = VALUE_OR_RETURN(
2940 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2941 aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
2942 aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
2943 aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
2944 aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
2945 aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
2946 aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
2947 return aidl;
2948 }
2949
2950 ConversionResult<audio_port_v7>
aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort & aidl)2951 aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) {
2952 audio_port_v7 legacy;
2953 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.hal.id));
2954 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.sys.role));
2955 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.sys.type));
2956 RETURN_IF_ERROR(aidl2legacy_string(aidl.hal.name, legacy.name, sizeof(legacy.name)));
2957
2958 if (aidl.hal.profiles.size() > std::size(legacy.audio_profiles)) {
2959 return unexpected(BAD_VALUE);
2960 }
2961 const bool isInput =
2962 VALUE_OR_RETURN(direction(aidl.sys.role, aidl.sys.type)) == Direction::INPUT;
2963 RETURN_IF_ERROR(convertRange(
2964 aidl.hal.profiles.begin(), aidl.hal.profiles.end(), legacy.audio_profiles,
2965 [isInput](const AudioProfile& p) {
2966 return aidl2legacy_AudioProfile_audio_profile(p, isInput);
2967 }));
2968 legacy.num_audio_profiles = aidl.hal.profiles.size();
2969
2970 if (aidl.hal.extraAudioDescriptors.size() > std::size(legacy.extra_audio_descriptors)) {
2971 return unexpected(BAD_VALUE);
2972 }
2973 RETURN_IF_ERROR(
2974 convertRange(
2975 aidl.hal.extraAudioDescriptors.begin(), aidl.hal.extraAudioDescriptors.end(),
2976 legacy.extra_audio_descriptors,
2977 aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor));
2978 legacy.num_extra_audio_descriptors = aidl.hal.extraAudioDescriptors.size();
2979
2980 if (aidl.hal.gains.size() > std::size(legacy.gains)) {
2981 return unexpected(BAD_VALUE);
2982 }
2983 RETURN_IF_ERROR(convertRange(aidl.hal.gains.begin(), aidl.hal.gains.end(), legacy.gains,
2984 [isInput](const AudioGain& g) {
2985 return aidl2legacy_AudioGain_audio_gain(g, isInput);
2986 }));
2987 legacy.num_gains = aidl.hal.gains.size();
2988
2989 legacy.active_config = VALUE_OR_RETURN(
2990 aidl2legacy_AudioPortConfig_audio_port_config(aidl.sys.activeConfig));
2991 legacy.ext = VALUE_OR_RETURN(
2992 aidl2legacy_AudioPortExt_audio_port_v7_ext(aidl.hal.ext, aidl.sys.type, aidl.sys.ext));
2993 return legacy;
2994 }
2995
2996 ConversionResult<media::AudioPort>
legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7 & legacy)2997 legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) {
2998 media::AudioPort aidl;
2999 aidl.hal.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
3000 aidl.sys.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
3001 aidl.sys.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
3002 aidl.hal.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
3003
3004 if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {
3005 return unexpected(BAD_VALUE);
3006 }
3007 const bool isInput = VALUE_OR_RETURN(direction(legacy.role, legacy.type)) == Direction::INPUT;
3008 RETURN_IF_ERROR(
3009 convertRange(legacy.audio_profiles, legacy.audio_profiles + legacy.num_audio_profiles,
3010 std::back_inserter(aidl.hal.profiles),
3011 [isInput](const audio_profile& p) {
3012 return legacy2aidl_audio_profile_AudioProfile(p, isInput);
3013 }));
3014
3015 if (legacy.num_extra_audio_descriptors > std::size(legacy.extra_audio_descriptors)) {
3016 return unexpected(BAD_VALUE);
3017 }
3018 aidl.sys.profiles.resize(legacy.num_audio_profiles);
3019 RETURN_IF_ERROR(
3020 convertRange(legacy.extra_audio_descriptors,
3021 legacy.extra_audio_descriptors + legacy.num_extra_audio_descriptors,
3022 std::back_inserter(aidl.hal.extraAudioDescriptors),
3023 legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor));
3024
3025 if (legacy.num_gains > std::size(legacy.gains)) {
3026 return unexpected(BAD_VALUE);
3027 }
3028 RETURN_IF_ERROR(
3029 convertRange(legacy.gains, legacy.gains + legacy.num_gains,
3030 std::back_inserter(aidl.hal.gains),
3031 [isInput](const audio_gain& g) {
3032 return legacy2aidl_audio_gain_AudioGain(g, isInput);
3033 }));
3034 aidl.sys.gains.resize(legacy.num_gains);
3035
3036 aidl.sys.activeConfig = VALUE_OR_RETURN(
3037 legacy2aidl_audio_port_config_AudioPortConfig(legacy.active_config));
3038 aidl.sys.activeConfig.hal.portId = aidl.hal.id;
3039 RETURN_IF_ERROR(
3040 legacy2aidl_AudioPortExt(legacy.ext, legacy.type, &aidl.hal.ext, &aidl.sys.ext));
3041 return aidl;
3042 }
3043
3044 ConversionResult<audio_mode_t>
aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl)3045 aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
3046 switch (aidl) {
3047 case AudioMode::SYS_RESERVED_INVALID:
3048 return AUDIO_MODE_INVALID;
3049 case AudioMode::SYS_RESERVED_CURRENT:
3050 return AUDIO_MODE_CURRENT;
3051 case AudioMode::NORMAL:
3052 return AUDIO_MODE_NORMAL;
3053 case AudioMode::RINGTONE:
3054 return AUDIO_MODE_RINGTONE;
3055 case AudioMode::IN_CALL:
3056 return AUDIO_MODE_IN_CALL;
3057 case AudioMode::IN_COMMUNICATION:
3058 return AUDIO_MODE_IN_COMMUNICATION;
3059 case AudioMode::CALL_SCREEN:
3060 return AUDIO_MODE_CALL_SCREEN;
3061 case AudioMode::SYS_RESERVED_CALL_REDIRECT:
3062 return AUDIO_MODE_CALL_REDIRECT;
3063 case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
3064 return AUDIO_MODE_COMMUNICATION_REDIRECT;
3065 }
3066 return unexpected(BAD_VALUE);
3067 }
3068
3069 ConversionResult<AudioMode>
legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy)3070 legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
3071 switch (legacy) {
3072 case AUDIO_MODE_INVALID:
3073 return AudioMode::SYS_RESERVED_INVALID;
3074 case AUDIO_MODE_CURRENT:
3075 return AudioMode::SYS_RESERVED_CURRENT;
3076 case AUDIO_MODE_NORMAL:
3077 return AudioMode::NORMAL;
3078 case AUDIO_MODE_RINGTONE:
3079 return AudioMode::RINGTONE;
3080 case AUDIO_MODE_IN_CALL:
3081 return AudioMode::IN_CALL;
3082 case AUDIO_MODE_IN_COMMUNICATION:
3083 return AudioMode::IN_COMMUNICATION;
3084 case AUDIO_MODE_CALL_SCREEN:
3085 return AudioMode::CALL_SCREEN;
3086 case AUDIO_MODE_CALL_REDIRECT:
3087 return AudioMode::SYS_RESERVED_CALL_REDIRECT;
3088 case AUDIO_MODE_COMMUNICATION_REDIRECT:
3089 return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
3090 case AUDIO_MODE_CNT:
3091 break;
3092 }
3093 return unexpected(BAD_VALUE);
3094 }
3095
3096 ConversionResult<audio_unique_id_use_t>
aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(media::AudioUniqueIdUse aidl)3097 aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(media::AudioUniqueIdUse aidl) {
3098 switch (aidl) {
3099 case media::AudioUniqueIdUse::UNSPECIFIED:
3100 return AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
3101 case media::AudioUniqueIdUse::SESSION:
3102 return AUDIO_UNIQUE_ID_USE_SESSION;
3103 case media::AudioUniqueIdUse::MODULE:
3104 return AUDIO_UNIQUE_ID_USE_MODULE;
3105 case media::AudioUniqueIdUse::EFFECT:
3106 return AUDIO_UNIQUE_ID_USE_EFFECT;
3107 case media::AudioUniqueIdUse::PATCH:
3108 return AUDIO_UNIQUE_ID_USE_PATCH;
3109 case media::AudioUniqueIdUse::OUTPUT:
3110 return AUDIO_UNIQUE_ID_USE_OUTPUT;
3111 case media::AudioUniqueIdUse::INPUT:
3112 return AUDIO_UNIQUE_ID_USE_INPUT;
3113 case media::AudioUniqueIdUse::CLIENT:
3114 return AUDIO_UNIQUE_ID_USE_CLIENT;
3115 }
3116 return unexpected(BAD_VALUE);
3117 }
3118
3119 ConversionResult<media::AudioUniqueIdUse>
legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(audio_unique_id_use_t legacy)3120 legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(audio_unique_id_use_t legacy) {
3121 switch (legacy) {
3122 case AUDIO_UNIQUE_ID_USE_UNSPECIFIED:
3123 return media::AudioUniqueIdUse::UNSPECIFIED;
3124 case AUDIO_UNIQUE_ID_USE_SESSION:
3125 return media::AudioUniqueIdUse::SESSION;
3126 case AUDIO_UNIQUE_ID_USE_MODULE:
3127 return media::AudioUniqueIdUse::MODULE;
3128 case AUDIO_UNIQUE_ID_USE_EFFECT:
3129 return media::AudioUniqueIdUse::EFFECT;
3130 case AUDIO_UNIQUE_ID_USE_PATCH:
3131 return media::AudioUniqueIdUse::PATCH;
3132 case AUDIO_UNIQUE_ID_USE_OUTPUT:
3133 return media::AudioUniqueIdUse::OUTPUT;
3134 case AUDIO_UNIQUE_ID_USE_INPUT:
3135 return media::AudioUniqueIdUse::INPUT;
3136 case AUDIO_UNIQUE_ID_USE_CLIENT:
3137 return media::AudioUniqueIdUse::CLIENT;
3138 case AUDIO_UNIQUE_ID_USE_MAX:
3139 break;
3140 }
3141 return unexpected(BAD_VALUE);
3142 }
3143
3144 ConversionResult<volume_group_t>
aidl2legacy_int32_t_volume_group_t(int32_t aidl)3145 aidl2legacy_int32_t_volume_group_t(int32_t aidl) {
3146 return convertReinterpret<volume_group_t>(aidl);
3147 }
3148
3149 ConversionResult<int32_t>
legacy2aidl_volume_group_t_int32_t(volume_group_t legacy)3150 legacy2aidl_volume_group_t_int32_t(volume_group_t legacy) {
3151 return convertReinterpret<int32_t>(legacy);
3152 }
3153
3154 ConversionResult<product_strategy_t>
aidl2legacy_int32_t_product_strategy_t(int32_t aidl)3155 aidl2legacy_int32_t_product_strategy_t(int32_t aidl) {
3156 return convertReinterpret<product_strategy_t>(aidl);
3157 }
3158
3159 ConversionResult<int32_t>
legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy)3160 legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy) {
3161 return convertReinterpret<int32_t>(legacy);
3162 }
3163
3164 ConversionResult<audio_dual_mono_mode_t>
aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(media::AudioDualMonoMode aidl)3165 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(media::AudioDualMonoMode aidl) {
3166 switch (aidl) {
3167 case media::AudioDualMonoMode::OFF:
3168 return AUDIO_DUAL_MONO_MODE_OFF;
3169 case media::AudioDualMonoMode::LR:
3170 return AUDIO_DUAL_MONO_MODE_LR;
3171 case media::AudioDualMonoMode::LL:
3172 return AUDIO_DUAL_MONO_MODE_LL;
3173 case media::AudioDualMonoMode::RR:
3174 return AUDIO_DUAL_MONO_MODE_RR;
3175 }
3176 return unexpected(BAD_VALUE);
3177 }
3178
3179 ConversionResult<media::AudioDualMonoMode>
legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(audio_dual_mono_mode_t legacy)3180 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(audio_dual_mono_mode_t legacy) {
3181 switch (legacy) {
3182 case AUDIO_DUAL_MONO_MODE_OFF:
3183 return media::AudioDualMonoMode::OFF;
3184 case AUDIO_DUAL_MONO_MODE_LR:
3185 return media::AudioDualMonoMode::LR;
3186 case AUDIO_DUAL_MONO_MODE_LL:
3187 return media::AudioDualMonoMode::LL;
3188 case AUDIO_DUAL_MONO_MODE_RR:
3189 return media::AudioDualMonoMode::RR;
3190 }
3191 return unexpected(BAD_VALUE);
3192 }
3193
3194 ConversionResult<audio_timestretch_fallback_mode_t>
aidl2legacy_int32_t_audio_timestretch_fallback_mode_t(int32_t aidl)3195 aidl2legacy_int32_t_audio_timestretch_fallback_mode_t(int32_t aidl) {
3196 return convertReinterpret<audio_timestretch_fallback_mode_t>(aidl);
3197 }
3198
3199 ConversionResult<int32_t>
legacy2aidl_audio_timestretch_fallback_mode_t_int32_t(audio_timestretch_fallback_mode_t legacy)3200 legacy2aidl_audio_timestretch_fallback_mode_t_int32_t(audio_timestretch_fallback_mode_t legacy) {
3201 return convertReinterpret<int32_t>(legacy);
3202 }
3203
3204 ConversionResult<audio_timestretch_stretch_mode_t>
aidl2legacy_int32_t_audio_timestretch_stretch_mode_t(int32_t aidl)3205 aidl2legacy_int32_t_audio_timestretch_stretch_mode_t(int32_t aidl) {
3206 return convertReinterpret<audio_timestretch_stretch_mode_t>(aidl);
3207 }
3208
3209 ConversionResult<int32_t>
legacy2aidl_audio_timestretch_stretch_mode_t_int32_t(audio_timestretch_stretch_mode_t legacy)3210 legacy2aidl_audio_timestretch_stretch_mode_t_int32_t(audio_timestretch_stretch_mode_t legacy) {
3211 return convertReinterpret<int32_t>(legacy);
3212 }
3213
3214 ConversionResult<audio_playback_rate_t>
aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(const media::AudioPlaybackRate & aidl)3215 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(const media::AudioPlaybackRate& aidl) {
3216 audio_playback_rate_t legacy;
3217 legacy.mSpeed = aidl.speed;
3218 legacy.mPitch = aidl.pitch;
3219 legacy.mFallbackMode = VALUE_OR_RETURN(
3220 aidl2legacy_int32_t_audio_timestretch_fallback_mode_t(aidl.fallbackMode));
3221 legacy.mStretchMode = VALUE_OR_RETURN(
3222 aidl2legacy_int32_t_audio_timestretch_stretch_mode_t(aidl.stretchMode));
3223 return legacy;
3224 }
3225
3226 ConversionResult<media::AudioPlaybackRate>
legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(const audio_playback_rate_t & legacy)3227 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(const audio_playback_rate_t& legacy) {
3228 media::AudioPlaybackRate aidl;
3229 aidl.speed = legacy.mSpeed;
3230 aidl.pitch = legacy.mPitch;
3231 aidl.fallbackMode = VALUE_OR_RETURN(
3232 legacy2aidl_audio_timestretch_fallback_mode_t_int32_t(legacy.mFallbackMode));
3233 aidl.stretchMode = VALUE_OR_RETURN(
3234 legacy2aidl_audio_timestretch_stretch_mode_t_int32_t(legacy.mStretchMode));
3235 return aidl;
3236 }
3237
3238 ConversionResult<audio_standard_t>
aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl)3239 aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
3240 switch (aidl) {
3241 case AudioStandard::NONE:
3242 return AUDIO_STANDARD_NONE;
3243 case AudioStandard::EDID:
3244 return AUDIO_STANDARD_EDID;
3245 }
3246 return unexpected(BAD_VALUE);
3247 }
3248
3249 ConversionResult<AudioStandard>
legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy)3250 legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
3251 switch (legacy) {
3252 case AUDIO_STANDARD_NONE:
3253 return AudioStandard::NONE;
3254 case AUDIO_STANDARD_EDID:
3255 return AudioStandard::EDID;
3256 }
3257 return unexpected(BAD_VALUE);
3258 }
3259
3260 ConversionResult<audio_extra_audio_descriptor>
aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(const ExtraAudioDescriptor & aidl)3261 aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
3262 const ExtraAudioDescriptor& aidl) {
3263 audio_extra_audio_descriptor legacy;
3264 legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
3265 if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
3266 return unexpected(BAD_VALUE);
3267 }
3268 legacy.descriptor_length = aidl.audioDescriptor.size();
3269 std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
3270 std::begin(legacy.descriptor));
3271 legacy.encapsulation_type =
3272 VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
3273 aidl.encapsulationType));
3274 return legacy;
3275 }
3276
3277 ConversionResult<ExtraAudioDescriptor>
legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(const audio_extra_audio_descriptor & legacy)3278 legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
3279 const audio_extra_audio_descriptor& legacy) {
3280 ExtraAudioDescriptor aidl;
3281 aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
3282 if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
3283 return unexpected(BAD_VALUE);
3284 }
3285 aidl.audioDescriptor.resize(legacy.descriptor_length);
3286 std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
3287 aidl.audioDescriptor.begin());
3288 aidl.encapsulationType =
3289 VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
3290 legacy.encapsulation_type));
3291 return aidl;
3292 }
3293
3294 ConversionResult<audio_encapsulation_type_t>
aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(const AudioEncapsulationType & aidl)3295 aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
3296 const AudioEncapsulationType& aidl) {
3297 switch (aidl) {
3298 case AudioEncapsulationType::NONE:
3299 return AUDIO_ENCAPSULATION_TYPE_NONE;
3300 case AudioEncapsulationType::IEC61937:
3301 return AUDIO_ENCAPSULATION_TYPE_IEC61937;
3302 }
3303 return unexpected(BAD_VALUE);
3304 }
3305
3306 ConversionResult<AudioEncapsulationType>
legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(const audio_encapsulation_type_t & legacy)3307 legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
3308 const audio_encapsulation_type_t & legacy) {
3309 switch (legacy) {
3310 case AUDIO_ENCAPSULATION_TYPE_NONE:
3311 return AudioEncapsulationType::NONE;
3312 case AUDIO_ENCAPSULATION_TYPE_IEC61937:
3313 return AudioEncapsulationType::IEC61937;
3314 }
3315 return unexpected(BAD_VALUE);
3316 }
3317
3318 ConversionResult<TrackSecondaryOutputInfoPair>
aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair(const media::TrackSecondaryOutputInfo & aidl)3319 aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair(
3320 const media::TrackSecondaryOutputInfo& aidl) {
3321 TrackSecondaryOutputInfoPair trackSecondaryOutputInfoPair;
3322 trackSecondaryOutputInfoPair.first =
3323 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
3324 trackSecondaryOutputInfoPair.second =
3325 VALUE_OR_RETURN(convertContainer<std::vector<audio_port_handle_t>>(
3326 aidl.secondaryOutputIds, aidl2legacy_int32_t_audio_io_handle_t));
3327 return trackSecondaryOutputInfoPair;
3328 }
3329
3330 ConversionResult<media::TrackSecondaryOutputInfo>
legacy2aidl_TrackSecondaryOutputInfoPair_TrackSecondaryOutputInfo(const TrackSecondaryOutputInfoPair & legacy)3331 legacy2aidl_TrackSecondaryOutputInfoPair_TrackSecondaryOutputInfo(
3332 const TrackSecondaryOutputInfoPair& legacy) {
3333 media::TrackSecondaryOutputInfo trackSecondaryOutputInfo;
3334 trackSecondaryOutputInfo.portId =
3335 VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.first));
3336 trackSecondaryOutputInfo.secondaryOutputIds =
3337 VALUE_OR_RETURN(convertContainer<std::vector<int32_t>>(
3338 legacy.second, legacy2aidl_audio_io_handle_t_int32_t));
3339 return trackSecondaryOutputInfo;
3340 }
3341
3342 ConversionResult<audio_direct_mode_t>
aidl2legacy_AudioDirectMode_audio_direct_mode_t(media::AudioDirectMode aidl)3343 aidl2legacy_AudioDirectMode_audio_direct_mode_t(media::AudioDirectMode aidl) {
3344 switch (aidl) {
3345 case media::AudioDirectMode::NONE:
3346 return AUDIO_DIRECT_NOT_SUPPORTED;
3347 case media::AudioDirectMode::OFFLOAD:
3348 return AUDIO_DIRECT_OFFLOAD_SUPPORTED;
3349 case media::AudioDirectMode::OFFLOAD_GAPLESS:
3350 return AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED;
3351 case media::AudioDirectMode::BITSTREAM:
3352 return AUDIO_DIRECT_BITSTREAM_SUPPORTED;
3353 }
3354 return unexpected(BAD_VALUE);
3355 }
3356 ConversionResult<media::AudioDirectMode>
legacy2aidl_audio_direct_mode_t_AudioDirectMode(audio_direct_mode_t legacy)3357 legacy2aidl_audio_direct_mode_t_AudioDirectMode(audio_direct_mode_t legacy) {
3358 switch (legacy) {
3359 case AUDIO_DIRECT_NOT_SUPPORTED:
3360 return media::AudioDirectMode::NONE;
3361 case AUDIO_DIRECT_OFFLOAD_SUPPORTED:
3362 return media::AudioDirectMode::OFFLOAD;
3363 case AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED:
3364 return media::AudioDirectMode::OFFLOAD_GAPLESS;
3365 case AUDIO_DIRECT_BITSTREAM_SUPPORTED:
3366 return media::AudioDirectMode::BITSTREAM;
3367 }
3368 return unexpected(BAD_VALUE);
3369 }
3370
aidl2legacy_int32_t_audio_direct_mode_t_mask(int32_t aidl)3371 ConversionResult<audio_direct_mode_t> aidl2legacy_int32_t_audio_direct_mode_t_mask(int32_t aidl) {
3372 using LegacyMask = std::underlying_type_t<audio_direct_mode_t>;
3373
3374 LegacyMask converted = VALUE_OR_RETURN(
3375 (convertBitmask<LegacyMask, int32_t, audio_direct_mode_t, media::AudioDirectMode>(
3376 aidl, aidl2legacy_AudioDirectMode_audio_direct_mode_t,
3377 indexToEnum_index<media::AudioDirectMode>,
3378 enumToMask_bitmask<LegacyMask, audio_direct_mode_t>)));
3379 return static_cast<audio_direct_mode_t>(converted);
3380 }
legacy2aidl_audio_direct_mode_t_int32_t_mask(audio_direct_mode_t legacy)3381 ConversionResult<int32_t> legacy2aidl_audio_direct_mode_t_int32_t_mask(audio_direct_mode_t legacy) {
3382 using LegacyMask = std::underlying_type_t<audio_direct_mode_t>;
3383
3384 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
3385 return convertBitmask<int32_t, LegacyMask, media::AudioDirectMode, audio_direct_mode_t>(
3386 legacyMask, legacy2aidl_audio_direct_mode_t_AudioDirectMode,
3387 indexToEnum_bitmask<audio_direct_mode_t>,
3388 enumToMask_index<int32_t, media::AudioDirectMode>);
3389 }
3390
3391 ConversionResult<audio_latency_mode_t>
aidl2legacy_LatencyMode_audio_latency_mode_t(media::LatencyMode aidl)3392 aidl2legacy_LatencyMode_audio_latency_mode_t(media::LatencyMode aidl) {
3393 switch (aidl) {
3394 case media::LatencyMode::FREE:
3395 return AUDIO_LATENCY_MODE_FREE;
3396 case media::LatencyMode::LOW:
3397 return AUDIO_LATENCY_MODE_LOW;
3398 }
3399 return unexpected(BAD_VALUE);
3400 }
3401 ConversionResult<media::LatencyMode>
legacy2aidl_audio_latency_mode_t_LatencyMode(audio_latency_mode_t legacy)3402 legacy2aidl_audio_latency_mode_t_LatencyMode(audio_latency_mode_t legacy) {
3403 switch (legacy) {
3404 case AUDIO_LATENCY_MODE_FREE:
3405 return media::LatencyMode::FREE;
3406 case AUDIO_LATENCY_MODE_LOW:
3407 return media::LatencyMode::LOW;
3408 }
3409 return unexpected(BAD_VALUE);
3410 }
3411 } // namespace android
3412