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