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