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