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