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