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