Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_av / 72cd068f6f5a21453c5f5ed6979ba99178346811 / . / media / audioaidlconversion / AidlConversionCppNdk.cpp
blob: 8704314f9b784fe3b9a9e9d8cb0525ecf940327c [file] [log] [blame]
Shunkai Yao4b574cf2022-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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]32// AIDL CPP/NDK backend to legacy audio data structure conversion utilities.
Shunkai Yao4b574cf2022-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 Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]56using media::audio::common::AudioDualMonoMode;
Shunkai Yao4b574cf2022-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 Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]67using media::audio::common::AudioLatencyMode;
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]68using media::audio::common::AudioMode;
69using media::audio::common::AudioOffloadInfo;
70using media::audio::common::AudioOutputFlags;
Mikhail Naganovb1a075b2022-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 Yao4b574cf2022-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 Yao4b574cf2022-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 Yao4b574cf2022-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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]857 __builtin_popcount(bits) != 0 &&
858 __builtin_popcount(bits) <= (int)AUDIO_CHANNEL_COUNT_MAX) {
Shunkai Yao4b574cf2022-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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1134 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<int>(aidl.rampDurationMs));
Shunkai Yao4b574cf2022-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;
1178 }
1179 return unexpected(BAD_VALUE);
1180}
1181
1182ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
1183 audio_input_flags_t legacy) {
1184 switch (legacy) {
1185 case AUDIO_INPUT_FLAG_NONE:
1186 break; // shouldn't get here. must be listed -Werror,-Wswitch
1187 case AUDIO_INPUT_FLAG_FAST:
1188 return AudioInputFlags::FAST;
1189 case AUDIO_INPUT_FLAG_HW_HOTWORD:
1190 return AudioInputFlags::HW_HOTWORD;
1191 case AUDIO_INPUT_FLAG_RAW:
1192 return AudioInputFlags::RAW;
1193 case AUDIO_INPUT_FLAG_SYNC:
1194 return AudioInputFlags::SYNC;
1195 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
1196 return AudioInputFlags::MMAP_NOIRQ;
1197 case AUDIO_INPUT_FLAG_VOIP_TX:
1198 return AudioInputFlags::VOIP_TX;
1199 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
1200 return AudioInputFlags::HW_AV_SYNC;
1201 case AUDIO_INPUT_FLAG_DIRECT:
1202 return AudioInputFlags::DIRECT;
1203 case AUDIO_INPUT_FLAG_ULTRASOUND:
1204 return AudioInputFlags::ULTRASOUND;
1205 }
1206 return unexpected(BAD_VALUE);
1207}
1208
1209ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
1210 AudioOutputFlags aidl) {
1211 switch (aidl) {
1212 case AudioOutputFlags::DIRECT:
1213 return AUDIO_OUTPUT_FLAG_DIRECT;
1214 case AudioOutputFlags::PRIMARY:
1215 return AUDIO_OUTPUT_FLAG_PRIMARY;
1216 case AudioOutputFlags::FAST:
1217 return AUDIO_OUTPUT_FLAG_FAST;
1218 case AudioOutputFlags::DEEP_BUFFER:
1219 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
1220 case AudioOutputFlags::COMPRESS_OFFLOAD:
1221 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1222 case AudioOutputFlags::NON_BLOCKING:
1223 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
1224 case AudioOutputFlags::HW_AV_SYNC:
1225 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
1226 case AudioOutputFlags::TTS:
1227 return AUDIO_OUTPUT_FLAG_TTS;
1228 case AudioOutputFlags::RAW:
1229 return AUDIO_OUTPUT_FLAG_RAW;
1230 case AudioOutputFlags::SYNC:
1231 return AUDIO_OUTPUT_FLAG_SYNC;
1232 case AudioOutputFlags::IEC958_NONAUDIO:
1233 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
1234 case AudioOutputFlags::DIRECT_PCM:
1235 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
1236 case AudioOutputFlags::MMAP_NOIRQ:
1237 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
1238 case AudioOutputFlags::VOIP_RX:
1239 return AUDIO_OUTPUT_FLAG_VOIP_RX;
1240 case AudioOutputFlags::INCALL_MUSIC:
1241 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
1242 case AudioOutputFlags::GAPLESS_OFFLOAD:
1243 return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
1244 case AudioOutputFlags::ULTRASOUND:
1245 return AUDIO_OUTPUT_FLAG_ULTRASOUND;
1246 case AudioOutputFlags::SPATIALIZER:
1247 return AUDIO_OUTPUT_FLAG_SPATIALIZER;
1248 case AudioOutputFlags::BIT_PERFECT:
1249 return AUDIO_OUTPUT_FLAG_BIT_PERFECT;
1250 }
1251 return unexpected(BAD_VALUE);
1252}
1253
1254ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
1255 audio_output_flags_t legacy) {
1256 switch (legacy) {
1257 case AUDIO_OUTPUT_FLAG_NONE:
1258 break; // shouldn't get here. must be listed -Werror,-Wswitch
1259 case AUDIO_OUTPUT_FLAG_DIRECT:
1260 return AudioOutputFlags::DIRECT;
1261 case AUDIO_OUTPUT_FLAG_PRIMARY:
1262 return AudioOutputFlags::PRIMARY;
1263 case AUDIO_OUTPUT_FLAG_FAST:
1264 return AudioOutputFlags::FAST;
1265 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
1266 return AudioOutputFlags::DEEP_BUFFER;
1267 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
1268 return AudioOutputFlags::COMPRESS_OFFLOAD;
1269 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
1270 return AudioOutputFlags::NON_BLOCKING;
1271 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
1272 return AudioOutputFlags::HW_AV_SYNC;
1273 case AUDIO_OUTPUT_FLAG_TTS:
1274 return AudioOutputFlags::TTS;
1275 case AUDIO_OUTPUT_FLAG_RAW:
1276 return AudioOutputFlags::RAW;
1277 case AUDIO_OUTPUT_FLAG_SYNC:
1278 return AudioOutputFlags::SYNC;
1279 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
1280 return AudioOutputFlags::IEC958_NONAUDIO;
1281 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
1282 return AudioOutputFlags::DIRECT_PCM;
1283 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
1284 return AudioOutputFlags::MMAP_NOIRQ;
1285 case AUDIO_OUTPUT_FLAG_VOIP_RX:
1286 return AudioOutputFlags::VOIP_RX;
1287 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
1288 return AudioOutputFlags::INCALL_MUSIC;
1289 case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
1290 return AudioOutputFlags::GAPLESS_OFFLOAD;
1291 case AUDIO_OUTPUT_FLAG_ULTRASOUND:
1292 return AudioOutputFlags::ULTRASOUND;
1293 case AUDIO_OUTPUT_FLAG_SPATIALIZER:
1294 return AudioOutputFlags::SPATIALIZER;
1295 case AUDIO_OUTPUT_FLAG_BIT_PERFECT:
1296 return AudioOutputFlags::BIT_PERFECT;
1297 }
1298 return unexpected(BAD_VALUE);
1299}
1300
1301ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
1302 int32_t aidl) {
1303 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1304
1305 LegacyMask converted = VALUE_OR_RETURN(
1306 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
1307 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
1308 indexToEnum_index<AudioInputFlags>,
1309 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
1310 return static_cast<audio_input_flags_t>(converted);
1311}
1312
1313ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
1314 audio_input_flags_t legacy) {
1315 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1316
1317 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1318 return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
1319 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
1320 indexToEnum_bitmask<audio_input_flags_t>,
1321 enumToMask_index<int32_t, AudioInputFlags>);
1322}
1323
1324ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
1325 int32_t aidl) {
1326 return convertBitmask<audio_output_flags_t,
1327 int32_t,
1328 audio_output_flags_t,
1329 AudioOutputFlags>(
1330 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
1331 indexToEnum_index<AudioOutputFlags>,
1332 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
1333}
1334
1335ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
1336 audio_output_flags_t legacy) {
1337 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
1338
1339 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1340 return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
1341 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
1342 indexToEnum_bitmask<audio_output_flags_t>,
1343 enumToMask_index<int32_t, AudioOutputFlags>);
1344}
1345
1346ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
1347 const AudioIoFlags& aidl, bool isInput) {
1348 audio_io_flags legacy;
1349 if (isInput) {
1350 legacy.input = VALUE_OR_RETURN(
1351 aidl2legacy_int32_t_audio_input_flags_t_mask(
1352 VALUE_OR_RETURN(UNION_GET(aidl, input))));
1353 } else {
1354 legacy.output = VALUE_OR_RETURN(
1355 aidl2legacy_int32_t_audio_output_flags_t_mask(
1356 VALUE_OR_RETURN(UNION_GET(aidl, output))));
1357 }
1358 return legacy;
1359}
1360
1361ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
1362 const audio_io_flags& legacy, bool isInput) {
1363 AudioIoFlags aidl;
1364 if (isInput) {
1365 UNION_SET(aidl, input,
1366 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
1367 } else {
1368 UNION_SET(aidl, output,
1369 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
1370 }
1371 return aidl;
1372}
1373
1374ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
1375 AudioStreamType aidl) {
1376 switch (aidl) {
1377 case AudioStreamType::INVALID:
1378 break; // return error
1379 case AudioStreamType::SYS_RESERVED_DEFAULT:
1380 return AUDIO_STREAM_DEFAULT;
1381 case AudioStreamType::VOICE_CALL:
1382 return AUDIO_STREAM_VOICE_CALL;
1383 case AudioStreamType::SYSTEM:
1384 return AUDIO_STREAM_SYSTEM;
1385 case AudioStreamType::RING:
1386 return AUDIO_STREAM_RING;
1387 case AudioStreamType::MUSIC:
1388 return AUDIO_STREAM_MUSIC;
1389 case AudioStreamType::ALARM:
1390 return AUDIO_STREAM_ALARM;
1391 case AudioStreamType::NOTIFICATION:
1392 return AUDIO_STREAM_NOTIFICATION;
1393 case AudioStreamType::BLUETOOTH_SCO:
1394 return AUDIO_STREAM_BLUETOOTH_SCO;
1395 case AudioStreamType::ENFORCED_AUDIBLE:
1396 return AUDIO_STREAM_ENFORCED_AUDIBLE;
1397 case AudioStreamType::DTMF:
1398 return AUDIO_STREAM_DTMF;
1399 case AudioStreamType::TTS:
1400 return AUDIO_STREAM_TTS;
1401 case AudioStreamType::ACCESSIBILITY:
1402 return AUDIO_STREAM_ACCESSIBILITY;
1403 case AudioStreamType::ASSISTANT:
1404 return AUDIO_STREAM_ASSISTANT;
1405 case AudioStreamType::SYS_RESERVED_REROUTING:
1406 return AUDIO_STREAM_REROUTING;
1407 case AudioStreamType::SYS_RESERVED_PATCH:
1408 return AUDIO_STREAM_PATCH;
1409 case AudioStreamType::CALL_ASSISTANT:
1410 return AUDIO_STREAM_CALL_ASSISTANT;
1411 }
1412 return unexpected(BAD_VALUE);
1413}
1414
1415ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
1416 audio_stream_type_t legacy) {
1417 switch (legacy) {
1418 case AUDIO_STREAM_DEFAULT:
1419 return AudioStreamType::SYS_RESERVED_DEFAULT;
1420 case AUDIO_STREAM_VOICE_CALL:
1421 return AudioStreamType::VOICE_CALL;
1422 case AUDIO_STREAM_SYSTEM:
1423 return AudioStreamType::SYSTEM;
1424 case AUDIO_STREAM_RING:
1425 return AudioStreamType::RING;
1426 case AUDIO_STREAM_MUSIC:
1427 return AudioStreamType::MUSIC;
1428 case AUDIO_STREAM_ALARM:
1429 return AudioStreamType::ALARM;
1430 case AUDIO_STREAM_NOTIFICATION:
1431 return AudioStreamType::NOTIFICATION;
1432 case AUDIO_STREAM_BLUETOOTH_SCO:
1433 return AudioStreamType::BLUETOOTH_SCO;
1434 case AUDIO_STREAM_ENFORCED_AUDIBLE:
1435 return AudioStreamType::ENFORCED_AUDIBLE;
1436 case AUDIO_STREAM_DTMF:
1437 return AudioStreamType::DTMF;
1438 case AUDIO_STREAM_TTS:
1439 return AudioStreamType::TTS;
1440 case AUDIO_STREAM_ACCESSIBILITY:
1441 return AudioStreamType::ACCESSIBILITY;
1442 case AUDIO_STREAM_ASSISTANT:
1443 return AudioStreamType::ASSISTANT;
1444 case AUDIO_STREAM_REROUTING:
1445 return AudioStreamType::SYS_RESERVED_REROUTING;
1446 case AUDIO_STREAM_PATCH:
1447 return AudioStreamType::SYS_RESERVED_PATCH;
1448 case AUDIO_STREAM_CALL_ASSISTANT:
1449 return AudioStreamType::CALL_ASSISTANT;
1450 }
1451 return unexpected(BAD_VALUE);
1452}
1453
1454ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
1455 AudioSource aidl) {
1456 switch (aidl) {
1457 case AudioSource::SYS_RESERVED_INVALID:
1458 return AUDIO_SOURCE_INVALID;
1459 case AudioSource::DEFAULT:
1460 return AUDIO_SOURCE_DEFAULT;
1461 case AudioSource::MIC:
1462 return AUDIO_SOURCE_MIC;
1463 case AudioSource::VOICE_UPLINK:
1464 return AUDIO_SOURCE_VOICE_UPLINK;
1465 case AudioSource::VOICE_DOWNLINK:
1466 return AUDIO_SOURCE_VOICE_DOWNLINK;
1467 case AudioSource::VOICE_CALL:
1468 return AUDIO_SOURCE_VOICE_CALL;
1469 case AudioSource::CAMCORDER:
1470 return AUDIO_SOURCE_CAMCORDER;
1471 case AudioSource::VOICE_RECOGNITION:
1472 return AUDIO_SOURCE_VOICE_RECOGNITION;
1473 case AudioSource::VOICE_COMMUNICATION:
1474 return AUDIO_SOURCE_VOICE_COMMUNICATION;
1475 case AudioSource::REMOTE_SUBMIX:
1476 return AUDIO_SOURCE_REMOTE_SUBMIX;
1477 case AudioSource::UNPROCESSED:
1478 return AUDIO_SOURCE_UNPROCESSED;
1479 case AudioSource::VOICE_PERFORMANCE:
1480 return AUDIO_SOURCE_VOICE_PERFORMANCE;
1481 case AudioSource::ULTRASOUND:
1482 return AUDIO_SOURCE_ULTRASOUND;
1483 case AudioSource::ECHO_REFERENCE:
1484 return AUDIO_SOURCE_ECHO_REFERENCE;
1485 case AudioSource::FM_TUNER:
1486 return AUDIO_SOURCE_FM_TUNER;
1487 case AudioSource::HOTWORD:
1488 return AUDIO_SOURCE_HOTWORD;
1489 }
1490 return unexpected(BAD_VALUE);
1491}
1492
1493ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
1494 audio_source_t legacy) {
1495 switch (legacy) {
1496 case AUDIO_SOURCE_INVALID:
1497 return AudioSource::SYS_RESERVED_INVALID;
1498 case AUDIO_SOURCE_DEFAULT:
1499 return AudioSource::DEFAULT;
1500 case AUDIO_SOURCE_MIC:
1501 return AudioSource::MIC;
1502 case AUDIO_SOURCE_VOICE_UPLINK:
1503 return AudioSource::VOICE_UPLINK;
1504 case AUDIO_SOURCE_VOICE_DOWNLINK:
1505 return AudioSource::VOICE_DOWNLINK;
1506 case AUDIO_SOURCE_VOICE_CALL:
1507 return AudioSource::VOICE_CALL;
1508 case AUDIO_SOURCE_CAMCORDER:
1509 return AudioSource::CAMCORDER;
1510 case AUDIO_SOURCE_VOICE_RECOGNITION:
1511 return AudioSource::VOICE_RECOGNITION;
1512 case AUDIO_SOURCE_VOICE_COMMUNICATION:
1513 return AudioSource::VOICE_COMMUNICATION;
1514 case AUDIO_SOURCE_REMOTE_SUBMIX:
1515 return AudioSource::REMOTE_SUBMIX;
1516 case AUDIO_SOURCE_UNPROCESSED:
1517 return AudioSource::UNPROCESSED;
1518 case AUDIO_SOURCE_VOICE_PERFORMANCE:
1519 return AudioSource::VOICE_PERFORMANCE;
1520 case AUDIO_SOURCE_ULTRASOUND:
1521 return AudioSource::ULTRASOUND;
1522 case AUDIO_SOURCE_ECHO_REFERENCE:
1523 return AudioSource::ECHO_REFERENCE;
1524 case AUDIO_SOURCE_FM_TUNER:
1525 return AudioSource::FM_TUNER;
1526 case AUDIO_SOURCE_HOTWORD:
1527 return AudioSource::HOTWORD;
1528 }
1529 return unexpected(BAD_VALUE);
1530}
1531
1532ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
1533 return convertReinterpret<audio_session_t>(aidl);
1534}
1535
1536ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
1537 return convertReinterpret<int32_t>(legacy);
1538}
1539
1540ConversionResult<audio_content_type_t>
1541aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
1542 switch (aidl) {
1543 case AudioContentType::UNKNOWN:
1544 return AUDIO_CONTENT_TYPE_UNKNOWN;
1545 case AudioContentType::SPEECH:
1546 return AUDIO_CONTENT_TYPE_SPEECH;
1547 case AudioContentType::MUSIC:
1548 return AUDIO_CONTENT_TYPE_MUSIC;
1549 case AudioContentType::MOVIE:
1550 return AUDIO_CONTENT_TYPE_MOVIE;
1551 case AudioContentType::SONIFICATION:
1552 return AUDIO_CONTENT_TYPE_SONIFICATION;
1553 case AudioContentType::ULTRASOUND:
1554 return AUDIO_CONTENT_TYPE_ULTRASOUND;
1555 }
1556 return unexpected(BAD_VALUE);
1557}
1558
1559ConversionResult<AudioContentType>
1560legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
1561 switch (legacy) {
1562 case AUDIO_CONTENT_TYPE_UNKNOWN:
1563 return AudioContentType::UNKNOWN;
1564 case AUDIO_CONTENT_TYPE_SPEECH:
1565 return AudioContentType::SPEECH;
1566 case AUDIO_CONTENT_TYPE_MUSIC:
1567 return AudioContentType::MUSIC;
1568 case AUDIO_CONTENT_TYPE_MOVIE:
1569 return AudioContentType::MOVIE;
1570 case AUDIO_CONTENT_TYPE_SONIFICATION:
1571 return AudioContentType::SONIFICATION;
1572 case AUDIO_CONTENT_TYPE_ULTRASOUND:
1573 return AudioContentType::ULTRASOUND;
1574 }
1575 return unexpected(BAD_VALUE);
1576}
1577
1578ConversionResult<audio_usage_t>
1579aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
1580 switch (aidl) {
1581 case AudioUsage::INVALID:
1582 break; // return error
1583 case AudioUsage::UNKNOWN:
1584 return AUDIO_USAGE_UNKNOWN;
1585 case AudioUsage::MEDIA:
1586 return AUDIO_USAGE_MEDIA;
1587 case AudioUsage::VOICE_COMMUNICATION:
1588 return AUDIO_USAGE_VOICE_COMMUNICATION;
1589 case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
1590 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1591 case AudioUsage::ALARM:
1592 return AUDIO_USAGE_ALARM;
1593 case AudioUsage::NOTIFICATION:
1594 return AUDIO_USAGE_NOTIFICATION;
1595 case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
1596 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1597 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
1598 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
1599 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
1600 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
1601 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
1602 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
1603 case AudioUsage::NOTIFICATION_EVENT:
1604 return AUDIO_USAGE_NOTIFICATION_EVENT;
1605 case AudioUsage::ASSISTANCE_ACCESSIBILITY:
1606 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1607 case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
1608 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
1609 case AudioUsage::ASSISTANCE_SONIFICATION:
1610 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1611 case AudioUsage::GAME:
1612 return AUDIO_USAGE_GAME;
1613 case AudioUsage::VIRTUAL_SOURCE:
1614 return AUDIO_USAGE_VIRTUAL_SOURCE;
1615 case AudioUsage::ASSISTANT:
1616 return AUDIO_USAGE_ASSISTANT;
1617 case AudioUsage::CALL_ASSISTANT:
1618 return AUDIO_USAGE_CALL_ASSISTANT;
1619 case AudioUsage::EMERGENCY:
1620 return AUDIO_USAGE_EMERGENCY;
1621 case AudioUsage::SAFETY:
1622 return AUDIO_USAGE_SAFETY;
1623 case AudioUsage::VEHICLE_STATUS:
1624 return AUDIO_USAGE_VEHICLE_STATUS;
1625 case AudioUsage::ANNOUNCEMENT:
1626 return AUDIO_USAGE_ANNOUNCEMENT;
1627 }
1628 return unexpected(BAD_VALUE);
1629}
1630
1631ConversionResult<AudioUsage>
1632legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
1633 switch (legacy) {
1634 case AUDIO_USAGE_UNKNOWN:
1635 return AudioUsage::UNKNOWN;
1636 case AUDIO_USAGE_MEDIA:
1637 return AudioUsage::MEDIA;
1638 case AUDIO_USAGE_VOICE_COMMUNICATION:
1639 return AudioUsage::VOICE_COMMUNICATION;
1640 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
1641 return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
1642 case AUDIO_USAGE_ALARM:
1643 return AudioUsage::ALARM;
1644 case AUDIO_USAGE_NOTIFICATION:
1645 return AudioUsage::NOTIFICATION;
1646 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
1647 return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
1648 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
1649 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
1650 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
1651 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
1652 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
1653 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
1654 case AUDIO_USAGE_NOTIFICATION_EVENT:
1655 return AudioUsage::NOTIFICATION_EVENT;
1656 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
1657 return AudioUsage::ASSISTANCE_ACCESSIBILITY;
1658 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
1659 return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
1660 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
1661 return AudioUsage::ASSISTANCE_SONIFICATION;
1662 case AUDIO_USAGE_GAME:
1663 return AudioUsage::GAME;
1664 case AUDIO_USAGE_VIRTUAL_SOURCE:
1665 return AudioUsage::VIRTUAL_SOURCE;
1666 case AUDIO_USAGE_ASSISTANT:
1667 return AudioUsage::ASSISTANT;
1668 case AUDIO_USAGE_CALL_ASSISTANT:
1669 return AudioUsage::CALL_ASSISTANT;
1670 case AUDIO_USAGE_EMERGENCY:
1671 return AudioUsage::EMERGENCY;
1672 case AUDIO_USAGE_SAFETY:
1673 return AudioUsage::SAFETY;
1674 case AUDIO_USAGE_VEHICLE_STATUS:
1675 return AudioUsage::VEHICLE_STATUS;
1676 case AUDIO_USAGE_ANNOUNCEMENT:
1677 return AudioUsage::ANNOUNCEMENT;
1678 }
1679 return unexpected(BAD_VALUE);
1680}
1681
1682
1683ConversionResult<audio_encapsulation_mode_t>
1684aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
1685 switch (aidl) {
1686 case AudioEncapsulationMode::INVALID:
1687 break; // return error
1688 case AudioEncapsulationMode::NONE:
1689 return AUDIO_ENCAPSULATION_MODE_NONE;
1690 case AudioEncapsulationMode::ELEMENTARY_STREAM:
1691 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
1692 case AudioEncapsulationMode::HANDLE:
1693 return AUDIO_ENCAPSULATION_MODE_HANDLE;
1694 }
1695 return unexpected(BAD_VALUE);
1696}
1697
1698ConversionResult<AudioEncapsulationMode>
1699legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
1700 switch (legacy) {
1701 case AUDIO_ENCAPSULATION_MODE_NONE:
1702 return AudioEncapsulationMode::NONE;
1703 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
1704 return AudioEncapsulationMode::ELEMENTARY_STREAM;
1705 case AUDIO_ENCAPSULATION_MODE_HANDLE:
1706 return AudioEncapsulationMode::HANDLE;
1707 }
1708 return unexpected(BAD_VALUE);
1709}
1710
1711ConversionResult<audio_offload_info_t>
1712aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
1713 audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
1714 audio_config_base_t base = VALUE_OR_RETURN(
1715 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
1716 legacy.sample_rate = base.sample_rate;
1717 legacy.channel_mask = base.channel_mask;
1718 legacy.format = base.format;
1719 legacy.stream_type = VALUE_OR_RETURN(
1720 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1721 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitRatePerSecond));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1722 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
1723 legacy.has_video = aidl.hasVideo;
1724 legacy.is_streaming = aidl.isStreaming;
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1725 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitWidth));
1726 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.offloadBufferSize));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1727 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1728 legacy.encapsulation_mode = VALUE_OR_RETURN(
1729 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
1730 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
1731 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
1732 return legacy;
1733}
1734
1735ConversionResult<AudioOffloadInfo>
1736legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
1737 AudioOffloadInfo aidl;
1738 // Version 0.1 fields.
1739 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
1740 return unexpected(BAD_VALUE);
1741 }
1742 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1743 .channel_mask = legacy.channel_mask, .format = legacy.format };
1744 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
1745 base, false /*isInput*/));
1746 aidl.streamType = VALUE_OR_RETURN(
1747 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
1748 aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
1749 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
1750 aidl.hasVideo = legacy.has_video;
1751 aidl.isStreaming = legacy.is_streaming;
1752 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
1753 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
1754 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1755
1756 // Version 0.2 fields.
1757 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
1758 if (legacy.size <
1759 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
1760 return unexpected(BAD_VALUE);
1761 }
1762 aidl.encapsulationMode = VALUE_OR_RETURN(
1763 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
1764 legacy.encapsulation_mode));
1765 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
1766 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
1767 }
1768 return aidl;
1769}
1770
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame^]1771ConversionResult<AudioPortDirection> portDirection(audio_port_role_t role, audio_port_type_t type) {
1772 switch (type) {
1773 case AUDIO_PORT_TYPE_NONE:
1774 case AUDIO_PORT_TYPE_SESSION:
1775 break; // must be listed -Werror,-Wswitch
1776 case AUDIO_PORT_TYPE_DEVICE:
1777 switch (role) {
1778 case AUDIO_PORT_ROLE_NONE:
1779 break; // must be listed -Werror,-Wswitch
1780 case AUDIO_PORT_ROLE_SOURCE:
1781 return AudioPortDirection::INPUT;
1782 case AUDIO_PORT_ROLE_SINK:
1783 return AudioPortDirection::OUTPUT;
1784 }
1785 break;
1786 case AUDIO_PORT_TYPE_MIX:
1787 switch (role) {
1788 case AUDIO_PORT_ROLE_NONE:
1789 break; // must be listed -Werror,-Wswitch
1790 case AUDIO_PORT_ROLE_SOURCE:
1791 return AudioPortDirection::OUTPUT;
1792 case AUDIO_PORT_ROLE_SINK:
1793 return AudioPortDirection::INPUT;
1794 }
1795 break;
1796 }
1797 return unexpected(BAD_VALUE);
1798}
1799
1800ConversionResult<audio_port_role_t> portRole(AudioPortDirection direction, audio_port_type_t type) {
1801 switch (type) {
1802 case AUDIO_PORT_TYPE_NONE:
1803 case AUDIO_PORT_TYPE_SESSION:
1804 break; // must be listed -Werror,-Wswitch
1805 case AUDIO_PORT_TYPE_DEVICE:
1806 switch (direction) {
1807 case AudioPortDirection::INPUT:
1808 return AUDIO_PORT_ROLE_SOURCE;
1809 case AudioPortDirection::OUTPUT:
1810 return AUDIO_PORT_ROLE_SINK;
1811 }
1812 break;
1813 case AUDIO_PORT_TYPE_MIX:
1814 switch (direction) {
1815 case AudioPortDirection::OUTPUT:
1816 return AUDIO_PORT_ROLE_SOURCE;
1817 case AudioPortDirection::INPUT:
1818 return AUDIO_PORT_ROLE_SINK;
1819 }
1820 break;
1821 }
1822 return unexpected(BAD_VALUE);
1823}
1824
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1825ConversionResult<audio_config_t>
1826aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
1827 const audio_config_base_t legacyBase = VALUE_OR_RETURN(
1828 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
1829 audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
1830 legacy.sample_rate = legacyBase.sample_rate;
1831 legacy.channel_mask = legacyBase.channel_mask;
1832 legacy.format = legacyBase.format;
1833 legacy.offload_info = VALUE_OR_RETURN(
1834 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
1835 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
1836 return legacy;
1837}
1838
1839ConversionResult<AudioConfig>
1840legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
1841 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1842 .channel_mask = legacy.channel_mask, .format = legacy.format };
1843 AudioConfig aidl;
1844 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
1845 aidl.offloadInfo = VALUE_OR_RETURN(
1846 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
1847 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
1848 return aidl;
1849}
1850
1851ConversionResult<audio_config_base_t>
1852aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
1853 audio_config_base_t legacy;
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1854 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<int>(aidl.sampleRate));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1855 legacy.channel_mask = VALUE_OR_RETURN(
1856 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
1857 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
1858 return legacy;
1859}
1860
1861ConversionResult<AudioConfigBase>
1862legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
1863 AudioConfigBase aidl;
1864 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1865 aidl.channelMask = VALUE_OR_RETURN(
1866 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1867 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
1868 return aidl;
1869}
1870
1871ConversionResult<audio_uuid_t>
1872aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
1873 audio_uuid_t legacy;
1874 legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
1875 legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
1876 legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
1877 legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
1878 if (aidl.node.size() != std::size(legacy.node)) {
1879 return unexpected(BAD_VALUE);
1880 }
1881 std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
1882 return legacy;
1883}
1884
1885ConversionResult<AudioUuid>
1886legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
1887 AudioUuid aidl;
1888 aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
1889 aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
1890 aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
1891 aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
1892 std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
1893 return aidl;
1894}
1895
1896ConversionResult<audio_encapsulation_metadata_type_t>
1897aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
1898 AudioEncapsulationMetadataType aidl) {
1899 switch (aidl) {
1900 case AudioEncapsulationMetadataType::NONE:
1901 return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
1902 case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
1903 return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
1904 case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
1905 return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
1906 }
1907 return unexpected(BAD_VALUE);
1908}
1909
1910ConversionResult<AudioEncapsulationMetadataType>
1911legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
1912 audio_encapsulation_metadata_type_t legacy) {
1913 switch (legacy) {
1914 case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
1915 return AudioEncapsulationMetadataType::NONE;
1916 case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
1917 return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
1918 case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
1919 return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
1920 }
1921 return unexpected(BAD_VALUE);
1922}
1923
1924ConversionResult<uint32_t>
1925aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
1926 return convertBitmask<uint32_t,
1927 int32_t,
1928 audio_encapsulation_mode_t,
1929 AudioEncapsulationMode>(
1930 aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
1931 indexToEnum_index<AudioEncapsulationMode>,
1932 enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
1933}
1934
1935ConversionResult<int32_t>
1936legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
1937 return convertBitmask<int32_t,
1938 uint32_t,
1939 AudioEncapsulationMode,
1940 audio_encapsulation_mode_t>(
1941 legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
1942 indexToEnum_index<audio_encapsulation_mode_t>,
1943 enumToMask_index<int32_t, AudioEncapsulationMode>);
1944}
1945
1946ConversionResult<uint32_t>
1947aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
1948 return convertBitmask<uint32_t,
1949 int32_t,
1950 audio_encapsulation_metadata_type_t,
1951 AudioEncapsulationMetadataType>(
1952 aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
1953 indexToEnum_index<AudioEncapsulationMetadataType>,
1954 enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
1955}
1956
1957ConversionResult<int32_t>
1958legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
1959 return convertBitmask<int32_t,
1960 uint32_t,
1961 AudioEncapsulationMetadataType,
1962 audio_encapsulation_metadata_type_t>(
1963 legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
1964 indexToEnum_index<audio_encapsulation_metadata_type_t>,
1965 enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
1966}
1967
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame^]1968ConversionResult<audio_port_config_mix_ext_usecase>
1969aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(
1970 const AudioPortMixExtUseCase& aidl, bool isInput) {
1971 audio_port_config_mix_ext_usecase legacy{};
1972 if (aidl.getTag() != AudioPortMixExtUseCase::Tag::unspecified) {
1973 if (!isInput) {
1974 legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
1975 VALUE_OR_RETURN(UNION_GET(aidl, stream))));
1976 } else {
1977 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(
1978 VALUE_OR_RETURN(UNION_GET(aidl, source))));
1979 }
1980 }
1981 return legacy;
1982}
1983
1984ConversionResult<AudioPortMixExtUseCase>
1985legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(
1986 const audio_port_config_mix_ext_usecase& legacy, bool isInput) {
1987 AudioPortMixExtUseCase aidl;
1988 if (!isInput) {
1989 UNION_SET(aidl, stream, VALUE_OR_RETURN(
1990 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));
1991 } else {
1992 UNION_SET(aidl, source, VALUE_OR_RETURN(
1993 legacy2aidl_audio_source_t_AudioSource(legacy.source)));
1994 }
1995 return aidl;
1996}
1997
1998ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(
1999 const AudioPortMixExt& aidl, bool isInput) {
2000 audio_port_config_mix_ext legacy{};
2001 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
2002 legacy.usecase = VALUE_OR_RETURN(
2003 aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(
2004 aidl.usecase, isInput));
2005 return legacy;
2006}
2007
2008ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(
2009 const audio_port_config_mix_ext& legacy, bool isInput) {
2010 AudioPortMixExt aidl;
2011 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
2012 aidl.usecase = VALUE_OR_RETURN(
2013 legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(
2014 legacy.usecase, isInput));
2015 return aidl;
2016}
2017
2018ConversionResult<audio_port_config_device_ext>
2019aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(const AudioPortDeviceExt& aidl) {
2020 audio_port_config_device_ext legacy{};
2021 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2022 aidl.device, &legacy.type, legacy.address));
2023 return legacy;
2024}
2025
2026ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
2027 const audio_port_config_device_ext& legacy) {
2028 AudioPortDeviceExt aidl;
2029 aidl.device = VALUE_OR_RETURN(
2030 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
2031 return aidl;
2032}
2033
2034// This type is unnamed in the original definition, thus we name it here.
2035using audio_port_config_ext = decltype(audio_port_config::ext);
2036
2037status_t aidl2legacy_AudioPortExt_audio_port_config_ext(
2038 const AudioPortExt& aidl, bool isInput,
2039 audio_port_config_ext* legacy, audio_port_type_t* type) {
2040 switch (aidl.getTag()) {
2041 case AudioPortExt::Tag::unspecified:
2042 // Just verify that the union is empty.
2043 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));
2044 *legacy = {};
2045 *type = AUDIO_PORT_TYPE_NONE;
2046 return OK;
2047 case AudioPortExt::Tag::device:
2048 legacy->device = VALUE_OR_RETURN_STATUS(
2049 aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
2050 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));
2051 *type = AUDIO_PORT_TYPE_DEVICE;
2052 return OK;
2053 case AudioPortExt::Tag::mix:
2054 legacy->mix = VALUE_OR_RETURN_STATUS(
2055 aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(
2056 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix)), isInput));
2057 *type = AUDIO_PORT_TYPE_MIX;
2058 return OK;
2059 case AudioPortExt::Tag::session:
2060 // This variant is not used in the HAL scenario.
2061 legacy->session.session = AUDIO_SESSION_NONE;
2062 *type = AUDIO_PORT_TYPE_SESSION;
2063 return OK;
2064
2065 }
2066 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2067}
2068
2069ConversionResult<AudioPortExt> legacy2aidl_audio_port_config_ext_AudioPortExt(
2070 const audio_port_config_ext& legacy, audio_port_type_t type, bool isInput) {
2071 AudioPortExt aidl;
2072 switch (type) {
2073 case AUDIO_PORT_TYPE_NONE:
2074 UNION_SET(aidl, unspecified, false);
2075 return aidl;
2076 case AUDIO_PORT_TYPE_DEVICE: {
2077 AudioPortDeviceExt device = VALUE_OR_RETURN(
2078 legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(legacy.device));
2079 UNION_SET(aidl, device, device);
2080 return aidl;
2081 }
2082 case AUDIO_PORT_TYPE_MIX: {
2083 AudioPortMixExt mix = VALUE_OR_RETURN(
2084 legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(legacy.mix, isInput));
2085 UNION_SET(aidl, mix, mix);
2086 return aidl;
2087 }
2088 case AUDIO_PORT_TYPE_SESSION:
2089 // This variant is not used in the HAL scenario.
2090 UNION_SET(aidl, unspecified, false);
2091 return aidl;
2092 }
2093 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2094}
2095
2096status_t aidl2legacy_AudioPortConfig_audio_port_config(
2097 const AudioPortConfig& aidl, bool isInput, audio_port_config* legacy, int32_t* portId) {
2098 legacy->id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
2099 *portId = aidl.portId;
2100 if (aidl.sampleRate.has_value()) {
2101 legacy->sample_rate = VALUE_OR_RETURN_STATUS(
2102 convertIntegral<unsigned int>(aidl.sampleRate.value().value));
2103 legacy->config_mask |= AUDIO_PORT_CONFIG_SAMPLE_RATE;
2104 }
2105 if (aidl.channelMask.has_value()) {
2106 legacy->channel_mask =
2107 VALUE_OR_RETURN_STATUS(
2108 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
2109 aidl.channelMask.value(), isInput));
2110 legacy->config_mask |= AUDIO_PORT_CONFIG_CHANNEL_MASK;
2111 }
2112 if (aidl.format.has_value()) {
2113 legacy->format = VALUE_OR_RETURN_STATUS(
2114 aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format.value()));
2115 legacy->config_mask |= AUDIO_PORT_CONFIG_FORMAT;
2116 }
2117 if (aidl.gain.has_value()) {
2118 legacy->gain = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioGainConfig_audio_gain_config(
2119 aidl.gain.value(), isInput));
2120 legacy->config_mask |= AUDIO_PORT_CONFIG_GAIN;
2121 }
2122 if (aidl.flags.has_value()) {
2123 legacy->flags = VALUE_OR_RETURN_STATUS(
2124 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags.value(), isInput));
2125 legacy->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
2126 }
2127 RETURN_STATUS_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_config_ext(
2128 aidl.ext, isInput, &legacy->ext, &legacy->type));
2129 legacy->role = VALUE_OR_RETURN_STATUS(portRole(isInput ?
2130 AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy->type));
2131 return OK;
2132}
2133
2134ConversionResult<AudioPortConfig>
2135legacy2aidl_audio_port_config_AudioPortConfig(
2136 const audio_port_config& legacy, bool isInput, int32_t portId) {
2137 AudioPortConfig aidl;
2138 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2139 aidl.portId = portId;
2140 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
2141 Int aidl_sampleRate;
2142 aidl_sampleRate.value = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
2143 aidl.sampleRate = aidl_sampleRate;
2144 }
2145 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
2146 aidl.channelMask = VALUE_OR_RETURN(
2147 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2148 }
2149 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
2150 aidl.format = VALUE_OR_RETURN(
2151 legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2152 }
2153 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
2154 aidl.gain = VALUE_OR_RETURN(
2155 legacy2aidl_audio_gain_config_AudioGainConfig(legacy.gain, isInput));
2156 }
2157 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
2158 aidl.flags = VALUE_OR_RETURN(
2159 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, isInput));
2160 }
2161 aidl.ext = VALUE_OR_RETURN(
2162 legacy2aidl_audio_port_config_ext_AudioPortExt(legacy.ext, legacy.type, isInput));
2163 return aidl;
2164}
2165
2166ConversionResult<audio_port_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2167 const AudioPortMixExt& aidl) {
2168 audio_port_mix_ext legacy{};
2169 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
2170 return legacy;
2171}
2172
2173ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_mix_ext_AudioPortMixExt(
2174 const audio_port_mix_ext& legacy) {
2175 AudioPortMixExt aidl;
2176 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
2177 return aidl;
2178}
2179
2180ConversionResult<audio_port_device_ext>
2181aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(const AudioPortDeviceExt& aidl) {
2182 audio_port_device_ext legacy{};
2183 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2184 aidl.device, &legacy.type, legacy.address));
2185 return legacy;
2186}
2187
2188ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(
2189 const audio_port_device_ext& legacy) {
2190 AudioPortDeviceExt aidl;
2191 aidl.device = VALUE_OR_RETURN(
2192 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
2193 return aidl;
2194}
2195
2196// This type is unnamed in the original definition, thus we name it here.
2197using audio_port_v7_ext = decltype(audio_port_v7::ext);
2198
2199status_t aidl2legacy_AudioPortExt_audio_port_v7_ext(
2200 const AudioPortExt& aidl, audio_port_v7_ext* legacy, audio_port_type_t* type) {
2201 switch (aidl.getTag()) {
2202 case AudioPortExt::Tag::unspecified:
2203 // Just verify that the union is empty.
2204 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));
2205 *legacy = {};
2206 *type = AUDIO_PORT_TYPE_NONE;
2207 return OK;
2208 case AudioPortExt::Tag::device:
2209 legacy->device = VALUE_OR_RETURN_STATUS(
2210 aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
2211 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));
2212 *type = AUDIO_PORT_TYPE_DEVICE;
2213 return OK;
2214 case AudioPortExt::Tag::mix:
2215 legacy->mix = VALUE_OR_RETURN_STATUS(
2216 aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2217 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix))));
2218 *type = AUDIO_PORT_TYPE_MIX;
2219 return OK;
2220 case AudioPortExt::Tag::session:
2221 // This variant is not used in the HAL scenario.
2222 legacy->session.session = AUDIO_SESSION_NONE;
2223 *type = AUDIO_PORT_TYPE_SESSION;
2224 return OK;
2225
2226 }
2227 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2228}
2229
2230ConversionResult<AudioPortExt> legacy2aidl_audio_port_v7_ext_AudioPortExt(
2231 const audio_port_v7_ext& legacy, audio_port_type_t type) {
2232 AudioPortExt aidl;
2233 switch (type) {
2234 case AUDIO_PORT_TYPE_NONE:
2235 UNION_SET(aidl, unspecified, false);
2236 return aidl;
2237 case AUDIO_PORT_TYPE_DEVICE: {
2238 AudioPortDeviceExt device = VALUE_OR_RETURN(
2239 legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(legacy.device));
2240 UNION_SET(aidl, device, device);
2241 return aidl;
2242 }
2243 case AUDIO_PORT_TYPE_MIX: {
2244 AudioPortMixExt mix = VALUE_OR_RETURN(
2245 legacy2aidl_audio_port_mix_ext_AudioPortMixExt(legacy.mix));
2246 UNION_SET(aidl, mix, mix);
2247 return aidl;
2248 }
2249 case AUDIO_PORT_TYPE_SESSION:
2250 // This variant is not used in the HAL scenario.
2251 UNION_SET(aidl, unspecified, false);
2252 return aidl;
2253 }
2254 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2255}
2256
2257ConversionResult<audio_port_v7>
2258aidl2legacy_AudioPort_audio_port_v7(const AudioPort& aidl, bool isInput) {
2259 audio_port_v7 legacy;
2260 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
2261 RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));
2262
2263 if (aidl.profiles.size() > std::size(legacy.audio_profiles)) {
2264 return unexpected(BAD_VALUE);
2265 }
2266 RETURN_IF_ERROR(convertRange(
2267 aidl.profiles.begin(), aidl.profiles.end(), legacy.audio_profiles,
2268 [isInput](const AudioProfile& p) {
2269 return aidl2legacy_AudioProfile_audio_profile(p, isInput);
2270 }));
2271 legacy.num_audio_profiles = aidl.profiles.size();
2272
2273 if (aidl.extraAudioDescriptors.size() > std::size(legacy.extra_audio_descriptors)) {
2274 return unexpected(BAD_VALUE);
2275 }
2276 RETURN_IF_ERROR(
2277 convertRange(
2278 aidl.extraAudioDescriptors.begin(), aidl.extraAudioDescriptors.end(),
2279 legacy.extra_audio_descriptors,
2280 aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor));
2281 legacy.num_extra_audio_descriptors = aidl.extraAudioDescriptors.size();
2282
2283 if (aidl.gains.size() > std::size(legacy.gains)) {
2284 return unexpected(BAD_VALUE);
2285 }
2286 RETURN_IF_ERROR(convertRange(aidl.gains.begin(), aidl.gains.end(), legacy.gains,
2287 [isInput](const AudioGain& g) {
2288 return aidl2legacy_AudioGain_audio_gain(g, isInput);
2289 }));
2290 legacy.num_gains = aidl.gains.size();
2291
2292 RETURN_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_v7_ext(
2293 aidl.ext, &legacy.ext, &legacy.type));
2294 legacy.role = VALUE_OR_RETURN(portRole(
2295 isInput ? AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy.type));
2296
2297 AudioPortConfig aidlPortConfig;
2298 int32_t portId;
2299 aidlPortConfig.flags = aidl.flags;
2300 aidlPortConfig.ext = aidl.ext;
2301 RETURN_IF_ERROR(aidl2legacy_AudioPortConfig_audio_port_config(
2302 aidlPortConfig, isInput, &legacy.active_config, &portId));
2303 return legacy;
2304}
2305
2306ConversionResult<AudioPort>
2307legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy, bool isInput) {
2308 AudioPort aidl;
2309 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2310 aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
2311
2312 if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {
2313 return unexpected(BAD_VALUE);
2314 }
2315 RETURN_IF_ERROR(
2316 convertRange(legacy.audio_profiles, legacy.audio_profiles + legacy.num_audio_profiles,
2317 std::back_inserter(aidl.profiles),
2318 [isInput](const audio_profile& p) {
2319 return legacy2aidl_audio_profile_AudioProfile(p, isInput);
2320 }));
2321
2322 if (legacy.num_extra_audio_descriptors > std::size(legacy.extra_audio_descriptors)) {
2323 return unexpected(BAD_VALUE);
2324 }
2325 aidl.profiles.resize(legacy.num_audio_profiles);
2326 RETURN_IF_ERROR(
2327 convertRange(legacy.extra_audio_descriptors,
2328 legacy.extra_audio_descriptors + legacy.num_extra_audio_descriptors,
2329 std::back_inserter(aidl.extraAudioDescriptors),
2330 legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor));
2331
2332 if (legacy.num_gains > std::size(legacy.gains)) {
2333 return unexpected(BAD_VALUE);
2334 }
2335 RETURN_IF_ERROR(
2336 convertRange(legacy.gains, legacy.gains + legacy.num_gains,
2337 std::back_inserter(aidl.gains),
2338 [isInput](const audio_gain& g) {
2339 return legacy2aidl_audio_gain_AudioGain(g, isInput);
2340 }));
2341 aidl.gains.resize(legacy.num_gains);
2342
2343 aidl.ext = VALUE_OR_RETURN(
2344 legacy2aidl_audio_port_v7_ext_AudioPortExt(legacy.ext, legacy.type));
2345
2346 AudioPortConfig aidlPortConfig = VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(
2347 legacy.active_config, isInput, aidl.id));
2348 if (aidlPortConfig.flags.has_value()) {
2349 aidl.flags = aidlPortConfig.flags.value();
2350 } else {
2351 aidl.flags = isInput ?
2352 AudioIoFlags::make<AudioIoFlags::Tag::input>(0) :
2353 AudioIoFlags::make<AudioIoFlags::Tag::output>(0);
2354 }
2355 return aidl;
2356}
2357
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]2358ConversionResult<audio_profile>
2359aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
2360 audio_profile legacy;
2361 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
2362
2363 if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
2364 return unexpected(BAD_VALUE);
2365 }
2366 RETURN_IF_ERROR(
2367 convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
2368 convertIntegral<int32_t, unsigned int>));
2369 legacy.num_sample_rates = aidl.sampleRates.size();
2370
2371 if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
2372 return unexpected(BAD_VALUE);
2373 }
2374 RETURN_IF_ERROR(
2375 convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
2376 [isInput](const AudioChannelLayout& l) {
2377 return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
2378 }));
2379 legacy.num_channel_masks = aidl.channelMasks.size();
2380
2381 legacy.encapsulation_type = VALUE_OR_RETURN(
2382 aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
2383 return legacy;
2384}
2385
2386ConversionResult<AudioProfile>
2387legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
2388 AudioProfile aidl;
2389 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2390
2391 if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
2392 return unexpected(BAD_VALUE);
2393 }
2394 RETURN_IF_ERROR(
2395 convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
2396 std::back_inserter(aidl.sampleRates),
2397 convertIntegral<unsigned int, int32_t>));
2398
2399 if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
2400 return unexpected(BAD_VALUE);
2401 }
2402 RETURN_IF_ERROR(
2403 convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
2404 std::back_inserter(aidl.channelMasks),
2405 [isInput](audio_channel_mask_t m) {
2406 return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
2407 }));
2408
2409 aidl.encapsulationType = VALUE_OR_RETURN(
2410 legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2411 legacy.encapsulation_type));
2412 return aidl;
2413}
2414
2415ConversionResult<audio_gain>
2416aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
2417 audio_gain legacy;
2418 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
2419 legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
2420 aidl.channelMask, isInput));
2421 legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
2422 legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
2423 legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
2424 legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
2425 legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
2426 legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
2427 return legacy;
2428}
2429
2430ConversionResult<AudioGain>
2431legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
2432 AudioGain aidl;
2433 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
2434 aidl.channelMask = VALUE_OR_RETURN(
2435 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2436 aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
2437 aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
2438 aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
2439 aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
2440 aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
2441 aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
2442 return aidl;
2443}
2444
2445ConversionResult<audio_mode_t>
2446aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
2447 switch (aidl) {
2448 case AudioMode::SYS_RESERVED_INVALID:
2449 return AUDIO_MODE_INVALID;
2450 case AudioMode::SYS_RESERVED_CURRENT:
2451 return AUDIO_MODE_CURRENT;
2452 case AudioMode::NORMAL:
2453 return AUDIO_MODE_NORMAL;
2454 case AudioMode::RINGTONE:
2455 return AUDIO_MODE_RINGTONE;
2456 case AudioMode::IN_CALL:
2457 return AUDIO_MODE_IN_CALL;
2458 case AudioMode::IN_COMMUNICATION:
2459 return AUDIO_MODE_IN_COMMUNICATION;
2460 case AudioMode::CALL_SCREEN:
2461 return AUDIO_MODE_CALL_SCREEN;
2462 case AudioMode::SYS_RESERVED_CALL_REDIRECT:
2463 return AUDIO_MODE_CALL_REDIRECT;
2464 case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
2465 return AUDIO_MODE_COMMUNICATION_REDIRECT;
2466 }
2467 return unexpected(BAD_VALUE);
2468}
2469
2470ConversionResult<AudioMode>
2471legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
2472 switch (legacy) {
2473 case AUDIO_MODE_INVALID:
2474 return AudioMode::SYS_RESERVED_INVALID;
2475 case AUDIO_MODE_CURRENT:
2476 return AudioMode::SYS_RESERVED_CURRENT;
2477 case AUDIO_MODE_NORMAL:
2478 return AudioMode::NORMAL;
2479 case AUDIO_MODE_RINGTONE:
2480 return AudioMode::RINGTONE;
2481 case AUDIO_MODE_IN_CALL:
2482 return AudioMode::IN_CALL;
2483 case AUDIO_MODE_IN_COMMUNICATION:
2484 return AudioMode::IN_COMMUNICATION;
2485 case AUDIO_MODE_CALL_SCREEN:
2486 return AudioMode::CALL_SCREEN;
2487 case AUDIO_MODE_CALL_REDIRECT:
2488 return AudioMode::SYS_RESERVED_CALL_REDIRECT;
2489 case AUDIO_MODE_COMMUNICATION_REDIRECT:
2490 return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
2491 case AUDIO_MODE_CNT:
2492 break;
2493 }
2494 return unexpected(BAD_VALUE);
2495}
2496
2497ConversionResult<audio_standard_t>
2498aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
2499 switch (aidl) {
2500 case AudioStandard::NONE:
2501 return AUDIO_STANDARD_NONE;
2502 case AudioStandard::EDID:
2503 return AUDIO_STANDARD_EDID;
2504 }
2505 return unexpected(BAD_VALUE);
2506}
2507
2508ConversionResult<AudioStandard>
2509legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
2510 switch (legacy) {
2511 case AUDIO_STANDARD_NONE:
2512 return AudioStandard::NONE;
2513 case AUDIO_STANDARD_EDID:
2514 return AudioStandard::EDID;
2515 }
2516 return unexpected(BAD_VALUE);
2517}
2518
2519ConversionResult<audio_extra_audio_descriptor>
2520aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
2521 const ExtraAudioDescriptor& aidl) {
2522 audio_extra_audio_descriptor legacy;
2523 legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
2524 if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2525 return unexpected(BAD_VALUE);
2526 }
2527 legacy.descriptor_length = aidl.audioDescriptor.size();
2528 std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
2529 std::begin(legacy.descriptor));
2530 legacy.encapsulation_type =
2531 VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2532 aidl.encapsulationType));
2533 return legacy;
2534}
2535
2536ConversionResult<ExtraAudioDescriptor>
2537legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
2538 const audio_extra_audio_descriptor& legacy) {
2539 ExtraAudioDescriptor aidl;
2540 aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
2541 if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2542 return unexpected(BAD_VALUE);
2543 }
2544 aidl.audioDescriptor.resize(legacy.descriptor_length);
2545 std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
2546 aidl.audioDescriptor.begin());
2547 aidl.encapsulationType =
2548 VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2549 legacy.encapsulation_type));
2550 return aidl;
2551}
2552
2553ConversionResult<audio_encapsulation_type_t>
2554aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2555 const AudioEncapsulationType& aidl) {
2556 switch (aidl) {
2557 case AudioEncapsulationType::NONE:
2558 return AUDIO_ENCAPSULATION_TYPE_NONE;
2559 case AudioEncapsulationType::IEC61937:
2560 return AUDIO_ENCAPSULATION_TYPE_IEC61937;
2561 case AudioEncapsulationType::PCM:
2562 return AUDIO_ENCAPSULATION_TYPE_PCM;
2563 }
2564 return unexpected(BAD_VALUE);
2565}
2566
2567ConversionResult<AudioEncapsulationType>
2568legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2569 const audio_encapsulation_type_t & legacy) {
2570 switch (legacy) {
2571 case AUDIO_ENCAPSULATION_TYPE_NONE:
2572 return AudioEncapsulationType::NONE;
2573 case AUDIO_ENCAPSULATION_TYPE_IEC61937:
2574 return AudioEncapsulationType::IEC61937;
2575 case AUDIO_ENCAPSULATION_TYPE_PCM:
2576 return AudioEncapsulationType::PCM;
2577 }
2578 return unexpected(BAD_VALUE);
2579}
2580
Mikhail Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]2581ConversionResult<audio_dual_mono_mode_t>
2582aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(AudioDualMonoMode aidl) {
2583 switch (aidl) {
2584 case AudioDualMonoMode::OFF:
2585 return AUDIO_DUAL_MONO_MODE_OFF;
2586 case AudioDualMonoMode::LR:
2587 return AUDIO_DUAL_MONO_MODE_LR;
2588 case AudioDualMonoMode::LL:
2589 return AUDIO_DUAL_MONO_MODE_LL;
2590 case AudioDualMonoMode::RR:
2591 return AUDIO_DUAL_MONO_MODE_RR;
2592 }
2593 return unexpected(BAD_VALUE);
2594}
2595
2596ConversionResult<AudioDualMonoMode>
2597legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(audio_dual_mono_mode_t legacy) {
2598 switch (legacy) {
2599 case AUDIO_DUAL_MONO_MODE_OFF:
2600 return AudioDualMonoMode::OFF;
2601 case AUDIO_DUAL_MONO_MODE_LR:
2602 return AudioDualMonoMode::LR;
2603 case AUDIO_DUAL_MONO_MODE_LL:
2604 return AudioDualMonoMode::LL;
2605 case AUDIO_DUAL_MONO_MODE_RR:
2606 return AudioDualMonoMode::RR;
2607 }
2608 return unexpected(BAD_VALUE);
2609}
2610
2611ConversionResult<audio_timestretch_fallback_mode_t>
2612aidl2legacy_TimestretchFallbackMode_audio_timestretch_fallback_mode_t(
2613 AudioPlaybackRate::TimestretchFallbackMode aidl) {
2614 switch (aidl) {
2615 case AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_CUT_REPEAT:
2616 return AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT;
2617 case AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_DEFAULT:
2618 return AUDIO_TIMESTRETCH_FALLBACK_DEFAULT;
2619 case AudioPlaybackRate::TimestretchFallbackMode::MUTE:
2620 return AUDIO_TIMESTRETCH_FALLBACK_MUTE;
2621 case AudioPlaybackRate::TimestretchFallbackMode::FAIL:
2622 return AUDIO_TIMESTRETCH_FALLBACK_FAIL;
2623 }
2624 return unexpected(BAD_VALUE);
2625}
2626
2627ConversionResult<AudioPlaybackRate::TimestretchFallbackMode>
2628legacy2aidl_audio_timestretch_fallback_mode_t_TimestretchFallbackMode(
2629 audio_timestretch_fallback_mode_t legacy) {
2630 switch (legacy) {
2631 case AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT:
2632 return AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_CUT_REPEAT;
2633 case AUDIO_TIMESTRETCH_FALLBACK_DEFAULT:
2634 return AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_DEFAULT;
2635 case AUDIO_TIMESTRETCH_FALLBACK_MUTE:
2636 return AudioPlaybackRate::TimestretchFallbackMode::MUTE;
2637 case AUDIO_TIMESTRETCH_FALLBACK_FAIL:
2638 return AudioPlaybackRate::TimestretchFallbackMode::FAIL;
2639 }
2640 return unexpected(BAD_VALUE);
2641}
2642
2643ConversionResult<audio_timestretch_stretch_mode_t>
2644aidl2legacy_TimestretchMode_audio_timestretch_stretch_mode_t(
2645 AudioPlaybackRate::TimestretchMode aidl) {
2646 switch (aidl) {
2647 case AudioPlaybackRate::TimestretchMode::DEFAULT:
2648 return AUDIO_TIMESTRETCH_STRETCH_DEFAULT;
2649 case AudioPlaybackRate::TimestretchMode::VOICE:
2650 return AUDIO_TIMESTRETCH_STRETCH_VOICE;
2651 }
2652 return unexpected(BAD_VALUE);
2653}
2654
2655ConversionResult<AudioPlaybackRate::TimestretchMode>
2656legacy2aidl_audio_timestretch_stretch_mode_t_TimestretchMode(
2657 audio_timestretch_stretch_mode_t legacy) {
2658 switch (legacy) {
2659 case AUDIO_TIMESTRETCH_STRETCH_DEFAULT:
2660 return AudioPlaybackRate::TimestretchMode::DEFAULT;
2661 case AUDIO_TIMESTRETCH_STRETCH_VOICE:
2662 return AudioPlaybackRate::TimestretchMode::VOICE;
2663 }
2664 return unexpected(BAD_VALUE);
2665}
2666
2667ConversionResult<audio_playback_rate_t>
2668aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(const AudioPlaybackRate& aidl) {
2669 audio_playback_rate_t legacy;
2670 legacy.mSpeed = aidl.speed;
2671 legacy.mPitch = aidl.pitch;
2672 legacy.mFallbackMode = VALUE_OR_RETURN(
2673 aidl2legacy_TimestretchFallbackMode_audio_timestretch_fallback_mode_t(
2674 aidl.fallbackMode));
2675 legacy.mStretchMode = VALUE_OR_RETURN(
2676 aidl2legacy_TimestretchMode_audio_timestretch_stretch_mode_t(aidl.timestretchMode));
2677 return legacy;
2678}
2679
2680ConversionResult<AudioPlaybackRate>
2681legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(const audio_playback_rate_t& legacy) {
2682 AudioPlaybackRate aidl;
2683 aidl.speed = legacy.mSpeed;
2684 aidl.pitch = legacy.mPitch;
2685 aidl.fallbackMode = VALUE_OR_RETURN(
2686 legacy2aidl_audio_timestretch_fallback_mode_t_TimestretchFallbackMode(
2687 legacy.mFallbackMode));
2688 aidl.timestretchMode = VALUE_OR_RETURN(
2689 legacy2aidl_audio_timestretch_stretch_mode_t_TimestretchMode(legacy.mStretchMode));
2690 return aidl;
2691}
2692
2693ConversionResult<audio_latency_mode_t>
2694aidl2legacy_AudioLatencyMode_audio_latency_mode_t(AudioLatencyMode aidl) {
2695 switch (aidl) {
2696 case AudioLatencyMode::FREE:
2697 return AUDIO_LATENCY_MODE_FREE;
2698 case AudioLatencyMode::LOW:
2699 return AUDIO_LATENCY_MODE_LOW;
2700 }
2701 return unexpected(BAD_VALUE);
2702}
2703ConversionResult<AudioLatencyMode>
2704legacy2aidl_audio_latency_mode_t_AudioLatencyMode(audio_latency_mode_t legacy) {
2705 switch (legacy) {
2706 case AUDIO_LATENCY_MODE_FREE:
2707 return AudioLatencyMode::FREE;
2708 case AUDIO_LATENCY_MODE_LOW:
2709 return AudioLatencyMode::LOW;
2710 }
2711 return unexpected(BAD_VALUE);
2712}
2713
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]2714} // namespace android
2715
2716#if defined(BACKEND_NDK)
2717} // aidl
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame^]2718#endif