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