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