Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_av / 0f0a8037dd806322e3efbe2d931bdb93b5927898 / . / media / audioaidlconversion / AidlConversionCppNdk.cpp
blob: 7580724f9f59aeebc0630c3c5c05eeeea31f1afe [file] [log] [blame]
Shunkai Yao1b5fbab2022-12-14 04:27:19 +0000[diff] [blame]1/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <algorithm>
18#include <map>
19#include <utility>
20#include <vector>
21
22#define LOG_TAG "AidlConversionCppNdk"
23//#define LOG_NDEBUG 0
24#include <utils/Log.h>
25
26#include "media/AidlConversionCppNdk.h"
27
28#include <media/ShmemCompat.h>
29#include <media/stagefright/foundation/MediaDefs.h>
30
31////////////////////////////////////////////////////////////////////////////////////////////////////
32// Utilities
33
34#if defined(BACKEND_NDK)
35/* AIDL String generated in NDK is different than CPP */
36#define GET_DEVICE_DESC_CONNECTION(x) AudioDeviceDescription::CONNECTION_##x
37namespace aidl {
38#else
39#define GET_DEVICE_DESC_CONNECTION(x) AudioDeviceDescription::CONNECTION_##x()
40#endif
41
42namespace android {
43
44using ::android::BAD_VALUE;
45using ::android::OK;
46using ::android::base::unexpected;
47
48using media::audio::common::AudioChannelLayout;
49using media::audio::common::AudioConfig;
50using media::audio::common::AudioConfigBase;
51using media::audio::common::AudioContentType;
52using media::audio::common::AudioDevice;
53using media::audio::common::AudioDeviceAddress;
54using media::audio::common::AudioDeviceDescription;
55using media::audio::common::AudioDeviceType;
56using media::audio::common::AudioEncapsulationMetadataType;
57using media::audio::common::AudioEncapsulationMode;
58using media::audio::common::AudioEncapsulationType;
59using media::audio::common::AudioFormatDescription;
60using media::audio::common::AudioFormatType;
61using media::audio::common::AudioGain;
62using media::audio::common::AudioGainConfig;
63using media::audio::common::AudioGainMode;
64using media::audio::common::AudioInputFlags;
65using media::audio::common::AudioIoFlags;
66using media::audio::common::AudioMode;
67using media::audio::common::AudioOffloadInfo;
68using media::audio::common::AudioOutputFlags;
69using media::audio::common::AudioPortDeviceExt;
70using media::audio::common::AudioPortExt;
71using media::audio::common::AudioPortMixExt;
72using media::audio::common::AudioPortMixExtUseCase;
73using media::audio::common::AudioProfile;
74using media::audio::common::AudioSource;
75using media::audio::common::AudioStandard;
76using media::audio::common::AudioStreamType;
77using media::audio::common::AudioUsage;
78using media::audio::common::AudioUuid;
79using media::audio::common::ExtraAudioDescriptor;
80using media::audio::common::Int;
81using media::audio::common::PcmType;
82
83////////////////////////////////////////////////////////////////////////////////////////////////////
84// Converters
85
86::android::status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
87 if (aidl.size() > maxSize - 1) {
88 return BAD_VALUE;
89 }
90 aidl.copy(dest, aidl.size());
91 dest[aidl.size()] = '\0';
92 return OK;
93}
94
95ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
96 if (legacy == nullptr) {
97 return unexpected(BAD_VALUE);
98 }
99 if (strnlen(legacy, maxSize) == maxSize) {
100 // No null-terminator.
101 return unexpected(BAD_VALUE);
102 }
103 return std::string(legacy);
104}
105
106ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
107 return convertReinterpret<audio_module_handle_t>(aidl);
108}
109
110ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
111 return convertReinterpret<int32_t>(legacy);
112}
113
114ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
115 return convertReinterpret<audio_io_handle_t>(aidl);
116}
117
118ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
119 return convertReinterpret<int32_t>(legacy);
120}
121
122ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
123 return convertReinterpret<audio_port_handle_t>(aidl);
124}
125
126ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
127 return convertReinterpret<int32_t>(legacy);
128}
129
130ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
131 return convertReinterpret<audio_patch_handle_t>(aidl);
132}
133
134ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
135 return convertReinterpret<int32_t>(legacy);
136}
137
138ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
139 return convertReinterpret<audio_unique_id_t>(aidl);
140}
141
142ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
143 return convertReinterpret<int32_t>(legacy);
144}
145
146ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl) {
147 return convertReinterpret<audio_hw_sync_t>(aidl);
148}
149
150ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy) {
151 return convertReinterpret<int32_t>(legacy);
152}
153
154ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
155 return convertReinterpret<pid_t>(aidl);
156}
157
158ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
159 return convertReinterpret<int32_t>(legacy);
160}
161
162ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
163 return convertReinterpret<uid_t>(aidl);
164}
165
166ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
167 return convertReinterpret<int32_t>(legacy);
168}
169
170ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
171 return String16(aidl.data(), aidl.size());
172}
173
174ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
175 return std::string(String8(legacy).c_str());
176}
177
178// TODO b/182392769: create an optional -> optional util
179ConversionResult<std::optional<String16>>
180aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl) {
181 if (!aidl.has_value()) {
182 return std::nullopt;
183 }
184 ConversionResult<String16> conversion =
185 VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.value()));
186 return conversion.value();
187}
188
189ConversionResult<std::optional<std::string_view>>
190legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy) {
191 if (!legacy.has_value()) {
192 return std::nullopt;
193 }
194 ConversionResult<std::string> conversion =
195 VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.value()));
196 return conversion.value();
197}
198
199ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {
200 return String8(aidl.data(), aidl.size());
201}
202
203ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {
204 return std::string(legacy.c_str());
205}
206
207namespace {
208
209namespace detail {
210using AudioChannelBitPair = std::pair<audio_channel_mask_t, int>;
211using AudioChannelBitPairs = std::vector<AudioChannelBitPair>;
212using AudioChannelPair = std::pair<audio_channel_mask_t, AudioChannelLayout>;
213using AudioChannelPairs = std::vector<AudioChannelPair>;
214using AudioDevicePair = std::pair<audio_devices_t, AudioDeviceDescription>;
215using AudioDevicePairs = std::vector<AudioDevicePair>;
216using AudioFormatPair = std::pair<audio_format_t, AudioFormatDescription>;
217using AudioFormatPairs = std::vector<AudioFormatPair>;
218}
219
220const detail::AudioChannelBitPairs& getInAudioChannelBits() {
221 static const detail::AudioChannelBitPairs pairs = {
222 { AUDIO_CHANNEL_IN_LEFT, AudioChannelLayout::CHANNEL_FRONT_LEFT },
223 { AUDIO_CHANNEL_IN_RIGHT, AudioChannelLayout::CHANNEL_FRONT_RIGHT },
224 // AUDIO_CHANNEL_IN_FRONT is at the end
225 { AUDIO_CHANNEL_IN_BACK, AudioChannelLayout::CHANNEL_BACK_CENTER },
226 // AUDIO_CHANNEL_IN_*_PROCESSED not supported
227 // AUDIO_CHANNEL_IN_PRESSURE not supported
228 // AUDIO_CHANNEL_IN_*_AXIS not supported
229 // AUDIO_CHANNEL_IN_VOICE_* not supported
230 { AUDIO_CHANNEL_IN_BACK_LEFT, AudioChannelLayout::CHANNEL_BACK_LEFT },
231 { AUDIO_CHANNEL_IN_BACK_RIGHT, AudioChannelLayout::CHANNEL_BACK_RIGHT },
232 { AUDIO_CHANNEL_IN_CENTER, AudioChannelLayout::CHANNEL_FRONT_CENTER },
233 { AUDIO_CHANNEL_IN_LOW_FREQUENCY, AudioChannelLayout::CHANNEL_LOW_FREQUENCY },
234 { AUDIO_CHANNEL_IN_TOP_LEFT, AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT },
235 { AUDIO_CHANNEL_IN_TOP_RIGHT, AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT },
236 // When going from aidl to legacy, IN_CENTER is used
237 { AUDIO_CHANNEL_IN_FRONT, AudioChannelLayout::CHANNEL_FRONT_CENTER }
238 };
239 return pairs;
240}
241
242const detail::AudioChannelPairs& getInAudioChannelPairs() {
243 static const detail::AudioChannelPairs pairs = {
244#define DEFINE_INPUT_LAYOUT(n) \
245 { \
246 AUDIO_CHANNEL_IN_##n, \
247 AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
248 AudioChannelLayout::LAYOUT_##n) \
249 }
250
251 DEFINE_INPUT_LAYOUT(MONO),
252 DEFINE_INPUT_LAYOUT(STEREO),
253 DEFINE_INPUT_LAYOUT(FRONT_BACK),
254 // AUDIO_CHANNEL_IN_6 not supported
255 DEFINE_INPUT_LAYOUT(2POINT0POINT2),
256 DEFINE_INPUT_LAYOUT(2POINT1POINT2),
257 DEFINE_INPUT_LAYOUT(3POINT0POINT2),
258 DEFINE_INPUT_LAYOUT(3POINT1POINT2),
259 DEFINE_INPUT_LAYOUT(5POINT1)
260#undef DEFINE_INPUT_LAYOUT
261 };
262 return pairs;
263}
264
265const detail::AudioChannelBitPairs& getOutAudioChannelBits() {
266 static const detail::AudioChannelBitPairs pairs = {
267#define DEFINE_OUTPUT_BITS(n) \
268 { AUDIO_CHANNEL_OUT_##n, AudioChannelLayout::CHANNEL_##n }
269
270 DEFINE_OUTPUT_BITS(FRONT_LEFT),
271 DEFINE_OUTPUT_BITS(FRONT_RIGHT),
272 DEFINE_OUTPUT_BITS(FRONT_CENTER),
273 DEFINE_OUTPUT_BITS(LOW_FREQUENCY),
274 DEFINE_OUTPUT_BITS(BACK_LEFT),
275 DEFINE_OUTPUT_BITS(BACK_RIGHT),
276 DEFINE_OUTPUT_BITS(FRONT_LEFT_OF_CENTER),
277 DEFINE_OUTPUT_BITS(FRONT_RIGHT_OF_CENTER),
278 DEFINE_OUTPUT_BITS(BACK_CENTER),
279 DEFINE_OUTPUT_BITS(SIDE_LEFT),
280 DEFINE_OUTPUT_BITS(SIDE_RIGHT),
281 DEFINE_OUTPUT_BITS(TOP_CENTER),
282 DEFINE_OUTPUT_BITS(TOP_FRONT_LEFT),
283 DEFINE_OUTPUT_BITS(TOP_FRONT_CENTER),
284 DEFINE_OUTPUT_BITS(TOP_FRONT_RIGHT),
285 DEFINE_OUTPUT_BITS(TOP_BACK_LEFT),
286 DEFINE_OUTPUT_BITS(TOP_BACK_CENTER),
287 DEFINE_OUTPUT_BITS(TOP_BACK_RIGHT),
288 DEFINE_OUTPUT_BITS(TOP_SIDE_LEFT),
289 DEFINE_OUTPUT_BITS(TOP_SIDE_RIGHT),
290 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_LEFT),
291 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_CENTER),
292 DEFINE_OUTPUT_BITS(BOTTOM_FRONT_RIGHT),
293 DEFINE_OUTPUT_BITS(LOW_FREQUENCY_2),
294 DEFINE_OUTPUT_BITS(FRONT_WIDE_LEFT),
295 DEFINE_OUTPUT_BITS(FRONT_WIDE_RIGHT),
296#undef DEFINE_OUTPUT_BITS
297 { AUDIO_CHANNEL_OUT_HAPTIC_A, AudioChannelLayout::CHANNEL_HAPTIC_A },
298 { AUDIO_CHANNEL_OUT_HAPTIC_B, AudioChannelLayout::CHANNEL_HAPTIC_B }
299 };
300 return pairs;
301}
302
303const detail::AudioChannelPairs& getOutAudioChannelPairs() {
304 static const detail::AudioChannelPairs pairs = {
305#define DEFINE_OUTPUT_LAYOUT(n) \
306 { \
307 AUDIO_CHANNEL_OUT_##n, \
308 AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
309 AudioChannelLayout::LAYOUT_##n) \
310 }
311
312 DEFINE_OUTPUT_LAYOUT(MONO),
313 DEFINE_OUTPUT_LAYOUT(STEREO),
314 DEFINE_OUTPUT_LAYOUT(2POINT1),
315 DEFINE_OUTPUT_LAYOUT(TRI),
316 DEFINE_OUTPUT_LAYOUT(TRI_BACK),
317 DEFINE_OUTPUT_LAYOUT(3POINT1),
318 DEFINE_OUTPUT_LAYOUT(2POINT0POINT2),
319 DEFINE_OUTPUT_LAYOUT(2POINT1POINT2),
320 DEFINE_OUTPUT_LAYOUT(3POINT0POINT2),
321 DEFINE_OUTPUT_LAYOUT(3POINT1POINT2),
322 DEFINE_OUTPUT_LAYOUT(QUAD),
323 DEFINE_OUTPUT_LAYOUT(QUAD_SIDE),
324 DEFINE_OUTPUT_LAYOUT(SURROUND),
325 DEFINE_OUTPUT_LAYOUT(PENTA),
326 DEFINE_OUTPUT_LAYOUT(5POINT1),
327 DEFINE_OUTPUT_LAYOUT(5POINT1_SIDE),
328 DEFINE_OUTPUT_LAYOUT(5POINT1POINT2),
329 DEFINE_OUTPUT_LAYOUT(5POINT1POINT4),
330 DEFINE_OUTPUT_LAYOUT(6POINT1),
331 DEFINE_OUTPUT_LAYOUT(7POINT1),
332 DEFINE_OUTPUT_LAYOUT(7POINT1POINT2),
333 DEFINE_OUTPUT_LAYOUT(7POINT1POINT4),
334 DEFINE_OUTPUT_LAYOUT(13POINT_360RA),
335 DEFINE_OUTPUT_LAYOUT(22POINT2),
336 DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_A),
337 DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_A),
338 DEFINE_OUTPUT_LAYOUT(HAPTIC_AB),
339 DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_AB),
340 DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_AB)
341#undef DEFINE_OUTPUT_LAYOUT
342 };
343 return pairs;
344}
345
346const detail::AudioChannelPairs& getVoiceAudioChannelPairs() {
347 static const detail::AudioChannelPairs pairs = {
348#define DEFINE_VOICE_LAYOUT(n) \
349 { \
350 AUDIO_CHANNEL_IN_VOICE_##n, \
351 AudioChannelLayout::make<AudioChannelLayout::Tag::voiceMask>( \
352 AudioChannelLayout::VOICE_##n) \
353 }
354 DEFINE_VOICE_LAYOUT(UPLINK_MONO),
355 DEFINE_VOICE_LAYOUT(DNLINK_MONO),
356 DEFINE_VOICE_LAYOUT(CALL_MONO)
357#undef DEFINE_VOICE_LAYOUT
358 };
359 return pairs;
360}
361
362AudioDeviceDescription make_AudioDeviceDescription(AudioDeviceType type,
363 const std::string& connection = "") {
364 AudioDeviceDescription result;
365 result.type = type;
366 result.connection = connection;
367 return result;
368}
369
370void append_AudioDeviceDescription(detail::AudioDevicePairs& pairs,
371 audio_devices_t inputType, audio_devices_t outputType,
372 AudioDeviceType inType, AudioDeviceType outType,
373 const std::string& connection = "") {
374 pairs.push_back(std::make_pair(inputType, make_AudioDeviceDescription(inType, connection)));
375 pairs.push_back(std::make_pair(outputType, make_AudioDeviceDescription(outType, connection)));
376}
377
378const detail::AudioDevicePairs& getAudioDevicePairs() {
379 static const detail::AudioDevicePairs pairs = []() {
380 detail::AudioDevicePairs pairs = {{
381 {
382 AUDIO_DEVICE_NONE, AudioDeviceDescription{}
383 },
384 {
385 AUDIO_DEVICE_OUT_EARPIECE, make_AudioDeviceDescription(
386 AudioDeviceType::OUT_SPEAKER_EARPIECE)
387 },
388 {
389 AUDIO_DEVICE_OUT_SPEAKER, make_AudioDeviceDescription(
390 AudioDeviceType::OUT_SPEAKER)
391 },
392 {
393 AUDIO_DEVICE_OUT_WIRED_HEADPHONE, make_AudioDeviceDescription(
394 AudioDeviceType::OUT_HEADPHONE,
395 GET_DEVICE_DESC_CONNECTION(ANALOG))
396 },
397 {
398 AUDIO_DEVICE_OUT_BLUETOOTH_SCO, make_AudioDeviceDescription(
399 AudioDeviceType::OUT_DEVICE,
400 GET_DEVICE_DESC_CONNECTION(BT_SCO))
401 },
402 {
403 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, make_AudioDeviceDescription(
404 AudioDeviceType::OUT_CARKIT,
405 GET_DEVICE_DESC_CONNECTION(BT_SCO))
406 },
407 {
408 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, make_AudioDeviceDescription(
409 AudioDeviceType::OUT_HEADPHONE,
410 GET_DEVICE_DESC_CONNECTION(BT_A2DP))
411 },
412 {
413 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, make_AudioDeviceDescription(
414 AudioDeviceType::OUT_SPEAKER,
415 GET_DEVICE_DESC_CONNECTION(BT_A2DP))
416 },
417 {
418 AUDIO_DEVICE_OUT_TELEPHONY_TX, make_AudioDeviceDescription(
419 AudioDeviceType::OUT_TELEPHONY_TX)
420 },
421 {
422 AUDIO_DEVICE_OUT_AUX_LINE, make_AudioDeviceDescription(
423 AudioDeviceType::OUT_LINE_AUX)
424 },
425 {
426 AUDIO_DEVICE_OUT_SPEAKER_SAFE, make_AudioDeviceDescription(
427 AudioDeviceType::OUT_SPEAKER_SAFE)
428 },
429 {
430 AUDIO_DEVICE_OUT_HEARING_AID, make_AudioDeviceDescription(
431 AudioDeviceType::OUT_HEARING_AID,
432 GET_DEVICE_DESC_CONNECTION(WIRELESS))
433 },
434 {
435 AUDIO_DEVICE_OUT_ECHO_CANCELLER, make_AudioDeviceDescription(
436 AudioDeviceType::OUT_ECHO_CANCELLER)
437 },
438 {
439 AUDIO_DEVICE_OUT_BLE_SPEAKER, make_AudioDeviceDescription(
440 AudioDeviceType::OUT_SPEAKER,
441 GET_DEVICE_DESC_CONNECTION(BT_LE))
442 },
443 {
444 AUDIO_DEVICE_OUT_BLE_BROADCAST, make_AudioDeviceDescription(
445 AudioDeviceType::OUT_BROADCAST,
446 GET_DEVICE_DESC_CONNECTION(BT_LE))
447 },
448 // AUDIO_DEVICE_IN_AMBIENT and IN_COMMUNICATION are removed since they were deprecated.
449 {
450 AUDIO_DEVICE_IN_BUILTIN_MIC, make_AudioDeviceDescription(
451 AudioDeviceType::IN_MICROPHONE)
452 },
453 {
454 AUDIO_DEVICE_IN_BACK_MIC, make_AudioDeviceDescription(
455 AudioDeviceType::IN_MICROPHONE_BACK)
456 },
457 {
458 AUDIO_DEVICE_IN_TELEPHONY_RX, make_AudioDeviceDescription(
459 AudioDeviceType::IN_TELEPHONY_RX)
460 },
461 {
462 AUDIO_DEVICE_IN_TV_TUNER, make_AudioDeviceDescription(
463 AudioDeviceType::IN_TV_TUNER)
464 },
465 {
466 AUDIO_DEVICE_IN_LOOPBACK, make_AudioDeviceDescription(
467 AudioDeviceType::IN_LOOPBACK)
468 },
469 {
470 AUDIO_DEVICE_IN_BLUETOOTH_BLE, make_AudioDeviceDescription(
471 AudioDeviceType::IN_DEVICE,
472 GET_DEVICE_DESC_CONNECTION(BT_LE))
473 },
474 {
475 AUDIO_DEVICE_IN_ECHO_REFERENCE, make_AudioDeviceDescription(
476 AudioDeviceType::IN_ECHO_REFERENCE)
477 }
478 }};
479 append_AudioDeviceDescription(pairs,
480 AUDIO_DEVICE_IN_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT,
481 AudioDeviceType::IN_DEFAULT, AudioDeviceType::OUT_DEFAULT);
482 append_AudioDeviceDescription(pairs,
483 AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET,
484 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
485 GET_DEVICE_DESC_CONNECTION(ANALOG));
486 append_AudioDeviceDescription(pairs,
487 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
488 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
489 GET_DEVICE_DESC_CONNECTION(BT_SCO));
490 append_AudioDeviceDescription(pairs,
491 AUDIO_DEVICE_IN_HDMI, AUDIO_DEVICE_OUT_HDMI,
492 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
493 GET_DEVICE_DESC_CONNECTION(HDMI));
494 append_AudioDeviceDescription(pairs,
495 AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
496 AudioDeviceType::IN_SUBMIX, AudioDeviceType::OUT_SUBMIX);
497 append_AudioDeviceDescription(pairs,
498 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,
499 AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
500 GET_DEVICE_DESC_CONNECTION(ANALOG));
501 append_AudioDeviceDescription(pairs,
502 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,
503 AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
504 GET_DEVICE_DESC_CONNECTION(USB));
505 append_AudioDeviceDescription(pairs,
506 AUDIO_DEVICE_IN_USB_ACCESSORY, AUDIO_DEVICE_OUT_USB_ACCESSORY,
507 AudioDeviceType::IN_ACCESSORY, AudioDeviceType::OUT_ACCESSORY,
508 GET_DEVICE_DESC_CONNECTION(USB));
509 append_AudioDeviceDescription(pairs,
510 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_OUT_USB_DEVICE,
511 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
512 GET_DEVICE_DESC_CONNECTION(USB));
513 append_AudioDeviceDescription(pairs,
514 AUDIO_DEVICE_IN_FM_TUNER, AUDIO_DEVICE_OUT_FM,
515 AudioDeviceType::IN_FM_TUNER, AudioDeviceType::OUT_FM);
516 append_AudioDeviceDescription(pairs,
517 AUDIO_DEVICE_IN_LINE, AUDIO_DEVICE_OUT_LINE,
518 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
519 GET_DEVICE_DESC_CONNECTION(ANALOG));
520 append_AudioDeviceDescription(pairs,
521 AUDIO_DEVICE_IN_SPDIF, AUDIO_DEVICE_OUT_SPDIF,
522 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
523 GET_DEVICE_DESC_CONNECTION(SPDIF));
524 append_AudioDeviceDescription(pairs,
525 AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
526 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
527 GET_DEVICE_DESC_CONNECTION(BT_A2DP));
528 append_AudioDeviceDescription(pairs,
529 AUDIO_DEVICE_IN_IP, AUDIO_DEVICE_OUT_IP,
530 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
531 GET_DEVICE_DESC_CONNECTION(IP_V4));
532 append_AudioDeviceDescription(pairs,
533 AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_OUT_BUS,
534 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
535 GET_DEVICE_DESC_CONNECTION(BUS));
536 append_AudioDeviceDescription(pairs,
537 AUDIO_DEVICE_IN_PROXY, AUDIO_DEVICE_OUT_PROXY,
538 AudioDeviceType::IN_AFE_PROXY, AudioDeviceType::OUT_AFE_PROXY);
539 append_AudioDeviceDescription(pairs,
540 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_OUT_USB_HEADSET,
541 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
542 GET_DEVICE_DESC_CONNECTION(USB));
543 append_AudioDeviceDescription(pairs,
544 AUDIO_DEVICE_IN_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_ARC,
545 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
546 GET_DEVICE_DESC_CONNECTION(HDMI_ARC));
547 append_AudioDeviceDescription(pairs,
548 AUDIO_DEVICE_IN_HDMI_EARC, AUDIO_DEVICE_OUT_HDMI_EARC,
549 AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
550 GET_DEVICE_DESC_CONNECTION(HDMI_EARC));
551 append_AudioDeviceDescription(pairs,
552 AUDIO_DEVICE_IN_BLE_HEADSET, AUDIO_DEVICE_OUT_BLE_HEADSET,
553 AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
554 GET_DEVICE_DESC_CONNECTION(BT_LE));
555 return pairs;
556 }();
557#undef GET_DEVICE_DESC_CONNECTION
558 return pairs;
559}
560
561AudioFormatDescription make_AudioFormatDescription(AudioFormatType type) {
562 AudioFormatDescription result;
563 result.type = type;
564 return result;
565}
566
567AudioFormatDescription make_AudioFormatDescription(PcmType pcm) {
568 auto result = make_AudioFormatDescription(AudioFormatType::PCM);
569 result.pcm = pcm;
570 return result;
571}
572
573AudioFormatDescription make_AudioFormatDescription(const std::string& encoding) {
574 AudioFormatDescription result;
575 result.encoding = encoding;
576 return result;
577}
578
579AudioFormatDescription make_AudioFormatDescription(PcmType transport,
580 const std::string& encoding) {
581 auto result = make_AudioFormatDescription(encoding);
582 result.pcm = transport;
583 return result;
584}
585
586const detail::AudioFormatPairs& getAudioFormatPairs() {
587 static const detail::AudioFormatPairs pairs = {{
588 {AUDIO_FORMAT_INVALID,
589 make_AudioFormatDescription(AudioFormatType::SYS_RESERVED_INVALID)},
590 {AUDIO_FORMAT_DEFAULT, AudioFormatDescription{}},
591 {AUDIO_FORMAT_PCM_16_BIT, make_AudioFormatDescription(PcmType::INT_16_BIT)},
592 {AUDIO_FORMAT_PCM_8_BIT, make_AudioFormatDescription(PcmType::UINT_8_BIT)},
593 {AUDIO_FORMAT_PCM_32_BIT, make_AudioFormatDescription(PcmType::INT_32_BIT)},
594 {AUDIO_FORMAT_PCM_8_24_BIT, make_AudioFormatDescription(PcmType::FIXED_Q_8_24)},
595 {AUDIO_FORMAT_PCM_FLOAT, make_AudioFormatDescription(PcmType::FLOAT_32_BIT)},
596 {AUDIO_FORMAT_PCM_24_BIT_PACKED, make_AudioFormatDescription(PcmType::INT_24_BIT)},
597 {AUDIO_FORMAT_MP3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEG)},
598 {AUDIO_FORMAT_AMR_NB,
599 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_NB)},
600 {AUDIO_FORMAT_AMR_WB,
601 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_WB)},
602 {AUDIO_FORMAT_AAC,
603 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_MP4)},
604 {AUDIO_FORMAT_AAC_MAIN,
605 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_MAIN)},
606 {AUDIO_FORMAT_AAC_LC,
607 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LC)},
608 {AUDIO_FORMAT_AAC_SSR,
609 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_SSR)},
610 {AUDIO_FORMAT_AAC_LTP,
611 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LTP)},
612 {AUDIO_FORMAT_AAC_HE_V1,
613 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_HE_V1)},
614 {AUDIO_FORMAT_AAC_SCALABLE,
615 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_SCALABLE)},
616 {AUDIO_FORMAT_AAC_ERLC,
617 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ERLC)},
618 {AUDIO_FORMAT_AAC_LD,
619 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LD)},
620 {AUDIO_FORMAT_AAC_HE_V2,
621 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_HE_V2)},
622 {AUDIO_FORMAT_AAC_ELD,
623 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ELD)},
624 {AUDIO_FORMAT_AAC_XHE,
625 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_XHE)
626
627 },
628 // AUDIO_FORMAT_HE_AAC_V1 and HE_AAC_V2 are removed since they were deprecated long time
629 // ago.
630 {AUDIO_FORMAT_VORBIS,
631 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_VORBIS)},
632 {AUDIO_FORMAT_OPUS, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_OPUS)},
633 {AUDIO_FORMAT_AC3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AC3)},
634 {AUDIO_FORMAT_E_AC3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EAC3)},
635 {AUDIO_FORMAT_E_AC3_JOC,
636 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EAC3_JOC)},
637 {AUDIO_FORMAT_DTS, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS)},
638 {AUDIO_FORMAT_DTS_HD,
639 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_HD)},
640 {AUDIO_FORMAT_DTS_HD_MA,
641 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_HD_MA)},
642 {AUDIO_FORMAT_DTS_UHD,
643 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_UHD_P1)},
644 {AUDIO_FORMAT_DTS_UHD_P2,
645 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_UHD_P2)},
646 // In the future, we would like to represent encapsulated bitstreams as
647 // nested AudioFormatDescriptions. The legacy 'AUDIO_FORMAT_IEC61937' type doesn't
648 // specify the format of the encapsulated bitstream.
649 {AUDIO_FORMAT_IEC61937,
650 make_AudioFormatDescription(PcmType::INT_16_BIT,
651 ::android::MEDIA_MIMETYPE_AUDIO_IEC61937)},
652 {AUDIO_FORMAT_DOLBY_TRUEHD,
653 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_TRUEHD)},
654 {AUDIO_FORMAT_EVRC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRC)},
655 {AUDIO_FORMAT_EVRCB,
656 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCB)},
657 {AUDIO_FORMAT_EVRCWB,
658 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCWB)},
659 {AUDIO_FORMAT_EVRCNW,
660 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCNW)},
661 {AUDIO_FORMAT_AAC_ADIF,
662 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADIF)},
663 {AUDIO_FORMAT_WMA, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_WMA)},
664 {// Note: not in the IANA registry.
665 AUDIO_FORMAT_WMA_PRO, make_AudioFormatDescription("audio/x-ms-wma.pro")},
666 {AUDIO_FORMAT_AMR_WB_PLUS,
667 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_WB_PLUS)},
668 {AUDIO_FORMAT_MP2,
669 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II)},
670 {AUDIO_FORMAT_QCELP,
671 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_QCELP)},
672 {// Note: not in the IANA registry.
673 AUDIO_FORMAT_DSD, make_AudioFormatDescription("audio/vnd.sony.dsd")},
674 {AUDIO_FORMAT_FLAC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_FLAC)},
675 {AUDIO_FORMAT_ALAC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_ALAC)},
676 {// Note: not in the IANA registry.
677 AUDIO_FORMAT_APE, make_AudioFormatDescription("audio/x-ape")},
678 {AUDIO_FORMAT_AAC_ADTS,
679 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS)},
680 {AUDIO_FORMAT_AAC_ADTS_MAIN,
681 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_MAIN)},
682 {AUDIO_FORMAT_AAC_ADTS_LC,
683 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LC)},
684 {AUDIO_FORMAT_AAC_ADTS_SSR,
685 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SSR)},
686 {AUDIO_FORMAT_AAC_ADTS_LTP,
687 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LTP)},
688 {AUDIO_FORMAT_AAC_ADTS_HE_V1,
689 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V1)},
690 {AUDIO_FORMAT_AAC_ADTS_SCALABLE,
691 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SCALABLE)},
692 {AUDIO_FORMAT_AAC_ADTS_ERLC,
693 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ERLC)},
694 {AUDIO_FORMAT_AAC_ADTS_LD,
695 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LD)},
696 {AUDIO_FORMAT_AAC_ADTS_HE_V2,
697 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V2)},
698 {AUDIO_FORMAT_AAC_ADTS_ELD,
699 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ELD)},
700 {AUDIO_FORMAT_AAC_ADTS_XHE,
701 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_XHE)},
702 {// Note: not in the IANA registry. "vnd.octel.sbc" is not BT SBC.
703 AUDIO_FORMAT_SBC, make_AudioFormatDescription("audio/x-sbc")},
704 {AUDIO_FORMAT_APTX, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_APTX)},
705 {// Note: not in the IANA registry.
706 AUDIO_FORMAT_APTX_HD, make_AudioFormatDescription("audio/vnd.qcom.aptx.hd")},
707 {AUDIO_FORMAT_AC4, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AC4)},
708 {// Note: not in the IANA registry.
709 AUDIO_FORMAT_LDAC, make_AudioFormatDescription("audio/vnd.sony.ldac")},
710 {AUDIO_FORMAT_MAT,
711 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT)},
712 {// Note: not in the IANA registry.
713 AUDIO_FORMAT_MAT_1_0,
714 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
715 std::string(".1.0"))},
716 {// Note: not in the IANA registry.
717 AUDIO_FORMAT_MAT_2_0,
718 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
719 std::string(".2.0"))},
720 {// Note: not in the IANA registry.
721 AUDIO_FORMAT_MAT_2_1,
722 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
723 std::string(".2.1"))},
724 {AUDIO_FORMAT_AAC_LATM,
725 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC)},
726 {AUDIO_FORMAT_AAC_LATM_LC,
727 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_LC)},
728 {AUDIO_FORMAT_AAC_LATM_HE_V1,
729 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V1)},
730 {AUDIO_FORMAT_AAC_LATM_HE_V2,
731 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V2)},
732 {// Note: not in the IANA registry.
733 AUDIO_FORMAT_CELT, make_AudioFormatDescription("audio/x-celt")},
734 {// Note: not in the IANA registry.
735 AUDIO_FORMAT_APTX_ADAPTIVE,
736 make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive")},
737 {// Note: not in the IANA registry.
738 AUDIO_FORMAT_LHDC, make_AudioFormatDescription("audio/vnd.savitech.lhdc")},
739 {// Note: not in the IANA registry.
740 AUDIO_FORMAT_LHDC_LL, make_AudioFormatDescription("audio/vnd.savitech.lhdc.ll")},
741 {// Note: not in the IANA registry.
742 AUDIO_FORMAT_APTX_TWSP, make_AudioFormatDescription("audio/vnd.qcom.aptx.twsp")},
743 {// Note: not in the IANA registry.
744 AUDIO_FORMAT_LC3, make_AudioFormatDescription("audio/x-lc3")},
745 {AUDIO_FORMAT_MPEGH,
746 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1)},
747 {AUDIO_FORMAT_MPEGH_BL_L3,
748 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L3)},
749 {AUDIO_FORMAT_MPEGH_BL_L4,
750 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L4)},
751 {AUDIO_FORMAT_MPEGH_LC_L3,
752 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L3)},
753 {AUDIO_FORMAT_MPEGH_LC_L4,
754 make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L4)},
755 {AUDIO_FORMAT_IEC60958,
756 make_AudioFormatDescription(PcmType::INT_24_BIT,
757 ::android::MEDIA_MIMETYPE_AUDIO_IEC60958)},
758 {AUDIO_FORMAT_DRA, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DRA)},
759 {// Note: not in the IANA registry.
760 AUDIO_FORMAT_APTX_ADAPTIVE_QLEA,
761 make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r3")},
762 {// Note: not in the IANA registry.
763 AUDIO_FORMAT_APTX_ADAPTIVE_R4,
764 make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r4")},
765 }};
766 return pairs;
767}
768
769template<typename S, typename T>
770std::map<S, T> make_DirectMap(const std::vector<std::pair<S, T>>& v) {
771 std::map<S, T> result(v.begin(), v.end());
772 LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
773 return result;
774}
775
776template<typename S, typename T>
777std::map<S, T> make_DirectMap(
778 const std::vector<std::pair<S, T>>& v1, const std::vector<std::pair<S, T>>& v2) {
779 std::map<S, T> result(v1.begin(), v1.end());
780 LOG_ALWAYS_FATAL_IF(result.size() != v1.size(), "Duplicate key elements detected in v1");
781 result.insert(v2.begin(), v2.end());
782 LOG_ALWAYS_FATAL_IF(result.size() != v1.size() + v2.size(),
783 "Duplicate key elements detected in v1+v2");
784 return result;
785}
786
787template<typename S, typename T>
788std::map<T, S> make_ReverseMap(const std::vector<std::pair<S, T>>& v) {
789 std::map<T, S> result;
790 std::transform(v.begin(), v.end(), std::inserter(result, result.begin()),
791 [](const std::pair<S, T>& p) {
792 return std::make_pair(p.second, p.first);
793 });
794 LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
795 return result;
796}
797
798} // namespace
799
800audio_channel_mask_t aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
801 int aidlLayout, bool isInput) {
802 auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
803 const int aidlLayoutInitial = aidlLayout; // for error message
804 audio_channel_mask_t legacy = AUDIO_CHANNEL_NONE;
805 for (const auto& bitPair : bitMapping) {
806 if ((aidlLayout & bitPair.second) == bitPair.second) {
807 legacy = static_cast<audio_channel_mask_t>(legacy | bitPair.first);
808 aidlLayout &= ~bitPair.second;
809 if (aidlLayout == 0) {
810 return legacy;
811 }
812 }
813 }
814 ALOGE("%s: aidl layout 0x%x contains bits 0x%x that have no match to legacy %s bits",
815 __func__, aidlLayoutInitial, aidlLayout, isInput ? "input" : "output");
816 return AUDIO_CHANNEL_NONE;
817}
818
819ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
820 const AudioChannelLayout& aidl, bool isInput) {
821 using ReverseMap = std::map<AudioChannelLayout, audio_channel_mask_t>;
822 using Tag = AudioChannelLayout::Tag;
823 static const ReverseMap mIn = make_ReverseMap(getInAudioChannelPairs());
824 static const ReverseMap mOut = make_ReverseMap(getOutAudioChannelPairs());
825 static const ReverseMap mVoice = make_ReverseMap(getVoiceAudioChannelPairs());
826
827 auto convert = [](const AudioChannelLayout& aidl, const ReverseMap& m,
828 const char* func, const char* type) -> ConversionResult<audio_channel_mask_t> {
829 if (auto it = m.find(aidl); it != m.end()) {
830 return it->second;
831 } else {
832 ALOGW("%s: no legacy %s audio_channel_mask_t found for %s", func, type,
833 aidl.toString().c_str());
834 return unexpected(BAD_VALUE);
835 }
836 };
837
838 switch (aidl.getTag()) {
839 case Tag::none:
840 return AUDIO_CHANNEL_NONE;
841 case Tag::invalid:
842 return AUDIO_CHANNEL_INVALID;
843 case Tag::indexMask:
844 // Index masks do not have pre-defined values.
845 if (const int bits = aidl.get<Tag::indexMask>();
846 __builtin_popcount(bits) != 0 &&
847 __builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {
848 return audio_channel_mask_from_representation_and_bits(
849 AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
850 } else {
851 ALOGE("%s: invalid indexMask value 0x%x in %s",
852 __func__, bits, aidl.toString().c_str());
853 return unexpected(BAD_VALUE);
854 }
855 case Tag::layoutMask:
856 // The fast path is to find a direct match for some known layout mask.
857 if (const auto layoutMatch = convert(aidl, isInput ? mIn : mOut, __func__,
858 isInput ? "input" : "output");
859 layoutMatch.ok()) {
860 return layoutMatch;
861 }
862 // If a match for a predefined layout wasn't found, make a custom one from bits.
863 if (audio_channel_mask_t bitMask =
864 aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
865 aidl.get<Tag::layoutMask>(), isInput);
866 bitMask != AUDIO_CHANNEL_NONE) {
867 return bitMask;
868 }
869 return unexpected(BAD_VALUE);
870 case Tag::voiceMask:
871 return convert(aidl, mVoice, __func__, "voice");
872 }
873 ALOGE("%s: unexpected tag value %d", __func__, aidl.getTag());
874 return unexpected(BAD_VALUE);
875}
876
877int legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
878 audio_channel_mask_t legacy, bool isInput) {
879 auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
880 const int legacyInitial = legacy; // for error message
881 int aidlLayout = 0;
882 for (const auto& bitPair : bitMapping) {
883 if ((legacy & bitPair.first) == bitPair.first) {
884 aidlLayout |= bitPair.second;
885 legacy = static_cast<audio_channel_mask_t>(legacy & ~bitPair.first);
886 if (legacy == 0) {
887 return aidlLayout;
888 }
889 }
890 }
891 ALOGE("%s: legacy %s audio_channel_mask_t 0x%x contains unrecognized bits 0x%x",
892 __func__, isInput ? "input" : "output", legacyInitial, legacy);
893 return 0;
894}
895
896ConversionResult<AudioChannelLayout> legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
897 audio_channel_mask_t legacy, bool isInput) {
898 using DirectMap = std::map<audio_channel_mask_t, AudioChannelLayout>;
899 using Tag = AudioChannelLayout::Tag;
900 static const DirectMap mInAndVoice = make_DirectMap(
901 getInAudioChannelPairs(), getVoiceAudioChannelPairs());
902 static const DirectMap mOut = make_DirectMap(getOutAudioChannelPairs());
903
904 auto convert = [](const audio_channel_mask_t legacy, const DirectMap& m,
905 const char* func, const char* type) -> ConversionResult<AudioChannelLayout> {
906 if (auto it = m.find(legacy); it != m.end()) {
907 return it->second;
908 } else {
909 ALOGW("%s: no AudioChannelLayout found for legacy %s audio_channel_mask_t value 0x%x",
910 func, type, legacy);
911 return unexpected(BAD_VALUE);
912 }
913 };
914
915 if (legacy == AUDIO_CHANNEL_NONE) {
916 return AudioChannelLayout{};
917 } else if (legacy == AUDIO_CHANNEL_INVALID) {
918 return AudioChannelLayout::make<Tag::invalid>(0);
919 }
920
921 const audio_channel_representation_t repr = audio_channel_mask_get_representation(legacy);
922 if (repr == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
923 if (audio_channel_mask_is_valid(legacy)) {
924 const int indexMask = VALUE_OR_RETURN(
925 convertIntegral<int>(audio_channel_mask_get_bits(legacy)));
926 return AudioChannelLayout::make<Tag::indexMask>(indexMask);
927 } else {
928 ALOGE("%s: legacy audio_channel_mask_t value 0x%x is invalid", __func__, legacy);
929 return unexpected(BAD_VALUE);
930 }
931 } else if (repr == AUDIO_CHANNEL_REPRESENTATION_POSITION) {
932 // The fast path is to find a direct match for some known layout mask.
933 if (const auto layoutMatch = convert(legacy, isInput ? mInAndVoice : mOut, __func__,
934 isInput ? "input / voice" : "output");
935 layoutMatch.ok()) {
936 return layoutMatch;
937 }
938 // If a match for a predefined layout wasn't found, make a custom one from bits,
939 // rejecting those with voice channel bits.
940 if (!isInput ||
941 (legacy & (AUDIO_CHANNEL_IN_VOICE_UPLINK | AUDIO_CHANNEL_IN_VOICE_DNLINK)) == 0) {
942 if (int bitMaskLayout =
943 legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
944 legacy, isInput);
945 bitMaskLayout != 0) {
946 return AudioChannelLayout::make<Tag::layoutMask>(bitMaskLayout);
947 }
948 } else {
949 ALOGE("%s: legacy audio_channel_mask_t value 0x%x contains voice bits",
950 __func__, legacy);
951 }
952 return unexpected(BAD_VALUE);
953 }
954
955 ALOGE("%s: unknown representation %d in audio_channel_mask_t value 0x%x",
956 __func__, repr, legacy);
957 return unexpected(BAD_VALUE);
958}
959
960ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
961 const AudioDeviceDescription& aidl) {
962 static const std::map<AudioDeviceDescription, audio_devices_t> m =
963 make_ReverseMap(getAudioDevicePairs());
964 if (auto it = m.find(aidl); it != m.end()) {
965 return it->second;
966 } else {
967 ALOGE("%s: no legacy audio_devices_t found for %s", __func__, aidl.toString().c_str());
968 return unexpected(BAD_VALUE);
969 }
970}
971
972ConversionResult<AudioDeviceDescription> legacy2aidl_audio_devices_t_AudioDeviceDescription(
973 audio_devices_t legacy) {
974 static const std::map<audio_devices_t, AudioDeviceDescription> m =
975 make_DirectMap(getAudioDevicePairs());
976 if (auto it = m.find(legacy); it != m.end()) {
977 return it->second;
978 } else {
979 ALOGE("%s: no AudioDeviceDescription found for legacy audio_devices_t value 0x%x",
980 __func__, legacy);
981 return unexpected(BAD_VALUE);
982 }
983}
984
985::android::status_t aidl2legacy_AudioDevice_audio_device(
986 const AudioDevice& aidl,
987 audio_devices_t* legacyType, char* legacyAddress) {
988 *legacyType = VALUE_OR_RETURN_STATUS(
989 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
990 return aidl2legacy_string(
991 aidl.address.get<AudioDeviceAddress::id>(),
992 legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN);
993}
994
995::android::status_t aidl2legacy_AudioDevice_audio_device(
996 const AudioDevice& aidl,
997 audio_devices_t* legacyType, String8* legacyAddress) {
998 *legacyType = VALUE_OR_RETURN_STATUS(
999 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
1000 *legacyAddress = VALUE_OR_RETURN_STATUS(aidl2legacy_string_view_String8(
1001 aidl.address.get<AudioDeviceAddress::id>()));
1002 return OK;
1003}
1004
1005::android::status_t aidl2legacy_AudioDevice_audio_device(
1006 const AudioDevice& aidl,
1007 audio_devices_t* legacyType, std::string* legacyAddress) {
1008 *legacyType = VALUE_OR_RETURN_STATUS(
1009 aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
1010 *legacyAddress = aidl.address.get<AudioDeviceAddress::id>();
1011 return OK;
1012}
1013
1014ConversionResult<AudioDevice> legacy2aidl_audio_device_AudioDevice(
1015 audio_devices_t legacyType, const char* legacyAddress) {
1016 AudioDevice aidl;
1017 aidl.type = VALUE_OR_RETURN(
1018 legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
1019 const std::string aidl_id = VALUE_OR_RETURN(
1020 legacy2aidl_string(legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
1021 aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
1022 return aidl;
1023}
1024
1025ConversionResult<AudioDevice>
1026legacy2aidl_audio_device_AudioDevice(
1027 audio_devices_t legacyType, const String8& legacyAddress) {
1028 AudioDevice aidl;
1029 aidl.type = VALUE_OR_RETURN(
1030 legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
1031 const std::string aidl_id = VALUE_OR_RETURN(
1032 legacy2aidl_String8_string(legacyAddress));
1033 aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
1034 return aidl;
1035}
1036
1037ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
1038 const AudioFormatDescription& aidl) {
1039 static const std::map<AudioFormatDescription, audio_format_t> m =
1040 make_ReverseMap(getAudioFormatPairs());
1041 if (auto it = m.find(aidl); it != m.end()) {
1042 return it->second;
1043 } else {
1044 ALOGE("%s: no legacy audio_format_t found for %s", __func__, aidl.toString().c_str());
1045 return unexpected(BAD_VALUE);
1046 }
1047}
1048
1049ConversionResult<AudioFormatDescription> legacy2aidl_audio_format_t_AudioFormatDescription(
1050 audio_format_t legacy) {
1051 static const std::map<audio_format_t, AudioFormatDescription> m =
1052 make_DirectMap(getAudioFormatPairs());
1053 if (auto it = m.find(legacy); it != m.end()) {
1054 return it->second;
1055 } else {
1056 ALOGE("%s: no AudioFormatDescription found for legacy audio_format_t value 0x%x",
1057 __func__, legacy);
1058 return unexpected(BAD_VALUE);
1059 }
1060}
1061
1062ConversionResult<audio_gain_mode_t> aidl2legacy_AudioGainMode_audio_gain_mode_t(
1063 AudioGainMode aidl) {
1064 switch (aidl) {
1065 case AudioGainMode::JOINT:
1066 return AUDIO_GAIN_MODE_JOINT;
1067 case AudioGainMode::CHANNELS:
1068 return AUDIO_GAIN_MODE_CHANNELS;
1069 case AudioGainMode::RAMP:
1070 return AUDIO_GAIN_MODE_RAMP;
1071 }
1072 return unexpected(BAD_VALUE);
1073}
1074
1075ConversionResult<AudioGainMode> legacy2aidl_audio_gain_mode_t_AudioGainMode(
1076 audio_gain_mode_t legacy) {
1077 switch (legacy) {
1078 case AUDIO_GAIN_MODE_JOINT:
1079 return AudioGainMode::JOINT;
1080 case AUDIO_GAIN_MODE_CHANNELS:
1081 return AudioGainMode::CHANNELS;
1082 case AUDIO_GAIN_MODE_RAMP:
1083 return AudioGainMode::RAMP;
1084 }
1085 return unexpected(BAD_VALUE);
1086}
1087
1088ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl) {
1089 return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, AudioGainMode>(
1090 aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
1091 // AudioGainMode is index-based.
1092 indexToEnum_index<AudioGainMode>,
1093 // AUDIO_GAIN_MODE_* constants are mask-based.
1094 enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
1095}
1096
1097ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy) {
1098 return convertBitmask<int32_t, audio_gain_mode_t, AudioGainMode, audio_gain_mode_t>(
1099 legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
1100 // AUDIO_GAIN_MODE_* constants are mask-based.
1101 indexToEnum_bitmask<audio_gain_mode_t>,
1102 // AudioGainMode is index-based.
1103 enumToMask_index<int32_t, AudioGainMode>);
1104}
1105
1106ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
1107 const AudioGainConfig& aidl, bool isInput) {
1108 audio_gain_config legacy;
1109 legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
1110 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
1111 legacy.channel_mask = VALUE_OR_RETURN(
1112 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
1113 const bool isJoint = bitmaskIsSet(aidl.mode, AudioGainMode::JOINT);
1114 size_t numValues = isJoint ? 1
1115 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
1116 : audio_channel_count_from_out_mask(legacy.channel_mask);
1117 if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
1118 return unexpected(BAD_VALUE);
1119 }
1120 for (size_t i = 0; i < numValues; ++i) {
1121 legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
1122 }
1123 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
1124 return legacy;
1125}
1126
1127ConversionResult<AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
1128 const audio_gain_config& legacy, bool isInput) {
1129 AudioGainConfig aidl;
1130 aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
1131 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
1132 aidl.channelMask = VALUE_OR_RETURN(
1133 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1134 const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
1135 size_t numValues = isJoint ? 1
1136 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
1137 : audio_channel_count_from_out_mask(legacy.channel_mask);
1138 aidl.values.resize(numValues);
1139 for (size_t i = 0; i < numValues; ++i) {
1140 aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
1141 }
1142 aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
1143 return aidl;
1144}
1145
1146ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
1147 AudioInputFlags aidl) {
1148 switch (aidl) {
1149 case AudioInputFlags::FAST:
1150 return AUDIO_INPUT_FLAG_FAST;
1151 case AudioInputFlags::HW_HOTWORD:
1152 return AUDIO_INPUT_FLAG_HW_HOTWORD;
1153 case AudioInputFlags::RAW:
1154 return AUDIO_INPUT_FLAG_RAW;
1155 case AudioInputFlags::SYNC:
1156 return AUDIO_INPUT_FLAG_SYNC;
1157 case AudioInputFlags::MMAP_NOIRQ:
1158 return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
1159 case AudioInputFlags::VOIP_TX:
1160 return AUDIO_INPUT_FLAG_VOIP_TX;
1161 case AudioInputFlags::HW_AV_SYNC:
1162 return AUDIO_INPUT_FLAG_HW_AV_SYNC;
1163 case AudioInputFlags::DIRECT:
1164 return AUDIO_INPUT_FLAG_DIRECT;
1165 case AudioInputFlags::ULTRASOUND:
1166 return AUDIO_INPUT_FLAG_ULTRASOUND;
Atneya Nair0f0a8032022-12-12 16:20:12 -0800[diff] [blame^]1167 case AudioInputFlags::HOTWORD_TAP:
1168 return AUDIO_INPUT_FLAG_HOTWORD_TAP;
1169 case AudioInputFlags::HW_LOOKBACK:
1170 return AUDIO_INPUT_FLAG_HW_LOOKBACK;
Shunkai Yao1b5fbab2022-12-14 04:27:19 +0000[diff] [blame]1171 }
1172 return unexpected(BAD_VALUE);
1173}
1174
1175ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
1176 audio_input_flags_t legacy) {
1177 switch (legacy) {
1178 case AUDIO_INPUT_FLAG_NONE:
1179 break; // shouldn't get here. must be listed -Werror,-Wswitch
1180 case AUDIO_INPUT_FLAG_FAST:
1181 return AudioInputFlags::FAST;
1182 case AUDIO_INPUT_FLAG_HW_HOTWORD:
1183 return AudioInputFlags::HW_HOTWORD;
1184 case AUDIO_INPUT_FLAG_RAW:
1185 return AudioInputFlags::RAW;
1186 case AUDIO_INPUT_FLAG_SYNC:
1187 return AudioInputFlags::SYNC;
1188 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
1189 return AudioInputFlags::MMAP_NOIRQ;
1190 case AUDIO_INPUT_FLAG_VOIP_TX:
1191 return AudioInputFlags::VOIP_TX;
1192 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
1193 return AudioInputFlags::HW_AV_SYNC;
1194 case AUDIO_INPUT_FLAG_DIRECT:
1195 return AudioInputFlags::DIRECT;
1196 case AUDIO_INPUT_FLAG_ULTRASOUND:
1197 return AudioInputFlags::ULTRASOUND;
Atneya Nair0f0a8032022-12-12 16:20:12 -0800[diff] [blame^]1198 case AUDIO_INPUT_FLAG_HOTWORD_TAP:
1199 return AudioInputFlags::HOTWORD_TAP;
1200 case AUDIO_INPUT_FLAG_HW_LOOKBACK:
1201 return AudioInputFlags::HW_LOOKBACK;
Shunkai Yao1b5fbab2022-12-14 04:27:19 +0000[diff] [blame]1202 }
1203 return unexpected(BAD_VALUE);
1204}
1205
1206ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
1207 AudioOutputFlags aidl) {
1208 switch (aidl) {
1209 case AudioOutputFlags::DIRECT:
1210 return AUDIO_OUTPUT_FLAG_DIRECT;
1211 case AudioOutputFlags::PRIMARY:
1212 return AUDIO_OUTPUT_FLAG_PRIMARY;
1213 case AudioOutputFlags::FAST:
1214 return AUDIO_OUTPUT_FLAG_FAST;
1215 case AudioOutputFlags::DEEP_BUFFER:
1216 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
1217 case AudioOutputFlags::COMPRESS_OFFLOAD:
1218 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1219 case AudioOutputFlags::NON_BLOCKING:
1220 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
1221 case AudioOutputFlags::HW_AV_SYNC:
1222 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
1223 case AudioOutputFlags::TTS:
1224 return AUDIO_OUTPUT_FLAG_TTS;
1225 case AudioOutputFlags::RAW:
1226 return AUDIO_OUTPUT_FLAG_RAW;
1227 case AudioOutputFlags::SYNC:
1228 return AUDIO_OUTPUT_FLAG_SYNC;
1229 case AudioOutputFlags::IEC958_NONAUDIO:
1230 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
1231 case AudioOutputFlags::DIRECT_PCM:
1232 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
1233 case AudioOutputFlags::MMAP_NOIRQ:
1234 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
1235 case AudioOutputFlags::VOIP_RX:
1236 return AUDIO_OUTPUT_FLAG_VOIP_RX;
1237 case AudioOutputFlags::INCALL_MUSIC:
1238 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
1239 case AudioOutputFlags::GAPLESS_OFFLOAD:
1240 return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
1241 case AudioOutputFlags::ULTRASOUND:
1242 return AUDIO_OUTPUT_FLAG_ULTRASOUND;
1243 case AudioOutputFlags::SPATIALIZER:
1244 return AUDIO_OUTPUT_FLAG_SPATIALIZER;
1245 case AudioOutputFlags::BIT_PERFECT:
1246 return AUDIO_OUTPUT_FLAG_BIT_PERFECT;
1247 }
1248 return unexpected(BAD_VALUE);
1249}
1250
1251ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
1252 audio_output_flags_t legacy) {
1253 switch (legacy) {
1254 case AUDIO_OUTPUT_FLAG_NONE:
1255 break; // shouldn't get here. must be listed -Werror,-Wswitch
1256 case AUDIO_OUTPUT_FLAG_DIRECT:
1257 return AudioOutputFlags::DIRECT;
1258 case AUDIO_OUTPUT_FLAG_PRIMARY:
1259 return AudioOutputFlags::PRIMARY;
1260 case AUDIO_OUTPUT_FLAG_FAST:
1261 return AudioOutputFlags::FAST;
1262 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
1263 return AudioOutputFlags::DEEP_BUFFER;
1264 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
1265 return AudioOutputFlags::COMPRESS_OFFLOAD;
1266 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
1267 return AudioOutputFlags::NON_BLOCKING;
1268 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
1269 return AudioOutputFlags::HW_AV_SYNC;
1270 case AUDIO_OUTPUT_FLAG_TTS:
1271 return AudioOutputFlags::TTS;
1272 case AUDIO_OUTPUT_FLAG_RAW:
1273 return AudioOutputFlags::RAW;
1274 case AUDIO_OUTPUT_FLAG_SYNC:
1275 return AudioOutputFlags::SYNC;
1276 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
1277 return AudioOutputFlags::IEC958_NONAUDIO;
1278 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
1279 return AudioOutputFlags::DIRECT_PCM;
1280 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
1281 return AudioOutputFlags::MMAP_NOIRQ;
1282 case AUDIO_OUTPUT_FLAG_VOIP_RX:
1283 return AudioOutputFlags::VOIP_RX;
1284 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
1285 return AudioOutputFlags::INCALL_MUSIC;
1286 case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
1287 return AudioOutputFlags::GAPLESS_OFFLOAD;
1288 case AUDIO_OUTPUT_FLAG_ULTRASOUND:
1289 return AudioOutputFlags::ULTRASOUND;
1290 case AUDIO_OUTPUT_FLAG_SPATIALIZER:
1291 return AudioOutputFlags::SPATIALIZER;
1292 case AUDIO_OUTPUT_FLAG_BIT_PERFECT:
1293 return AudioOutputFlags::BIT_PERFECT;
1294 }
1295 return unexpected(BAD_VALUE);
1296}
1297
1298ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
1299 int32_t aidl) {
1300 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1301
1302 LegacyMask converted = VALUE_OR_RETURN(
1303 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
1304 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
1305 indexToEnum_index<AudioInputFlags>,
1306 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
1307 return static_cast<audio_input_flags_t>(converted);
1308}
1309
1310ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
1311 audio_input_flags_t legacy) {
1312 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1313
1314 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1315 return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
1316 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
1317 indexToEnum_bitmask<audio_input_flags_t>,
1318 enumToMask_index<int32_t, AudioInputFlags>);
1319}
1320
1321ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
1322 int32_t aidl) {
1323 return convertBitmask<audio_output_flags_t,
1324 int32_t,
1325 audio_output_flags_t,
1326 AudioOutputFlags>(
1327 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
1328 indexToEnum_index<AudioOutputFlags>,
1329 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
1330}
1331
1332ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
1333 audio_output_flags_t legacy) {
1334 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
1335
1336 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1337 return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
1338 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
1339 indexToEnum_bitmask<audio_output_flags_t>,
1340 enumToMask_index<int32_t, AudioOutputFlags>);
1341}
1342
1343ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
1344 const AudioIoFlags& aidl, bool isInput) {
1345 audio_io_flags legacy;
1346 if (isInput) {
1347 legacy.input = VALUE_OR_RETURN(
1348 aidl2legacy_int32_t_audio_input_flags_t_mask(
1349 VALUE_OR_RETURN(UNION_GET(aidl, input))));
1350 } else {
1351 legacy.output = VALUE_OR_RETURN(
1352 aidl2legacy_int32_t_audio_output_flags_t_mask(
1353 VALUE_OR_RETURN(UNION_GET(aidl, output))));
1354 }
1355 return legacy;
1356}
1357
1358ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
1359 const audio_io_flags& legacy, bool isInput) {
1360 AudioIoFlags aidl;
1361 if (isInput) {
1362 UNION_SET(aidl, input,
1363 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
1364 } else {
1365 UNION_SET(aidl, output,
1366 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
1367 }
1368 return aidl;
1369}
1370
1371ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
1372 AudioStreamType aidl) {
1373 switch (aidl) {
1374 case AudioStreamType::INVALID:
1375 break; // return error
1376 case AudioStreamType::SYS_RESERVED_DEFAULT:
1377 return AUDIO_STREAM_DEFAULT;
1378 case AudioStreamType::VOICE_CALL:
1379 return AUDIO_STREAM_VOICE_CALL;
1380 case AudioStreamType::SYSTEM:
1381 return AUDIO_STREAM_SYSTEM;
1382 case AudioStreamType::RING:
1383 return AUDIO_STREAM_RING;
1384 case AudioStreamType::MUSIC:
1385 return AUDIO_STREAM_MUSIC;
1386 case AudioStreamType::ALARM:
1387 return AUDIO_STREAM_ALARM;
1388 case AudioStreamType::NOTIFICATION:
1389 return AUDIO_STREAM_NOTIFICATION;
1390 case AudioStreamType::BLUETOOTH_SCO:
1391 return AUDIO_STREAM_BLUETOOTH_SCO;
1392 case AudioStreamType::ENFORCED_AUDIBLE:
1393 return AUDIO_STREAM_ENFORCED_AUDIBLE;
1394 case AudioStreamType::DTMF:
1395 return AUDIO_STREAM_DTMF;
1396 case AudioStreamType::TTS:
1397 return AUDIO_STREAM_TTS;
1398 case AudioStreamType::ACCESSIBILITY:
1399 return AUDIO_STREAM_ACCESSIBILITY;
1400 case AudioStreamType::ASSISTANT:
1401 return AUDIO_STREAM_ASSISTANT;
1402 case AudioStreamType::SYS_RESERVED_REROUTING:
1403 return AUDIO_STREAM_REROUTING;
1404 case AudioStreamType::SYS_RESERVED_PATCH:
1405 return AUDIO_STREAM_PATCH;
1406 case AudioStreamType::CALL_ASSISTANT:
1407 return AUDIO_STREAM_CALL_ASSISTANT;
1408 }
1409 return unexpected(BAD_VALUE);
1410}
1411
1412ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
1413 audio_stream_type_t legacy) {
1414 switch (legacy) {
1415 case AUDIO_STREAM_DEFAULT:
1416 return AudioStreamType::SYS_RESERVED_DEFAULT;
1417 case AUDIO_STREAM_VOICE_CALL:
1418 return AudioStreamType::VOICE_CALL;
1419 case AUDIO_STREAM_SYSTEM:
1420 return AudioStreamType::SYSTEM;
1421 case AUDIO_STREAM_RING:
1422 return AudioStreamType::RING;
1423 case AUDIO_STREAM_MUSIC:
1424 return AudioStreamType::MUSIC;
1425 case AUDIO_STREAM_ALARM:
1426 return AudioStreamType::ALARM;
1427 case AUDIO_STREAM_NOTIFICATION:
1428 return AudioStreamType::NOTIFICATION;
1429 case AUDIO_STREAM_BLUETOOTH_SCO:
1430 return AudioStreamType::BLUETOOTH_SCO;
1431 case AUDIO_STREAM_ENFORCED_AUDIBLE:
1432 return AudioStreamType::ENFORCED_AUDIBLE;
1433 case AUDIO_STREAM_DTMF:
1434 return AudioStreamType::DTMF;
1435 case AUDIO_STREAM_TTS:
1436 return AudioStreamType::TTS;
1437 case AUDIO_STREAM_ACCESSIBILITY:
1438 return AudioStreamType::ACCESSIBILITY;
1439 case AUDIO_STREAM_ASSISTANT:
1440 return AudioStreamType::ASSISTANT;
1441 case AUDIO_STREAM_REROUTING:
1442 return AudioStreamType::SYS_RESERVED_REROUTING;
1443 case AUDIO_STREAM_PATCH:
1444 return AudioStreamType::SYS_RESERVED_PATCH;
1445 case AUDIO_STREAM_CALL_ASSISTANT:
1446 return AudioStreamType::CALL_ASSISTANT;
1447 }
1448 return unexpected(BAD_VALUE);
1449}
1450
1451ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
1452 AudioSource aidl) {
1453 switch (aidl) {
1454 case AudioSource::SYS_RESERVED_INVALID:
1455 return AUDIO_SOURCE_INVALID;
1456 case AudioSource::DEFAULT:
1457 return AUDIO_SOURCE_DEFAULT;
1458 case AudioSource::MIC:
1459 return AUDIO_SOURCE_MIC;
1460 case AudioSource::VOICE_UPLINK:
1461 return AUDIO_SOURCE_VOICE_UPLINK;
1462 case AudioSource::VOICE_DOWNLINK:
1463 return AUDIO_SOURCE_VOICE_DOWNLINK;
1464 case AudioSource::VOICE_CALL:
1465 return AUDIO_SOURCE_VOICE_CALL;
1466 case AudioSource::CAMCORDER:
1467 return AUDIO_SOURCE_CAMCORDER;
1468 case AudioSource::VOICE_RECOGNITION:
1469 return AUDIO_SOURCE_VOICE_RECOGNITION;
1470 case AudioSource::VOICE_COMMUNICATION:
1471 return AUDIO_SOURCE_VOICE_COMMUNICATION;
1472 case AudioSource::REMOTE_SUBMIX:
1473 return AUDIO_SOURCE_REMOTE_SUBMIX;
1474 case AudioSource::UNPROCESSED:
1475 return AUDIO_SOURCE_UNPROCESSED;
1476 case AudioSource::VOICE_PERFORMANCE:
1477 return AUDIO_SOURCE_VOICE_PERFORMANCE;
1478 case AudioSource::ULTRASOUND:
1479 return AUDIO_SOURCE_ULTRASOUND;
1480 case AudioSource::ECHO_REFERENCE:
1481 return AUDIO_SOURCE_ECHO_REFERENCE;
1482 case AudioSource::FM_TUNER:
1483 return AUDIO_SOURCE_FM_TUNER;
1484 case AudioSource::HOTWORD:
1485 return AUDIO_SOURCE_HOTWORD;
1486 }
1487 return unexpected(BAD_VALUE);
1488}
1489
1490ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
1491 audio_source_t legacy) {
1492 switch (legacy) {
1493 case AUDIO_SOURCE_INVALID:
1494 return AudioSource::SYS_RESERVED_INVALID;
1495 case AUDIO_SOURCE_DEFAULT:
1496 return AudioSource::DEFAULT;
1497 case AUDIO_SOURCE_MIC:
1498 return AudioSource::MIC;
1499 case AUDIO_SOURCE_VOICE_UPLINK:
1500 return AudioSource::VOICE_UPLINK;
1501 case AUDIO_SOURCE_VOICE_DOWNLINK:
1502 return AudioSource::VOICE_DOWNLINK;
1503 case AUDIO_SOURCE_VOICE_CALL:
1504 return AudioSource::VOICE_CALL;
1505 case AUDIO_SOURCE_CAMCORDER:
1506 return AudioSource::CAMCORDER;
1507 case AUDIO_SOURCE_VOICE_RECOGNITION:
1508 return AudioSource::VOICE_RECOGNITION;
1509 case AUDIO_SOURCE_VOICE_COMMUNICATION:
1510 return AudioSource::VOICE_COMMUNICATION;
1511 case AUDIO_SOURCE_REMOTE_SUBMIX:
1512 return AudioSource::REMOTE_SUBMIX;
1513 case AUDIO_SOURCE_UNPROCESSED:
1514 return AudioSource::UNPROCESSED;
1515 case AUDIO_SOURCE_VOICE_PERFORMANCE:
1516 return AudioSource::VOICE_PERFORMANCE;
1517 case AUDIO_SOURCE_ULTRASOUND:
1518 return AudioSource::ULTRASOUND;
1519 case AUDIO_SOURCE_ECHO_REFERENCE:
1520 return AudioSource::ECHO_REFERENCE;
1521 case AUDIO_SOURCE_FM_TUNER:
1522 return AudioSource::FM_TUNER;
1523 case AUDIO_SOURCE_HOTWORD:
1524 return AudioSource::HOTWORD;
1525 }
1526 return unexpected(BAD_VALUE);
1527}
1528
1529ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
1530 return convertReinterpret<audio_session_t>(aidl);
1531}
1532
1533ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
1534 return convertReinterpret<int32_t>(legacy);
1535}
1536
1537ConversionResult<audio_content_type_t>
1538aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
1539 switch (aidl) {
1540 case AudioContentType::UNKNOWN:
1541 return AUDIO_CONTENT_TYPE_UNKNOWN;
1542 case AudioContentType::SPEECH:
1543 return AUDIO_CONTENT_TYPE_SPEECH;
1544 case AudioContentType::MUSIC:
1545 return AUDIO_CONTENT_TYPE_MUSIC;
1546 case AudioContentType::MOVIE:
1547 return AUDIO_CONTENT_TYPE_MOVIE;
1548 case AudioContentType::SONIFICATION:
1549 return AUDIO_CONTENT_TYPE_SONIFICATION;
1550 case AudioContentType::ULTRASOUND:
1551 return AUDIO_CONTENT_TYPE_ULTRASOUND;
1552 }
1553 return unexpected(BAD_VALUE);
1554}
1555
1556ConversionResult<AudioContentType>
1557legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
1558 switch (legacy) {
1559 case AUDIO_CONTENT_TYPE_UNKNOWN:
1560 return AudioContentType::UNKNOWN;
1561 case AUDIO_CONTENT_TYPE_SPEECH:
1562 return AudioContentType::SPEECH;
1563 case AUDIO_CONTENT_TYPE_MUSIC:
1564 return AudioContentType::MUSIC;
1565 case AUDIO_CONTENT_TYPE_MOVIE:
1566 return AudioContentType::MOVIE;
1567 case AUDIO_CONTENT_TYPE_SONIFICATION:
1568 return AudioContentType::SONIFICATION;
1569 case AUDIO_CONTENT_TYPE_ULTRASOUND:
1570 return AudioContentType::ULTRASOUND;
1571 }
1572 return unexpected(BAD_VALUE);
1573}
1574
1575ConversionResult<audio_usage_t>
1576aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
1577 switch (aidl) {
1578 case AudioUsage::INVALID:
1579 break; // return error
1580 case AudioUsage::UNKNOWN:
1581 return AUDIO_USAGE_UNKNOWN;
1582 case AudioUsage::MEDIA:
1583 return AUDIO_USAGE_MEDIA;
1584 case AudioUsage::VOICE_COMMUNICATION:
1585 return AUDIO_USAGE_VOICE_COMMUNICATION;
1586 case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
1587 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1588 case AudioUsage::ALARM:
1589 return AUDIO_USAGE_ALARM;
1590 case AudioUsage::NOTIFICATION:
1591 return AUDIO_USAGE_NOTIFICATION;
1592 case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
1593 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1594 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
1595 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
1596 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
1597 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
1598 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
1599 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
1600 case AudioUsage::NOTIFICATION_EVENT:
1601 return AUDIO_USAGE_NOTIFICATION_EVENT;
1602 case AudioUsage::ASSISTANCE_ACCESSIBILITY:
1603 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1604 case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
1605 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
1606 case AudioUsage::ASSISTANCE_SONIFICATION:
1607 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1608 case AudioUsage::GAME:
1609 return AUDIO_USAGE_GAME;
1610 case AudioUsage::VIRTUAL_SOURCE:
1611 return AUDIO_USAGE_VIRTUAL_SOURCE;
1612 case AudioUsage::ASSISTANT:
1613 return AUDIO_USAGE_ASSISTANT;
1614 case AudioUsage::CALL_ASSISTANT:
1615 return AUDIO_USAGE_CALL_ASSISTANT;
1616 case AudioUsage::EMERGENCY:
1617 return AUDIO_USAGE_EMERGENCY;
1618 case AudioUsage::SAFETY:
1619 return AUDIO_USAGE_SAFETY;
1620 case AudioUsage::VEHICLE_STATUS:
1621 return AUDIO_USAGE_VEHICLE_STATUS;
1622 case AudioUsage::ANNOUNCEMENT:
1623 return AUDIO_USAGE_ANNOUNCEMENT;
1624 }
1625 return unexpected(BAD_VALUE);
1626}
1627
1628ConversionResult<AudioUsage>
1629legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
1630 switch (legacy) {
1631 case AUDIO_USAGE_UNKNOWN:
1632 return AudioUsage::UNKNOWN;
1633 case AUDIO_USAGE_MEDIA:
1634 return AudioUsage::MEDIA;
1635 case AUDIO_USAGE_VOICE_COMMUNICATION:
1636 return AudioUsage::VOICE_COMMUNICATION;
1637 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
1638 return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
1639 case AUDIO_USAGE_ALARM:
1640 return AudioUsage::ALARM;
1641 case AUDIO_USAGE_NOTIFICATION:
1642 return AudioUsage::NOTIFICATION;
1643 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
1644 return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
1645 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
1646 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
1647 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
1648 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
1649 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
1650 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
1651 case AUDIO_USAGE_NOTIFICATION_EVENT:
1652 return AudioUsage::NOTIFICATION_EVENT;
1653 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
1654 return AudioUsage::ASSISTANCE_ACCESSIBILITY;
1655 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
1656 return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
1657 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
1658 return AudioUsage::ASSISTANCE_SONIFICATION;
1659 case AUDIO_USAGE_GAME:
1660 return AudioUsage::GAME;
1661 case AUDIO_USAGE_VIRTUAL_SOURCE:
1662 return AudioUsage::VIRTUAL_SOURCE;
1663 case AUDIO_USAGE_ASSISTANT:
1664 return AudioUsage::ASSISTANT;
1665 case AUDIO_USAGE_CALL_ASSISTANT:
1666 return AudioUsage::CALL_ASSISTANT;
1667 case AUDIO_USAGE_EMERGENCY:
1668 return AudioUsage::EMERGENCY;
1669 case AUDIO_USAGE_SAFETY:
1670 return AudioUsage::SAFETY;
1671 case AUDIO_USAGE_VEHICLE_STATUS:
1672 return AudioUsage::VEHICLE_STATUS;
1673 case AUDIO_USAGE_ANNOUNCEMENT:
1674 return AudioUsage::ANNOUNCEMENT;
1675 }
1676 return unexpected(BAD_VALUE);
1677}
1678
1679
1680ConversionResult<audio_encapsulation_mode_t>
1681aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
1682 switch (aidl) {
1683 case AudioEncapsulationMode::INVALID:
1684 break; // return error
1685 case AudioEncapsulationMode::NONE:
1686 return AUDIO_ENCAPSULATION_MODE_NONE;
1687 case AudioEncapsulationMode::ELEMENTARY_STREAM:
1688 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
1689 case AudioEncapsulationMode::HANDLE:
1690 return AUDIO_ENCAPSULATION_MODE_HANDLE;
1691 }
1692 return unexpected(BAD_VALUE);
1693}
1694
1695ConversionResult<AudioEncapsulationMode>
1696legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
1697 switch (legacy) {
1698 case AUDIO_ENCAPSULATION_MODE_NONE:
1699 return AudioEncapsulationMode::NONE;
1700 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
1701 return AudioEncapsulationMode::ELEMENTARY_STREAM;
1702 case AUDIO_ENCAPSULATION_MODE_HANDLE:
1703 return AudioEncapsulationMode::HANDLE;
1704 }
1705 return unexpected(BAD_VALUE);
1706}
1707
1708ConversionResult<audio_offload_info_t>
1709aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
1710 audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
1711 audio_config_base_t base = VALUE_OR_RETURN(
1712 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
1713 legacy.sample_rate = base.sample_rate;
1714 legacy.channel_mask = base.channel_mask;
1715 legacy.format = base.format;
1716 legacy.stream_type = VALUE_OR_RETURN(
1717 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
1718 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));
1719 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
1720 legacy.has_video = aidl.hasVideo;
1721 legacy.is_streaming = aidl.isStreaming;
1722 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
1723 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
1724 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1725 legacy.encapsulation_mode = VALUE_OR_RETURN(
1726 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
1727 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
1728 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
1729 return legacy;
1730}
1731
1732ConversionResult<AudioOffloadInfo>
1733legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
1734 AudioOffloadInfo aidl;
1735 // Version 0.1 fields.
1736 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
1737 return unexpected(BAD_VALUE);
1738 }
1739 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1740 .channel_mask = legacy.channel_mask, .format = legacy.format };
1741 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
1742 base, false /*isInput*/));
1743 aidl.streamType = VALUE_OR_RETURN(
1744 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
1745 aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
1746 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
1747 aidl.hasVideo = legacy.has_video;
1748 aidl.isStreaming = legacy.is_streaming;
1749 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
1750 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
1751 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1752
1753 // Version 0.2 fields.
1754 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
1755 if (legacy.size <
1756 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
1757 return unexpected(BAD_VALUE);
1758 }
1759 aidl.encapsulationMode = VALUE_OR_RETURN(
1760 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
1761 legacy.encapsulation_mode));
1762 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
1763 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
1764 }
1765 return aidl;
1766}
1767
1768ConversionResult<audio_config_t>
1769aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
1770 const audio_config_base_t legacyBase = VALUE_OR_RETURN(
1771 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
1772 audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
1773 legacy.sample_rate = legacyBase.sample_rate;
1774 legacy.channel_mask = legacyBase.channel_mask;
1775 legacy.format = legacyBase.format;
1776 legacy.offload_info = VALUE_OR_RETURN(
1777 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
1778 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
1779 return legacy;
1780}
1781
1782ConversionResult<AudioConfig>
1783legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
1784 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1785 .channel_mask = legacy.channel_mask, .format = legacy.format };
1786 AudioConfig aidl;
1787 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
1788 aidl.offloadInfo = VALUE_OR_RETURN(
1789 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
1790 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
1791 return aidl;
1792}
1793
1794ConversionResult<audio_config_base_t>
1795aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
1796 audio_config_base_t legacy;
1797 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
1798 legacy.channel_mask = VALUE_OR_RETURN(
1799 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
1800 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
1801 return legacy;
1802}
1803
1804ConversionResult<AudioConfigBase>
1805legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
1806 AudioConfigBase aidl;
1807 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1808 aidl.channelMask = VALUE_OR_RETURN(
1809 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1810 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
1811 return aidl;
1812}
1813
1814ConversionResult<audio_uuid_t>
1815aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
1816 audio_uuid_t legacy;
1817 legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
1818 legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
1819 legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
1820 legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
1821 if (aidl.node.size() != std::size(legacy.node)) {
1822 return unexpected(BAD_VALUE);
1823 }
1824 std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
1825 return legacy;
1826}
1827
1828ConversionResult<AudioUuid>
1829legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
1830 AudioUuid aidl;
1831 aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
1832 aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
1833 aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
1834 aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
1835 std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
1836 return aidl;
1837}
1838
1839ConversionResult<audio_encapsulation_metadata_type_t>
1840aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
1841 AudioEncapsulationMetadataType aidl) {
1842 switch (aidl) {
1843 case AudioEncapsulationMetadataType::NONE:
1844 return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
1845 case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
1846 return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
1847 case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
1848 return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
1849 }
1850 return unexpected(BAD_VALUE);
1851}
1852
1853ConversionResult<AudioEncapsulationMetadataType>
1854legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
1855 audio_encapsulation_metadata_type_t legacy) {
1856 switch (legacy) {
1857 case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
1858 return AudioEncapsulationMetadataType::NONE;
1859 case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
1860 return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
1861 case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
1862 return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
1863 }
1864 return unexpected(BAD_VALUE);
1865}
1866
1867ConversionResult<uint32_t>
1868aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
1869 return convertBitmask<uint32_t,
1870 int32_t,
1871 audio_encapsulation_mode_t,
1872 AudioEncapsulationMode>(
1873 aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
1874 indexToEnum_index<AudioEncapsulationMode>,
1875 enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
1876}
1877
1878ConversionResult<int32_t>
1879legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
1880 return convertBitmask<int32_t,
1881 uint32_t,
1882 AudioEncapsulationMode,
1883 audio_encapsulation_mode_t>(
1884 legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
1885 indexToEnum_index<audio_encapsulation_mode_t>,
1886 enumToMask_index<int32_t, AudioEncapsulationMode>);
1887}
1888
1889ConversionResult<uint32_t>
1890aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
1891 return convertBitmask<uint32_t,
1892 int32_t,
1893 audio_encapsulation_metadata_type_t,
1894 AudioEncapsulationMetadataType>(
1895 aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
1896 indexToEnum_index<AudioEncapsulationMetadataType>,
1897 enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
1898}
1899
1900ConversionResult<int32_t>
1901legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
1902 return convertBitmask<int32_t,
1903 uint32_t,
1904 AudioEncapsulationMetadataType,
1905 audio_encapsulation_metadata_type_t>(
1906 legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
1907 indexToEnum_index<audio_encapsulation_metadata_type_t>,
1908 enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
1909}
1910
1911ConversionResult<audio_profile>
1912aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
1913 audio_profile legacy;
1914 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
1915
1916 if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
1917 return unexpected(BAD_VALUE);
1918 }
1919 RETURN_IF_ERROR(
1920 convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
1921 convertIntegral<int32_t, unsigned int>));
1922 legacy.num_sample_rates = aidl.sampleRates.size();
1923
1924 if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
1925 return unexpected(BAD_VALUE);
1926 }
1927 RETURN_IF_ERROR(
1928 convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
1929 [isInput](const AudioChannelLayout& l) {
1930 return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
1931 }));
1932 legacy.num_channel_masks = aidl.channelMasks.size();
1933
1934 legacy.encapsulation_type = VALUE_OR_RETURN(
1935 aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
1936 return legacy;
1937}
1938
1939ConversionResult<AudioProfile>
1940legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
1941 AudioProfile aidl;
1942 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
1943
1944 if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
1945 return unexpected(BAD_VALUE);
1946 }
1947 RETURN_IF_ERROR(
1948 convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
1949 std::back_inserter(aidl.sampleRates),
1950 convertIntegral<unsigned int, int32_t>));
1951
1952 if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
1953 return unexpected(BAD_VALUE);
1954 }
1955 RETURN_IF_ERROR(
1956 convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
1957 std::back_inserter(aidl.channelMasks),
1958 [isInput](audio_channel_mask_t m) {
1959 return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
1960 }));
1961
1962 aidl.encapsulationType = VALUE_OR_RETURN(
1963 legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
1964 legacy.encapsulation_type));
1965 return aidl;
1966}
1967
1968ConversionResult<audio_gain>
1969aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
1970 audio_gain legacy;
1971 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
1972 legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
1973 aidl.channelMask, isInput));
1974 legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
1975 legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
1976 legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
1977 legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
1978 legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
1979 legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
1980 return legacy;
1981}
1982
1983ConversionResult<AudioGain>
1984legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
1985 AudioGain aidl;
1986 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
1987 aidl.channelMask = VALUE_OR_RETURN(
1988 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1989 aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
1990 aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
1991 aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
1992 aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
1993 aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
1994 aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
1995 return aidl;
1996}
1997
1998ConversionResult<audio_mode_t>
1999aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
2000 switch (aidl) {
2001 case AudioMode::SYS_RESERVED_INVALID:
2002 return AUDIO_MODE_INVALID;
2003 case AudioMode::SYS_RESERVED_CURRENT:
2004 return AUDIO_MODE_CURRENT;
2005 case AudioMode::NORMAL:
2006 return AUDIO_MODE_NORMAL;
2007 case AudioMode::RINGTONE:
2008 return AUDIO_MODE_RINGTONE;
2009 case AudioMode::IN_CALL:
2010 return AUDIO_MODE_IN_CALL;
2011 case AudioMode::IN_COMMUNICATION:
2012 return AUDIO_MODE_IN_COMMUNICATION;
2013 case AudioMode::CALL_SCREEN:
2014 return AUDIO_MODE_CALL_SCREEN;
2015 case AudioMode::SYS_RESERVED_CALL_REDIRECT:
2016 return AUDIO_MODE_CALL_REDIRECT;
2017 case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
2018 return AUDIO_MODE_COMMUNICATION_REDIRECT;
2019 }
2020 return unexpected(BAD_VALUE);
2021}
2022
2023ConversionResult<AudioMode>
2024legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
2025 switch (legacy) {
2026 case AUDIO_MODE_INVALID:
2027 return AudioMode::SYS_RESERVED_INVALID;
2028 case AUDIO_MODE_CURRENT:
2029 return AudioMode::SYS_RESERVED_CURRENT;
2030 case AUDIO_MODE_NORMAL:
2031 return AudioMode::NORMAL;
2032 case AUDIO_MODE_RINGTONE:
2033 return AudioMode::RINGTONE;
2034 case AUDIO_MODE_IN_CALL:
2035 return AudioMode::IN_CALL;
2036 case AUDIO_MODE_IN_COMMUNICATION:
2037 return AudioMode::IN_COMMUNICATION;
2038 case AUDIO_MODE_CALL_SCREEN:
2039 return AudioMode::CALL_SCREEN;
2040 case AUDIO_MODE_CALL_REDIRECT:
2041 return AudioMode::SYS_RESERVED_CALL_REDIRECT;
2042 case AUDIO_MODE_COMMUNICATION_REDIRECT:
2043 return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
2044 case AUDIO_MODE_CNT:
2045 break;
2046 }
2047 return unexpected(BAD_VALUE);
2048}
2049
2050ConversionResult<audio_standard_t>
2051aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
2052 switch (aidl) {
2053 case AudioStandard::NONE:
2054 return AUDIO_STANDARD_NONE;
2055 case AudioStandard::EDID:
2056 return AUDIO_STANDARD_EDID;
2057 }
2058 return unexpected(BAD_VALUE);
2059}
2060
2061ConversionResult<AudioStandard>
2062legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
2063 switch (legacy) {
2064 case AUDIO_STANDARD_NONE:
2065 return AudioStandard::NONE;
2066 case AUDIO_STANDARD_EDID:
2067 return AudioStandard::EDID;
2068 }
2069 return unexpected(BAD_VALUE);
2070}
2071
2072ConversionResult<audio_extra_audio_descriptor>
2073aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
2074 const ExtraAudioDescriptor& aidl) {
2075 audio_extra_audio_descriptor legacy;
2076 legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
2077 if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2078 return unexpected(BAD_VALUE);
2079 }
2080 legacy.descriptor_length = aidl.audioDescriptor.size();
2081 std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
2082 std::begin(legacy.descriptor));
2083 legacy.encapsulation_type =
2084 VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2085 aidl.encapsulationType));
2086 return legacy;
2087}
2088
2089ConversionResult<ExtraAudioDescriptor>
2090legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
2091 const audio_extra_audio_descriptor& legacy) {
2092 ExtraAudioDescriptor aidl;
2093 aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
2094 if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2095 return unexpected(BAD_VALUE);
2096 }
2097 aidl.audioDescriptor.resize(legacy.descriptor_length);
2098 std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
2099 aidl.audioDescriptor.begin());
2100 aidl.encapsulationType =
2101 VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2102 legacy.encapsulation_type));
2103 return aidl;
2104}
2105
2106ConversionResult<audio_encapsulation_type_t>
2107aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2108 const AudioEncapsulationType& aidl) {
2109 switch (aidl) {
2110 case AudioEncapsulationType::NONE:
2111 return AUDIO_ENCAPSULATION_TYPE_NONE;
2112 case AudioEncapsulationType::IEC61937:
2113 return AUDIO_ENCAPSULATION_TYPE_IEC61937;
2114 case AudioEncapsulationType::PCM:
2115 return AUDIO_ENCAPSULATION_TYPE_PCM;
2116 }
2117 return unexpected(BAD_VALUE);
2118}
2119
2120ConversionResult<AudioEncapsulationType>
2121legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2122 const audio_encapsulation_type_t & legacy) {
2123 switch (legacy) {
2124 case AUDIO_ENCAPSULATION_TYPE_NONE:
2125 return AudioEncapsulationType::NONE;
2126 case AUDIO_ENCAPSULATION_TYPE_IEC61937:
2127 return AudioEncapsulationType::IEC61937;
2128 case AUDIO_ENCAPSULATION_TYPE_PCM:
2129 return AudioEncapsulationType::PCM;
2130 }
2131 return unexpected(BAD_VALUE);
2132}
2133
2134} // namespace android
2135
2136#if defined(BACKEND_NDK)
2137} // aidl
Atneya Nair0f0a8032022-12-12 16:20:12 -0800[diff] [blame^]2138#endif