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