Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_av / 893b7c23e72084319611494e11f93fbf2d0d8243 / . / media / audioaidlconversion / AidlConversionCppNdk.cpp
blob: 8c2b9409d50345d6d1ad4bc81127909af46861fb [file] [log] [blame]
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]32// AIDL CPP/NDK backend to legacy audio data structure conversion utilities.
Shunkai Yao4b574cf2022-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 Yao4b574cf2022-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 Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]59using media::audio::common::AudioDualMonoMode;
Shunkai Yao4b574cf2022-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 Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]70using media::audio::common::AudioLatencyMode;
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]71using media::audio::common::AudioMode;
72using media::audio::common::AudioOffloadInfo;
73using media::audio::common::AudioOutputFlags;
Mikhail Naganovb1a075b2022-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 Yao4b574cf2022-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 Naganov2a6a3012023-02-13 11:45:03 -0800[diff] [blame]89using media::audio::common::MicrophoneDynamicInfo;
90using media::audio::common::MicrophoneInfo;
Shunkai Yao4b574cf2022-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 Yao4b574cf2022-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 Yao4b574cf2022-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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]862 __builtin_popcount(bits) != 0 &&
863 __builtin_popcount(bits) <= (int)AUDIO_CHANNEL_COUNT_MAX) {
Shunkai Yao4b574cf2022-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 Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1139 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<int>(aidl.rampDurationMs));
Shunkai Yao4b574cf2022-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;
1183 }
1184 return unexpected(BAD_VALUE);
1185}
1186
1187ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
1188 audio_input_flags_t legacy) {
1189 switch (legacy) {
1190 case AUDIO_INPUT_FLAG_NONE:
1191 break; // shouldn't get here. must be listed -Werror,-Wswitch
1192 case AUDIO_INPUT_FLAG_FAST:
1193 return AudioInputFlags::FAST;
1194 case AUDIO_INPUT_FLAG_HW_HOTWORD:
1195 return AudioInputFlags::HW_HOTWORD;
1196 case AUDIO_INPUT_FLAG_RAW:
1197 return AudioInputFlags::RAW;
1198 case AUDIO_INPUT_FLAG_SYNC:
1199 return AudioInputFlags::SYNC;
1200 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
1201 return AudioInputFlags::MMAP_NOIRQ;
1202 case AUDIO_INPUT_FLAG_VOIP_TX:
1203 return AudioInputFlags::VOIP_TX;
1204 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
1205 return AudioInputFlags::HW_AV_SYNC;
1206 case AUDIO_INPUT_FLAG_DIRECT:
1207 return AudioInputFlags::DIRECT;
1208 case AUDIO_INPUT_FLAG_ULTRASOUND:
1209 return AudioInputFlags::ULTRASOUND;
1210 }
1211 return unexpected(BAD_VALUE);
1212}
1213
1214ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
1215 AudioOutputFlags aidl) {
1216 switch (aidl) {
1217 case AudioOutputFlags::DIRECT:
1218 return AUDIO_OUTPUT_FLAG_DIRECT;
1219 case AudioOutputFlags::PRIMARY:
1220 return AUDIO_OUTPUT_FLAG_PRIMARY;
1221 case AudioOutputFlags::FAST:
1222 return AUDIO_OUTPUT_FLAG_FAST;
1223 case AudioOutputFlags::DEEP_BUFFER:
1224 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
1225 case AudioOutputFlags::COMPRESS_OFFLOAD:
1226 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1227 case AudioOutputFlags::NON_BLOCKING:
1228 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
1229 case AudioOutputFlags::HW_AV_SYNC:
1230 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
1231 case AudioOutputFlags::TTS:
1232 return AUDIO_OUTPUT_FLAG_TTS;
1233 case AudioOutputFlags::RAW:
1234 return AUDIO_OUTPUT_FLAG_RAW;
1235 case AudioOutputFlags::SYNC:
1236 return AUDIO_OUTPUT_FLAG_SYNC;
1237 case AudioOutputFlags::IEC958_NONAUDIO:
1238 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
1239 case AudioOutputFlags::DIRECT_PCM:
1240 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
1241 case AudioOutputFlags::MMAP_NOIRQ:
1242 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
1243 case AudioOutputFlags::VOIP_RX:
1244 return AUDIO_OUTPUT_FLAG_VOIP_RX;
1245 case AudioOutputFlags::INCALL_MUSIC:
1246 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
1247 case AudioOutputFlags::GAPLESS_OFFLOAD:
1248 return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
1249 case AudioOutputFlags::ULTRASOUND:
1250 return AUDIO_OUTPUT_FLAG_ULTRASOUND;
1251 case AudioOutputFlags::SPATIALIZER:
1252 return AUDIO_OUTPUT_FLAG_SPATIALIZER;
1253 case AudioOutputFlags::BIT_PERFECT:
1254 return AUDIO_OUTPUT_FLAG_BIT_PERFECT;
1255 }
1256 return unexpected(BAD_VALUE);
1257}
1258
1259ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
1260 audio_output_flags_t legacy) {
1261 switch (legacy) {
1262 case AUDIO_OUTPUT_FLAG_NONE:
1263 break; // shouldn't get here. must be listed -Werror,-Wswitch
1264 case AUDIO_OUTPUT_FLAG_DIRECT:
1265 return AudioOutputFlags::DIRECT;
1266 case AUDIO_OUTPUT_FLAG_PRIMARY:
1267 return AudioOutputFlags::PRIMARY;
1268 case AUDIO_OUTPUT_FLAG_FAST:
1269 return AudioOutputFlags::FAST;
1270 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
1271 return AudioOutputFlags::DEEP_BUFFER;
1272 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
1273 return AudioOutputFlags::COMPRESS_OFFLOAD;
1274 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
1275 return AudioOutputFlags::NON_BLOCKING;
1276 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
1277 return AudioOutputFlags::HW_AV_SYNC;
1278 case AUDIO_OUTPUT_FLAG_TTS:
1279 return AudioOutputFlags::TTS;
1280 case AUDIO_OUTPUT_FLAG_RAW:
1281 return AudioOutputFlags::RAW;
1282 case AUDIO_OUTPUT_FLAG_SYNC:
1283 return AudioOutputFlags::SYNC;
1284 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
1285 return AudioOutputFlags::IEC958_NONAUDIO;
1286 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
1287 return AudioOutputFlags::DIRECT_PCM;
1288 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
1289 return AudioOutputFlags::MMAP_NOIRQ;
1290 case AUDIO_OUTPUT_FLAG_VOIP_RX:
1291 return AudioOutputFlags::VOIP_RX;
1292 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
1293 return AudioOutputFlags::INCALL_MUSIC;
1294 case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
1295 return AudioOutputFlags::GAPLESS_OFFLOAD;
1296 case AUDIO_OUTPUT_FLAG_ULTRASOUND:
1297 return AudioOutputFlags::ULTRASOUND;
1298 case AUDIO_OUTPUT_FLAG_SPATIALIZER:
1299 return AudioOutputFlags::SPATIALIZER;
1300 case AUDIO_OUTPUT_FLAG_BIT_PERFECT:
1301 return AudioOutputFlags::BIT_PERFECT;
1302 }
1303 return unexpected(BAD_VALUE);
1304}
1305
1306ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
1307 int32_t aidl) {
1308 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1309
1310 LegacyMask converted = VALUE_OR_RETURN(
1311 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
1312 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
1313 indexToEnum_index<AudioInputFlags>,
1314 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
1315 return static_cast<audio_input_flags_t>(converted);
1316}
1317
1318ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
1319 audio_input_flags_t legacy) {
1320 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
1321
1322 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1323 return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
1324 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
1325 indexToEnum_bitmask<audio_input_flags_t>,
1326 enumToMask_index<int32_t, AudioInputFlags>);
1327}
1328
1329ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
1330 int32_t aidl) {
1331 return convertBitmask<audio_output_flags_t,
1332 int32_t,
1333 audio_output_flags_t,
1334 AudioOutputFlags>(
1335 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
1336 indexToEnum_index<AudioOutputFlags>,
1337 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
1338}
1339
1340ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
1341 audio_output_flags_t legacy) {
1342 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
1343
1344 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
1345 return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
1346 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
1347 indexToEnum_bitmask<audio_output_flags_t>,
1348 enumToMask_index<int32_t, AudioOutputFlags>);
1349}
1350
1351ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
1352 const AudioIoFlags& aidl, bool isInput) {
1353 audio_io_flags legacy;
1354 if (isInput) {
1355 legacy.input = VALUE_OR_RETURN(
1356 aidl2legacy_int32_t_audio_input_flags_t_mask(
1357 VALUE_OR_RETURN(UNION_GET(aidl, input))));
1358 } else {
1359 legacy.output = VALUE_OR_RETURN(
1360 aidl2legacy_int32_t_audio_output_flags_t_mask(
1361 VALUE_OR_RETURN(UNION_GET(aidl, output))));
1362 }
1363 return legacy;
1364}
1365
1366ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
1367 const audio_io_flags& legacy, bool isInput) {
1368 AudioIoFlags aidl;
1369 if (isInput) {
1370 UNION_SET(aidl, input,
1371 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
1372 } else {
1373 UNION_SET(aidl, output,
1374 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
1375 }
1376 return aidl;
1377}
1378
1379ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
1380 AudioStreamType aidl) {
1381 switch (aidl) {
1382 case AudioStreamType::INVALID:
1383 break; // return error
1384 case AudioStreamType::SYS_RESERVED_DEFAULT:
1385 return AUDIO_STREAM_DEFAULT;
1386 case AudioStreamType::VOICE_CALL:
1387 return AUDIO_STREAM_VOICE_CALL;
1388 case AudioStreamType::SYSTEM:
1389 return AUDIO_STREAM_SYSTEM;
1390 case AudioStreamType::RING:
1391 return AUDIO_STREAM_RING;
1392 case AudioStreamType::MUSIC:
1393 return AUDIO_STREAM_MUSIC;
1394 case AudioStreamType::ALARM:
1395 return AUDIO_STREAM_ALARM;
1396 case AudioStreamType::NOTIFICATION:
1397 return AUDIO_STREAM_NOTIFICATION;
1398 case AudioStreamType::BLUETOOTH_SCO:
1399 return AUDIO_STREAM_BLUETOOTH_SCO;
1400 case AudioStreamType::ENFORCED_AUDIBLE:
1401 return AUDIO_STREAM_ENFORCED_AUDIBLE;
1402 case AudioStreamType::DTMF:
1403 return AUDIO_STREAM_DTMF;
1404 case AudioStreamType::TTS:
1405 return AUDIO_STREAM_TTS;
1406 case AudioStreamType::ACCESSIBILITY:
1407 return AUDIO_STREAM_ACCESSIBILITY;
1408 case AudioStreamType::ASSISTANT:
1409 return AUDIO_STREAM_ASSISTANT;
1410 case AudioStreamType::SYS_RESERVED_REROUTING:
1411 return AUDIO_STREAM_REROUTING;
1412 case AudioStreamType::SYS_RESERVED_PATCH:
1413 return AUDIO_STREAM_PATCH;
1414 case AudioStreamType::CALL_ASSISTANT:
1415 return AUDIO_STREAM_CALL_ASSISTANT;
1416 }
1417 return unexpected(BAD_VALUE);
1418}
1419
1420ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
1421 audio_stream_type_t legacy) {
1422 switch (legacy) {
1423 case AUDIO_STREAM_DEFAULT:
1424 return AudioStreamType::SYS_RESERVED_DEFAULT;
1425 case AUDIO_STREAM_VOICE_CALL:
1426 return AudioStreamType::VOICE_CALL;
1427 case AUDIO_STREAM_SYSTEM:
1428 return AudioStreamType::SYSTEM;
1429 case AUDIO_STREAM_RING:
1430 return AudioStreamType::RING;
1431 case AUDIO_STREAM_MUSIC:
1432 return AudioStreamType::MUSIC;
1433 case AUDIO_STREAM_ALARM:
1434 return AudioStreamType::ALARM;
1435 case AUDIO_STREAM_NOTIFICATION:
1436 return AudioStreamType::NOTIFICATION;
1437 case AUDIO_STREAM_BLUETOOTH_SCO:
1438 return AudioStreamType::BLUETOOTH_SCO;
1439 case AUDIO_STREAM_ENFORCED_AUDIBLE:
1440 return AudioStreamType::ENFORCED_AUDIBLE;
1441 case AUDIO_STREAM_DTMF:
1442 return AudioStreamType::DTMF;
1443 case AUDIO_STREAM_TTS:
1444 return AudioStreamType::TTS;
1445 case AUDIO_STREAM_ACCESSIBILITY:
1446 return AudioStreamType::ACCESSIBILITY;
1447 case AUDIO_STREAM_ASSISTANT:
1448 return AudioStreamType::ASSISTANT;
1449 case AUDIO_STREAM_REROUTING:
1450 return AudioStreamType::SYS_RESERVED_REROUTING;
1451 case AUDIO_STREAM_PATCH:
1452 return AudioStreamType::SYS_RESERVED_PATCH;
1453 case AUDIO_STREAM_CALL_ASSISTANT:
1454 return AudioStreamType::CALL_ASSISTANT;
1455 }
1456 return unexpected(BAD_VALUE);
1457}
1458
1459ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
1460 AudioSource aidl) {
1461 switch (aidl) {
1462 case AudioSource::SYS_RESERVED_INVALID:
1463 return AUDIO_SOURCE_INVALID;
1464 case AudioSource::DEFAULT:
1465 return AUDIO_SOURCE_DEFAULT;
1466 case AudioSource::MIC:
1467 return AUDIO_SOURCE_MIC;
1468 case AudioSource::VOICE_UPLINK:
1469 return AUDIO_SOURCE_VOICE_UPLINK;
1470 case AudioSource::VOICE_DOWNLINK:
1471 return AUDIO_SOURCE_VOICE_DOWNLINK;
1472 case AudioSource::VOICE_CALL:
1473 return AUDIO_SOURCE_VOICE_CALL;
1474 case AudioSource::CAMCORDER:
1475 return AUDIO_SOURCE_CAMCORDER;
1476 case AudioSource::VOICE_RECOGNITION:
1477 return AUDIO_SOURCE_VOICE_RECOGNITION;
1478 case AudioSource::VOICE_COMMUNICATION:
1479 return AUDIO_SOURCE_VOICE_COMMUNICATION;
1480 case AudioSource::REMOTE_SUBMIX:
1481 return AUDIO_SOURCE_REMOTE_SUBMIX;
1482 case AudioSource::UNPROCESSED:
1483 return AUDIO_SOURCE_UNPROCESSED;
1484 case AudioSource::VOICE_PERFORMANCE:
1485 return AUDIO_SOURCE_VOICE_PERFORMANCE;
1486 case AudioSource::ULTRASOUND:
1487 return AUDIO_SOURCE_ULTRASOUND;
1488 case AudioSource::ECHO_REFERENCE:
1489 return AUDIO_SOURCE_ECHO_REFERENCE;
1490 case AudioSource::FM_TUNER:
1491 return AUDIO_SOURCE_FM_TUNER;
1492 case AudioSource::HOTWORD:
1493 return AUDIO_SOURCE_HOTWORD;
1494 }
1495 return unexpected(BAD_VALUE);
1496}
1497
1498ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
1499 audio_source_t legacy) {
1500 switch (legacy) {
1501 case AUDIO_SOURCE_INVALID:
1502 return AudioSource::SYS_RESERVED_INVALID;
1503 case AUDIO_SOURCE_DEFAULT:
1504 return AudioSource::DEFAULT;
1505 case AUDIO_SOURCE_MIC:
1506 return AudioSource::MIC;
1507 case AUDIO_SOURCE_VOICE_UPLINK:
1508 return AudioSource::VOICE_UPLINK;
1509 case AUDIO_SOURCE_VOICE_DOWNLINK:
1510 return AudioSource::VOICE_DOWNLINK;
1511 case AUDIO_SOURCE_VOICE_CALL:
1512 return AudioSource::VOICE_CALL;
1513 case AUDIO_SOURCE_CAMCORDER:
1514 return AudioSource::CAMCORDER;
1515 case AUDIO_SOURCE_VOICE_RECOGNITION:
1516 return AudioSource::VOICE_RECOGNITION;
1517 case AUDIO_SOURCE_VOICE_COMMUNICATION:
1518 return AudioSource::VOICE_COMMUNICATION;
1519 case AUDIO_SOURCE_REMOTE_SUBMIX:
1520 return AudioSource::REMOTE_SUBMIX;
1521 case AUDIO_SOURCE_UNPROCESSED:
1522 return AudioSource::UNPROCESSED;
1523 case AUDIO_SOURCE_VOICE_PERFORMANCE:
1524 return AudioSource::VOICE_PERFORMANCE;
1525 case AUDIO_SOURCE_ULTRASOUND:
1526 return AudioSource::ULTRASOUND;
1527 case AUDIO_SOURCE_ECHO_REFERENCE:
1528 return AudioSource::ECHO_REFERENCE;
1529 case AUDIO_SOURCE_FM_TUNER:
1530 return AudioSource::FM_TUNER;
1531 case AUDIO_SOURCE_HOTWORD:
1532 return AudioSource::HOTWORD;
1533 }
1534 return unexpected(BAD_VALUE);
1535}
1536
1537ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
1538 return convertReinterpret<audio_session_t>(aidl);
1539}
1540
1541ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
1542 return convertReinterpret<int32_t>(legacy);
1543}
1544
1545ConversionResult<audio_content_type_t>
1546aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
1547 switch (aidl) {
1548 case AudioContentType::UNKNOWN:
1549 return AUDIO_CONTENT_TYPE_UNKNOWN;
1550 case AudioContentType::SPEECH:
1551 return AUDIO_CONTENT_TYPE_SPEECH;
1552 case AudioContentType::MUSIC:
1553 return AUDIO_CONTENT_TYPE_MUSIC;
1554 case AudioContentType::MOVIE:
1555 return AUDIO_CONTENT_TYPE_MOVIE;
1556 case AudioContentType::SONIFICATION:
1557 return AUDIO_CONTENT_TYPE_SONIFICATION;
1558 case AudioContentType::ULTRASOUND:
1559 return AUDIO_CONTENT_TYPE_ULTRASOUND;
1560 }
1561 return unexpected(BAD_VALUE);
1562}
1563
1564ConversionResult<AudioContentType>
1565legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
1566 switch (legacy) {
1567 case AUDIO_CONTENT_TYPE_UNKNOWN:
1568 return AudioContentType::UNKNOWN;
1569 case AUDIO_CONTENT_TYPE_SPEECH:
1570 return AudioContentType::SPEECH;
1571 case AUDIO_CONTENT_TYPE_MUSIC:
1572 return AudioContentType::MUSIC;
1573 case AUDIO_CONTENT_TYPE_MOVIE:
1574 return AudioContentType::MOVIE;
1575 case AUDIO_CONTENT_TYPE_SONIFICATION:
1576 return AudioContentType::SONIFICATION;
1577 case AUDIO_CONTENT_TYPE_ULTRASOUND:
1578 return AudioContentType::ULTRASOUND;
1579 }
1580 return unexpected(BAD_VALUE);
1581}
1582
1583ConversionResult<audio_usage_t>
1584aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
1585 switch (aidl) {
1586 case AudioUsage::INVALID:
1587 break; // return error
1588 case AudioUsage::UNKNOWN:
1589 return AUDIO_USAGE_UNKNOWN;
1590 case AudioUsage::MEDIA:
1591 return AUDIO_USAGE_MEDIA;
1592 case AudioUsage::VOICE_COMMUNICATION:
1593 return AUDIO_USAGE_VOICE_COMMUNICATION;
1594 case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
1595 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1596 case AudioUsage::ALARM:
1597 return AUDIO_USAGE_ALARM;
1598 case AudioUsage::NOTIFICATION:
1599 return AUDIO_USAGE_NOTIFICATION;
1600 case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
1601 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1602 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
1603 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
1604 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
1605 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
1606 case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
1607 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
1608 case AudioUsage::NOTIFICATION_EVENT:
1609 return AUDIO_USAGE_NOTIFICATION_EVENT;
1610 case AudioUsage::ASSISTANCE_ACCESSIBILITY:
1611 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1612 case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
1613 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
1614 case AudioUsage::ASSISTANCE_SONIFICATION:
1615 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1616 case AudioUsage::GAME:
1617 return AUDIO_USAGE_GAME;
1618 case AudioUsage::VIRTUAL_SOURCE:
1619 return AUDIO_USAGE_VIRTUAL_SOURCE;
1620 case AudioUsage::ASSISTANT:
1621 return AUDIO_USAGE_ASSISTANT;
1622 case AudioUsage::CALL_ASSISTANT:
1623 return AUDIO_USAGE_CALL_ASSISTANT;
1624 case AudioUsage::EMERGENCY:
1625 return AUDIO_USAGE_EMERGENCY;
1626 case AudioUsage::SAFETY:
1627 return AUDIO_USAGE_SAFETY;
1628 case AudioUsage::VEHICLE_STATUS:
1629 return AUDIO_USAGE_VEHICLE_STATUS;
1630 case AudioUsage::ANNOUNCEMENT:
1631 return AUDIO_USAGE_ANNOUNCEMENT;
1632 }
1633 return unexpected(BAD_VALUE);
1634}
1635
1636ConversionResult<AudioUsage>
1637legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
1638 switch (legacy) {
1639 case AUDIO_USAGE_UNKNOWN:
1640 return AudioUsage::UNKNOWN;
1641 case AUDIO_USAGE_MEDIA:
1642 return AudioUsage::MEDIA;
1643 case AUDIO_USAGE_VOICE_COMMUNICATION:
1644 return AudioUsage::VOICE_COMMUNICATION;
1645 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
1646 return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
1647 case AUDIO_USAGE_ALARM:
1648 return AudioUsage::ALARM;
1649 case AUDIO_USAGE_NOTIFICATION:
1650 return AudioUsage::NOTIFICATION;
1651 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
1652 return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
1653 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
1654 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
1655 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
1656 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
1657 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
1658 return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
1659 case AUDIO_USAGE_NOTIFICATION_EVENT:
1660 return AudioUsage::NOTIFICATION_EVENT;
1661 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
1662 return AudioUsage::ASSISTANCE_ACCESSIBILITY;
1663 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
1664 return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
1665 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
1666 return AudioUsage::ASSISTANCE_SONIFICATION;
1667 case AUDIO_USAGE_GAME:
1668 return AudioUsage::GAME;
1669 case AUDIO_USAGE_VIRTUAL_SOURCE:
1670 return AudioUsage::VIRTUAL_SOURCE;
1671 case AUDIO_USAGE_ASSISTANT:
1672 return AudioUsage::ASSISTANT;
1673 case AUDIO_USAGE_CALL_ASSISTANT:
1674 return AudioUsage::CALL_ASSISTANT;
1675 case AUDIO_USAGE_EMERGENCY:
1676 return AudioUsage::EMERGENCY;
1677 case AUDIO_USAGE_SAFETY:
1678 return AudioUsage::SAFETY;
1679 case AUDIO_USAGE_VEHICLE_STATUS:
1680 return AudioUsage::VEHICLE_STATUS;
1681 case AUDIO_USAGE_ANNOUNCEMENT:
1682 return AudioUsage::ANNOUNCEMENT;
1683 }
1684 return unexpected(BAD_VALUE);
1685}
1686
1687
1688ConversionResult<audio_encapsulation_mode_t>
1689aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
1690 switch (aidl) {
1691 case AudioEncapsulationMode::INVALID:
1692 break; // return error
1693 case AudioEncapsulationMode::NONE:
1694 return AUDIO_ENCAPSULATION_MODE_NONE;
1695 case AudioEncapsulationMode::ELEMENTARY_STREAM:
1696 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
1697 case AudioEncapsulationMode::HANDLE:
1698 return AUDIO_ENCAPSULATION_MODE_HANDLE;
1699 }
1700 return unexpected(BAD_VALUE);
1701}
1702
1703ConversionResult<AudioEncapsulationMode>
1704legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
1705 switch (legacy) {
1706 case AUDIO_ENCAPSULATION_MODE_NONE:
1707 return AudioEncapsulationMode::NONE;
1708 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
1709 return AudioEncapsulationMode::ELEMENTARY_STREAM;
1710 case AUDIO_ENCAPSULATION_MODE_HANDLE:
1711 return AudioEncapsulationMode::HANDLE;
1712 }
1713 return unexpected(BAD_VALUE);
1714}
1715
1716ConversionResult<audio_offload_info_t>
1717aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
1718 audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
1719 audio_config_base_t base = VALUE_OR_RETURN(
1720 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
1721 legacy.sample_rate = base.sample_rate;
1722 legacy.channel_mask = base.channel_mask;
1723 legacy.format = base.format;
1724 legacy.stream_type = VALUE_OR_RETURN(
1725 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1726 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitRatePerSecond));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1727 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
1728 legacy.has_video = aidl.hasVideo;
1729 legacy.is_streaming = aidl.isStreaming;
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1730 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitWidth));
1731 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.offloadBufferSize));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1732 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1733 legacy.encapsulation_mode = VALUE_OR_RETURN(
1734 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
1735 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
1736 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
1737 return legacy;
1738}
1739
1740ConversionResult<AudioOffloadInfo>
1741legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
1742 AudioOffloadInfo aidl;
1743 // Version 0.1 fields.
1744 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
1745 return unexpected(BAD_VALUE);
1746 }
1747 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1748 .channel_mask = legacy.channel_mask, .format = legacy.format };
1749 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
1750 base, false /*isInput*/));
1751 aidl.streamType = VALUE_OR_RETURN(
1752 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
1753 aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
1754 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
1755 aidl.hasVideo = legacy.has_video;
1756 aidl.isStreaming = legacy.is_streaming;
1757 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
1758 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
1759 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1760
1761 // Version 0.2 fields.
1762 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
1763 if (legacy.size <
1764 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
1765 return unexpected(BAD_VALUE);
1766 }
1767 aidl.encapsulationMode = VALUE_OR_RETURN(
1768 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
1769 legacy.encapsulation_mode));
1770 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
1771 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
1772 }
1773 return aidl;
1774}
1775
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame]1776ConversionResult<AudioPortDirection> portDirection(audio_port_role_t role, audio_port_type_t type) {
1777 switch (type) {
1778 case AUDIO_PORT_TYPE_NONE:
1779 case AUDIO_PORT_TYPE_SESSION:
1780 break; // must be listed -Werror,-Wswitch
1781 case AUDIO_PORT_TYPE_DEVICE:
1782 switch (role) {
1783 case AUDIO_PORT_ROLE_NONE:
1784 break; // must be listed -Werror,-Wswitch
1785 case AUDIO_PORT_ROLE_SOURCE:
1786 return AudioPortDirection::INPUT;
1787 case AUDIO_PORT_ROLE_SINK:
1788 return AudioPortDirection::OUTPUT;
1789 }
1790 break;
1791 case AUDIO_PORT_TYPE_MIX:
1792 switch (role) {
1793 case AUDIO_PORT_ROLE_NONE:
1794 break; // must be listed -Werror,-Wswitch
1795 case AUDIO_PORT_ROLE_SOURCE:
1796 return AudioPortDirection::OUTPUT;
1797 case AUDIO_PORT_ROLE_SINK:
1798 return AudioPortDirection::INPUT;
1799 }
1800 break;
1801 }
1802 return unexpected(BAD_VALUE);
1803}
1804
1805ConversionResult<audio_port_role_t> portRole(AudioPortDirection direction, audio_port_type_t type) {
1806 switch (type) {
1807 case AUDIO_PORT_TYPE_NONE:
1808 case AUDIO_PORT_TYPE_SESSION:
1809 break; // must be listed -Werror,-Wswitch
1810 case AUDIO_PORT_TYPE_DEVICE:
1811 switch (direction) {
1812 case AudioPortDirection::INPUT:
1813 return AUDIO_PORT_ROLE_SOURCE;
1814 case AudioPortDirection::OUTPUT:
1815 return AUDIO_PORT_ROLE_SINK;
1816 }
1817 break;
1818 case AUDIO_PORT_TYPE_MIX:
1819 switch (direction) {
1820 case AudioPortDirection::OUTPUT:
1821 return AUDIO_PORT_ROLE_SOURCE;
1822 case AudioPortDirection::INPUT:
1823 return AUDIO_PORT_ROLE_SINK;
1824 }
1825 break;
1826 }
1827 return unexpected(BAD_VALUE);
1828}
1829
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1830ConversionResult<audio_config_t>
1831aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
1832 const audio_config_base_t legacyBase = VALUE_OR_RETURN(
1833 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
1834 audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
1835 legacy.sample_rate = legacyBase.sample_rate;
1836 legacy.channel_mask = legacyBase.channel_mask;
1837 legacy.format = legacyBase.format;
1838 legacy.offload_info = VALUE_OR_RETURN(
1839 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
1840 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
1841 return legacy;
1842}
1843
1844ConversionResult<AudioConfig>
1845legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
1846 const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
1847 .channel_mask = legacy.channel_mask, .format = legacy.format };
1848 AudioConfig aidl;
1849 aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
1850 aidl.offloadInfo = VALUE_OR_RETURN(
1851 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
1852 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
1853 return aidl;
1854}
1855
1856ConversionResult<audio_config_base_t>
1857aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
1858 audio_config_base_t legacy;
Shunkai Yao51202502022-12-12 06:11:46 +0000[diff] [blame]1859 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<int>(aidl.sampleRate));
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]1860 legacy.channel_mask = VALUE_OR_RETURN(
1861 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
1862 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
1863 return legacy;
1864}
1865
1866ConversionResult<AudioConfigBase>
1867legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
1868 AudioConfigBase aidl;
1869 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1870 aidl.channelMask = VALUE_OR_RETURN(
1871 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
1872 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
1873 return aidl;
1874}
1875
1876ConversionResult<audio_uuid_t>
1877aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
1878 audio_uuid_t legacy;
1879 legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
1880 legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
1881 legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
1882 legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
1883 if (aidl.node.size() != std::size(legacy.node)) {
1884 return unexpected(BAD_VALUE);
1885 }
1886 std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
1887 return legacy;
1888}
1889
1890ConversionResult<AudioUuid>
1891legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
1892 AudioUuid aidl;
1893 aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
1894 aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
1895 aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
1896 aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
1897 std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
1898 return aidl;
1899}
1900
1901ConversionResult<audio_encapsulation_metadata_type_t>
1902aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
1903 AudioEncapsulationMetadataType aidl) {
1904 switch (aidl) {
1905 case AudioEncapsulationMetadataType::NONE:
1906 return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
1907 case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
1908 return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
1909 case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
1910 return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
1911 }
1912 return unexpected(BAD_VALUE);
1913}
1914
1915ConversionResult<AudioEncapsulationMetadataType>
1916legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
1917 audio_encapsulation_metadata_type_t legacy) {
1918 switch (legacy) {
1919 case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
1920 return AudioEncapsulationMetadataType::NONE;
1921 case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
1922 return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
1923 case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
1924 return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
1925 }
1926 return unexpected(BAD_VALUE);
1927}
1928
1929ConversionResult<uint32_t>
1930aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
1931 return convertBitmask<uint32_t,
1932 int32_t,
1933 audio_encapsulation_mode_t,
1934 AudioEncapsulationMode>(
1935 aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
1936 indexToEnum_index<AudioEncapsulationMode>,
1937 enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
1938}
1939
1940ConversionResult<int32_t>
1941legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
1942 return convertBitmask<int32_t,
1943 uint32_t,
1944 AudioEncapsulationMode,
1945 audio_encapsulation_mode_t>(
1946 legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
1947 indexToEnum_index<audio_encapsulation_mode_t>,
1948 enumToMask_index<int32_t, AudioEncapsulationMode>);
1949}
1950
1951ConversionResult<uint32_t>
1952aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
1953 return convertBitmask<uint32_t,
1954 int32_t,
1955 audio_encapsulation_metadata_type_t,
1956 AudioEncapsulationMetadataType>(
1957 aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
1958 indexToEnum_index<AudioEncapsulationMetadataType>,
1959 enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
1960}
1961
1962ConversionResult<int32_t>
1963legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
1964 return convertBitmask<int32_t,
1965 uint32_t,
1966 AudioEncapsulationMetadataType,
1967 audio_encapsulation_metadata_type_t>(
1968 legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
1969 indexToEnum_index<audio_encapsulation_metadata_type_t>,
1970 enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
1971}
1972
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame]1973ConversionResult<audio_port_config_mix_ext_usecase>
1974aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(
1975 const AudioPortMixExtUseCase& aidl, bool isInput) {
1976 audio_port_config_mix_ext_usecase legacy{};
1977 if (aidl.getTag() != AudioPortMixExtUseCase::Tag::unspecified) {
1978 if (!isInput) {
1979 legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
1980 VALUE_OR_RETURN(UNION_GET(aidl, stream))));
1981 } else {
1982 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(
1983 VALUE_OR_RETURN(UNION_GET(aidl, source))));
1984 }
1985 }
1986 return legacy;
1987}
1988
1989ConversionResult<AudioPortMixExtUseCase>
1990legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(
1991 const audio_port_config_mix_ext_usecase& legacy, bool isInput) {
1992 AudioPortMixExtUseCase aidl;
1993 if (!isInput) {
1994 UNION_SET(aidl, stream, VALUE_OR_RETURN(
1995 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));
1996 } else {
1997 UNION_SET(aidl, source, VALUE_OR_RETURN(
1998 legacy2aidl_audio_source_t_AudioSource(legacy.source)));
1999 }
2000 return aidl;
2001}
2002
2003ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(
2004 const AudioPortMixExt& aidl, bool isInput) {
2005 audio_port_config_mix_ext legacy{};
2006 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
2007 legacy.usecase = VALUE_OR_RETURN(
2008 aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(
2009 aidl.usecase, isInput));
2010 return legacy;
2011}
2012
2013ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(
2014 const audio_port_config_mix_ext& legacy, bool isInput) {
2015 AudioPortMixExt aidl;
2016 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
2017 aidl.usecase = VALUE_OR_RETURN(
2018 legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(
2019 legacy.usecase, isInput));
2020 return aidl;
2021}
2022
2023ConversionResult<audio_port_config_device_ext>
2024aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(const AudioPortDeviceExt& aidl) {
2025 audio_port_config_device_ext legacy{};
2026 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2027 aidl.device, &legacy.type, legacy.address));
2028 return legacy;
2029}
2030
2031ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
2032 const audio_port_config_device_ext& legacy) {
2033 AudioPortDeviceExt aidl;
2034 aidl.device = VALUE_OR_RETURN(
2035 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
2036 return aidl;
2037}
2038
2039// This type is unnamed in the original definition, thus we name it here.
2040using audio_port_config_ext = decltype(audio_port_config::ext);
2041
2042status_t aidl2legacy_AudioPortExt_audio_port_config_ext(
2043 const AudioPortExt& aidl, bool isInput,
2044 audio_port_config_ext* legacy, audio_port_type_t* type) {
2045 switch (aidl.getTag()) {
2046 case AudioPortExt::Tag::unspecified:
2047 // Just verify that the union is empty.
2048 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));
2049 *legacy = {};
2050 *type = AUDIO_PORT_TYPE_NONE;
2051 return OK;
2052 case AudioPortExt::Tag::device:
2053 legacy->device = VALUE_OR_RETURN_STATUS(
2054 aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
2055 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));
2056 *type = AUDIO_PORT_TYPE_DEVICE;
2057 return OK;
2058 case AudioPortExt::Tag::mix:
2059 legacy->mix = VALUE_OR_RETURN_STATUS(
2060 aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(
2061 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix)), isInput));
2062 *type = AUDIO_PORT_TYPE_MIX;
2063 return OK;
2064 case AudioPortExt::Tag::session:
2065 // This variant is not used in the HAL scenario.
2066 legacy->session.session = AUDIO_SESSION_NONE;
2067 *type = AUDIO_PORT_TYPE_SESSION;
2068 return OK;
2069
2070 }
2071 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2072}
2073
2074ConversionResult<AudioPortExt> legacy2aidl_audio_port_config_ext_AudioPortExt(
2075 const audio_port_config_ext& legacy, audio_port_type_t type, bool isInput) {
2076 AudioPortExt aidl;
2077 switch (type) {
2078 case AUDIO_PORT_TYPE_NONE:
2079 UNION_SET(aidl, unspecified, false);
2080 return aidl;
2081 case AUDIO_PORT_TYPE_DEVICE: {
2082 AudioPortDeviceExt device = VALUE_OR_RETURN(
2083 legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(legacy.device));
2084 UNION_SET(aidl, device, device);
2085 return aidl;
2086 }
2087 case AUDIO_PORT_TYPE_MIX: {
2088 AudioPortMixExt mix = VALUE_OR_RETURN(
2089 legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(legacy.mix, isInput));
2090 UNION_SET(aidl, mix, mix);
2091 return aidl;
2092 }
2093 case AUDIO_PORT_TYPE_SESSION:
2094 // This variant is not used in the HAL scenario.
2095 UNION_SET(aidl, unspecified, false);
2096 return aidl;
2097 }
2098 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2099}
2100
2101status_t aidl2legacy_AudioPortConfig_audio_port_config(
2102 const AudioPortConfig& aidl, bool isInput, audio_port_config* legacy, int32_t* portId) {
2103 legacy->id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
2104 *portId = aidl.portId;
2105 if (aidl.sampleRate.has_value()) {
2106 legacy->sample_rate = VALUE_OR_RETURN_STATUS(
2107 convertIntegral<unsigned int>(aidl.sampleRate.value().value));
2108 legacy->config_mask |= AUDIO_PORT_CONFIG_SAMPLE_RATE;
2109 }
2110 if (aidl.channelMask.has_value()) {
2111 legacy->channel_mask =
2112 VALUE_OR_RETURN_STATUS(
2113 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
2114 aidl.channelMask.value(), isInput));
2115 legacy->config_mask |= AUDIO_PORT_CONFIG_CHANNEL_MASK;
2116 }
2117 if (aidl.format.has_value()) {
2118 legacy->format = VALUE_OR_RETURN_STATUS(
2119 aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format.value()));
2120 legacy->config_mask |= AUDIO_PORT_CONFIG_FORMAT;
2121 }
2122 if (aidl.gain.has_value()) {
2123 legacy->gain = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioGainConfig_audio_gain_config(
2124 aidl.gain.value(), isInput));
2125 legacy->config_mask |= AUDIO_PORT_CONFIG_GAIN;
2126 }
2127 if (aidl.flags.has_value()) {
2128 legacy->flags = VALUE_OR_RETURN_STATUS(
2129 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags.value(), isInput));
2130 legacy->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
2131 }
2132 RETURN_STATUS_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_config_ext(
2133 aidl.ext, isInput, &legacy->ext, &legacy->type));
2134 legacy->role = VALUE_OR_RETURN_STATUS(portRole(isInput ?
2135 AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy->type));
2136 return OK;
2137}
2138
2139ConversionResult<AudioPortConfig>
2140legacy2aidl_audio_port_config_AudioPortConfig(
2141 const audio_port_config& legacy, bool isInput, int32_t portId) {
2142 AudioPortConfig aidl;
2143 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2144 aidl.portId = portId;
2145 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
2146 Int aidl_sampleRate;
2147 aidl_sampleRate.value = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
2148 aidl.sampleRate = aidl_sampleRate;
2149 }
2150 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
2151 aidl.channelMask = VALUE_OR_RETURN(
2152 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2153 }
2154 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
2155 aidl.format = VALUE_OR_RETURN(
2156 legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2157 }
2158 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
2159 aidl.gain = VALUE_OR_RETURN(
2160 legacy2aidl_audio_gain_config_AudioGainConfig(legacy.gain, isInput));
2161 }
2162 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
2163 aidl.flags = VALUE_OR_RETURN(
2164 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, isInput));
2165 }
2166 aidl.ext = VALUE_OR_RETURN(
2167 legacy2aidl_audio_port_config_ext_AudioPortExt(legacy.ext, legacy.type, isInput));
2168 return aidl;
2169}
2170
2171ConversionResult<audio_port_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2172 const AudioPortMixExt& aidl) {
2173 audio_port_mix_ext legacy{};
2174 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
2175 return legacy;
2176}
2177
2178ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_mix_ext_AudioPortMixExt(
2179 const audio_port_mix_ext& legacy) {
2180 AudioPortMixExt aidl;
2181 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
2182 return aidl;
2183}
2184
2185ConversionResult<audio_port_device_ext>
2186aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(const AudioPortDeviceExt& aidl) {
2187 audio_port_device_ext legacy{};
2188 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2189 aidl.device, &legacy.type, legacy.address));
Mikhail Naganovb9503342023-02-24 17:18:35 -0800[diff] [blame]2190 legacy.encapsulation_modes = VALUE_OR_RETURN(
2191 aidl2legacy_AudioEncapsulationMode_mask(aidl.encapsulationModes));
2192 legacy.encapsulation_metadata_types = VALUE_OR_RETURN(
2193 aidl2legacy_AudioEncapsulationMetadataType_mask(
2194 aidl.encapsulationMetadataTypes));
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame]2195 return legacy;
2196}
2197
2198ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(
2199 const audio_port_device_ext& legacy) {
2200 AudioPortDeviceExt aidl;
2201 aidl.device = VALUE_OR_RETURN(
2202 legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
Mikhail Naganovb9503342023-02-24 17:18:35 -0800[diff] [blame]2203 aidl.encapsulationModes = VALUE_OR_RETURN(
2204 legacy2aidl_AudioEncapsulationMode_mask(legacy.encapsulation_modes));
2205 aidl.encapsulationMetadataTypes = VALUE_OR_RETURN(
2206 legacy2aidl_AudioEncapsulationMetadataType_mask(legacy.encapsulation_metadata_types));
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame]2207 return aidl;
2208}
2209
2210// This type is unnamed in the original definition, thus we name it here.
2211using audio_port_v7_ext = decltype(audio_port_v7::ext);
2212
2213status_t aidl2legacy_AudioPortExt_audio_port_v7_ext(
2214 const AudioPortExt& aidl, audio_port_v7_ext* legacy, audio_port_type_t* type) {
2215 switch (aidl.getTag()) {
2216 case AudioPortExt::Tag::unspecified:
2217 // Just verify that the union is empty.
2218 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));
2219 *legacy = {};
2220 *type = AUDIO_PORT_TYPE_NONE;
2221 return OK;
2222 case AudioPortExt::Tag::device:
2223 legacy->device = VALUE_OR_RETURN_STATUS(
2224 aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
2225 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));
2226 *type = AUDIO_PORT_TYPE_DEVICE;
2227 return OK;
2228 case AudioPortExt::Tag::mix:
2229 legacy->mix = VALUE_OR_RETURN_STATUS(
2230 aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
2231 VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix))));
2232 *type = AUDIO_PORT_TYPE_MIX;
2233 return OK;
2234 case AudioPortExt::Tag::session:
2235 // This variant is not used in the HAL scenario.
2236 legacy->session.session = AUDIO_SESSION_NONE;
2237 *type = AUDIO_PORT_TYPE_SESSION;
2238 return OK;
2239
2240 }
2241 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2242}
2243
2244ConversionResult<AudioPortExt> legacy2aidl_audio_port_v7_ext_AudioPortExt(
2245 const audio_port_v7_ext& legacy, audio_port_type_t type) {
2246 AudioPortExt aidl;
2247 switch (type) {
2248 case AUDIO_PORT_TYPE_NONE:
2249 UNION_SET(aidl, unspecified, false);
2250 return aidl;
2251 case AUDIO_PORT_TYPE_DEVICE: {
2252 AudioPortDeviceExt device = VALUE_OR_RETURN(
2253 legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(legacy.device));
2254 UNION_SET(aidl, device, device);
2255 return aidl;
2256 }
2257 case AUDIO_PORT_TYPE_MIX: {
2258 AudioPortMixExt mix = VALUE_OR_RETURN(
2259 legacy2aidl_audio_port_mix_ext_AudioPortMixExt(legacy.mix));
2260 UNION_SET(aidl, mix, mix);
2261 return aidl;
2262 }
2263 case AUDIO_PORT_TYPE_SESSION:
2264 // This variant is not used in the HAL scenario.
2265 UNION_SET(aidl, unspecified, false);
2266 return aidl;
2267 }
2268 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
2269}
2270
2271ConversionResult<audio_port_v7>
2272aidl2legacy_AudioPort_audio_port_v7(const AudioPort& aidl, bool isInput) {
2273 audio_port_v7 legacy;
2274 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
2275 RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));
2276
2277 if (aidl.profiles.size() > std::size(legacy.audio_profiles)) {
2278 return unexpected(BAD_VALUE);
2279 }
2280 RETURN_IF_ERROR(convertRange(
2281 aidl.profiles.begin(), aidl.profiles.end(), legacy.audio_profiles,
2282 [isInput](const AudioProfile& p) {
2283 return aidl2legacy_AudioProfile_audio_profile(p, isInput);
2284 }));
2285 legacy.num_audio_profiles = aidl.profiles.size();
2286
2287 if (aidl.extraAudioDescriptors.size() > std::size(legacy.extra_audio_descriptors)) {
2288 return unexpected(BAD_VALUE);
2289 }
2290 RETURN_IF_ERROR(
2291 convertRange(
2292 aidl.extraAudioDescriptors.begin(), aidl.extraAudioDescriptors.end(),
2293 legacy.extra_audio_descriptors,
2294 aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor));
2295 legacy.num_extra_audio_descriptors = aidl.extraAudioDescriptors.size();
2296
2297 if (aidl.gains.size() > std::size(legacy.gains)) {
2298 return unexpected(BAD_VALUE);
2299 }
2300 RETURN_IF_ERROR(convertRange(aidl.gains.begin(), aidl.gains.end(), legacy.gains,
2301 [isInput](const AudioGain& g) {
2302 return aidl2legacy_AudioGain_audio_gain(g, isInput);
2303 }));
2304 legacy.num_gains = aidl.gains.size();
2305
2306 RETURN_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_v7_ext(
2307 aidl.ext, &legacy.ext, &legacy.type));
2308 legacy.role = VALUE_OR_RETURN(portRole(
2309 isInput ? AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy.type));
2310
2311 AudioPortConfig aidlPortConfig;
2312 int32_t portId;
2313 aidlPortConfig.flags = aidl.flags;
2314 aidlPortConfig.ext = aidl.ext;
2315 RETURN_IF_ERROR(aidl2legacy_AudioPortConfig_audio_port_config(
2316 aidlPortConfig, isInput, &legacy.active_config, &portId));
2317 return legacy;
2318}
2319
2320ConversionResult<AudioPort>
2321legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy, bool isInput) {
2322 AudioPort aidl;
2323 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2324 aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
2325
2326 if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {
2327 return unexpected(BAD_VALUE);
2328 }
2329 RETURN_IF_ERROR(
2330 convertRange(legacy.audio_profiles, legacy.audio_profiles + legacy.num_audio_profiles,
2331 std::back_inserter(aidl.profiles),
2332 [isInput](const audio_profile& p) {
2333 return legacy2aidl_audio_profile_AudioProfile(p, isInput);
2334 }));
2335
2336 if (legacy.num_extra_audio_descriptors > std::size(legacy.extra_audio_descriptors)) {
2337 return unexpected(BAD_VALUE);
2338 }
2339 aidl.profiles.resize(legacy.num_audio_profiles);
2340 RETURN_IF_ERROR(
2341 convertRange(legacy.extra_audio_descriptors,
2342 legacy.extra_audio_descriptors + legacy.num_extra_audio_descriptors,
2343 std::back_inserter(aidl.extraAudioDescriptors),
2344 legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor));
2345
2346 if (legacy.num_gains > std::size(legacy.gains)) {
2347 return unexpected(BAD_VALUE);
2348 }
2349 RETURN_IF_ERROR(
2350 convertRange(legacy.gains, legacy.gains + legacy.num_gains,
2351 std::back_inserter(aidl.gains),
2352 [isInput](const audio_gain& g) {
2353 return legacy2aidl_audio_gain_AudioGain(g, isInput);
2354 }));
2355 aidl.gains.resize(legacy.num_gains);
2356
2357 aidl.ext = VALUE_OR_RETURN(
2358 legacy2aidl_audio_port_v7_ext_AudioPortExt(legacy.ext, legacy.type));
2359
2360 AudioPortConfig aidlPortConfig = VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(
2361 legacy.active_config, isInput, aidl.id));
2362 if (aidlPortConfig.flags.has_value()) {
2363 aidl.flags = aidlPortConfig.flags.value();
2364 } else {
2365 aidl.flags = isInput ?
2366 AudioIoFlags::make<AudioIoFlags::Tag::input>(0) :
2367 AudioIoFlags::make<AudioIoFlags::Tag::output>(0);
2368 }
2369 return aidl;
2370}
2371
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]2372ConversionResult<audio_profile>
2373aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
2374 audio_profile legacy;
2375 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
2376
2377 if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
2378 return unexpected(BAD_VALUE);
2379 }
2380 RETURN_IF_ERROR(
2381 convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
2382 convertIntegral<int32_t, unsigned int>));
2383 legacy.num_sample_rates = aidl.sampleRates.size();
2384
2385 if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
2386 return unexpected(BAD_VALUE);
2387 }
2388 RETURN_IF_ERROR(
2389 convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
2390 [isInput](const AudioChannelLayout& l) {
2391 return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
2392 }));
2393 legacy.num_channel_masks = aidl.channelMasks.size();
2394
2395 legacy.encapsulation_type = VALUE_OR_RETURN(
2396 aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
2397 return legacy;
2398}
2399
2400ConversionResult<AudioProfile>
2401legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
2402 AudioProfile aidl;
2403 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
2404
2405 if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
2406 return unexpected(BAD_VALUE);
2407 }
2408 RETURN_IF_ERROR(
2409 convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
2410 std::back_inserter(aidl.sampleRates),
2411 convertIntegral<unsigned int, int32_t>));
2412
2413 if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
2414 return unexpected(BAD_VALUE);
2415 }
2416 RETURN_IF_ERROR(
2417 convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
2418 std::back_inserter(aidl.channelMasks),
2419 [isInput](audio_channel_mask_t m) {
2420 return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
2421 }));
2422
2423 aidl.encapsulationType = VALUE_OR_RETURN(
2424 legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2425 legacy.encapsulation_type));
2426 return aidl;
2427}
2428
2429ConversionResult<audio_gain>
2430aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
2431 audio_gain legacy;
2432 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
2433 legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
2434 aidl.channelMask, isInput));
2435 legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
2436 legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
2437 legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
2438 legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
2439 legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
2440 legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
2441 return legacy;
2442}
2443
2444ConversionResult<AudioGain>
2445legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
2446 AudioGain aidl;
2447 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
2448 aidl.channelMask = VALUE_OR_RETURN(
2449 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
2450 aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
2451 aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
2452 aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
2453 aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
2454 aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
2455 aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
2456 return aidl;
2457}
2458
2459ConversionResult<audio_mode_t>
2460aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
2461 switch (aidl) {
2462 case AudioMode::SYS_RESERVED_INVALID:
2463 return AUDIO_MODE_INVALID;
2464 case AudioMode::SYS_RESERVED_CURRENT:
2465 return AUDIO_MODE_CURRENT;
2466 case AudioMode::NORMAL:
2467 return AUDIO_MODE_NORMAL;
2468 case AudioMode::RINGTONE:
2469 return AUDIO_MODE_RINGTONE;
2470 case AudioMode::IN_CALL:
2471 return AUDIO_MODE_IN_CALL;
2472 case AudioMode::IN_COMMUNICATION:
2473 return AUDIO_MODE_IN_COMMUNICATION;
2474 case AudioMode::CALL_SCREEN:
2475 return AUDIO_MODE_CALL_SCREEN;
2476 case AudioMode::SYS_RESERVED_CALL_REDIRECT:
2477 return AUDIO_MODE_CALL_REDIRECT;
2478 case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
2479 return AUDIO_MODE_COMMUNICATION_REDIRECT;
2480 }
2481 return unexpected(BAD_VALUE);
2482}
2483
2484ConversionResult<AudioMode>
2485legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
2486 switch (legacy) {
2487 case AUDIO_MODE_INVALID:
2488 return AudioMode::SYS_RESERVED_INVALID;
2489 case AUDIO_MODE_CURRENT:
2490 return AudioMode::SYS_RESERVED_CURRENT;
2491 case AUDIO_MODE_NORMAL:
2492 return AudioMode::NORMAL;
2493 case AUDIO_MODE_RINGTONE:
2494 return AudioMode::RINGTONE;
2495 case AUDIO_MODE_IN_CALL:
2496 return AudioMode::IN_CALL;
2497 case AUDIO_MODE_IN_COMMUNICATION:
2498 return AudioMode::IN_COMMUNICATION;
2499 case AUDIO_MODE_CALL_SCREEN:
2500 return AudioMode::CALL_SCREEN;
2501 case AUDIO_MODE_CALL_REDIRECT:
2502 return AudioMode::SYS_RESERVED_CALL_REDIRECT;
2503 case AUDIO_MODE_COMMUNICATION_REDIRECT:
2504 return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
2505 case AUDIO_MODE_CNT:
2506 break;
2507 }
2508 return unexpected(BAD_VALUE);
2509}
2510
2511ConversionResult<audio_standard_t>
2512aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
2513 switch (aidl) {
2514 case AudioStandard::NONE:
2515 return AUDIO_STANDARD_NONE;
2516 case AudioStandard::EDID:
2517 return AUDIO_STANDARD_EDID;
2518 }
2519 return unexpected(BAD_VALUE);
2520}
2521
2522ConversionResult<AudioStandard>
2523legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
2524 switch (legacy) {
2525 case AUDIO_STANDARD_NONE:
2526 return AudioStandard::NONE;
2527 case AUDIO_STANDARD_EDID:
2528 return AudioStandard::EDID;
2529 }
2530 return unexpected(BAD_VALUE);
2531}
2532
2533ConversionResult<audio_extra_audio_descriptor>
2534aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
2535 const ExtraAudioDescriptor& aidl) {
2536 audio_extra_audio_descriptor legacy;
2537 legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
2538 if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2539 return unexpected(BAD_VALUE);
2540 }
2541 legacy.descriptor_length = aidl.audioDescriptor.size();
2542 std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
2543 std::begin(legacy.descriptor));
2544 legacy.encapsulation_type =
2545 VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2546 aidl.encapsulationType));
2547 return legacy;
2548}
2549
2550ConversionResult<ExtraAudioDescriptor>
2551legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
2552 const audio_extra_audio_descriptor& legacy) {
2553 ExtraAudioDescriptor aidl;
2554 aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
2555 if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
2556 return unexpected(BAD_VALUE);
2557 }
2558 aidl.audioDescriptor.resize(legacy.descriptor_length);
2559 std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
2560 aidl.audioDescriptor.begin());
2561 aidl.encapsulationType =
2562 VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2563 legacy.encapsulation_type));
2564 return aidl;
2565}
2566
2567ConversionResult<audio_encapsulation_type_t>
2568aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
2569 const AudioEncapsulationType& aidl) {
2570 switch (aidl) {
2571 case AudioEncapsulationType::NONE:
2572 return AUDIO_ENCAPSULATION_TYPE_NONE;
2573 case AudioEncapsulationType::IEC61937:
2574 return AUDIO_ENCAPSULATION_TYPE_IEC61937;
2575 case AudioEncapsulationType::PCM:
2576 return AUDIO_ENCAPSULATION_TYPE_PCM;
2577 }
2578 return unexpected(BAD_VALUE);
2579}
2580
2581ConversionResult<AudioEncapsulationType>
2582legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
2583 const audio_encapsulation_type_t & legacy) {
2584 switch (legacy) {
2585 case AUDIO_ENCAPSULATION_TYPE_NONE:
2586 return AudioEncapsulationType::NONE;
2587 case AUDIO_ENCAPSULATION_TYPE_IEC61937:
2588 return AudioEncapsulationType::IEC61937;
2589 case AUDIO_ENCAPSULATION_TYPE_PCM:
2590 return AudioEncapsulationType::PCM;
2591 }
2592 return unexpected(BAD_VALUE);
2593}
2594
Mikhail Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]2595ConversionResult<audio_dual_mono_mode_t>
2596aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(AudioDualMonoMode aidl) {
2597 switch (aidl) {
2598 case AudioDualMonoMode::OFF:
2599 return AUDIO_DUAL_MONO_MODE_OFF;
2600 case AudioDualMonoMode::LR:
2601 return AUDIO_DUAL_MONO_MODE_LR;
2602 case AudioDualMonoMode::LL:
2603 return AUDIO_DUAL_MONO_MODE_LL;
2604 case AudioDualMonoMode::RR:
2605 return AUDIO_DUAL_MONO_MODE_RR;
2606 }
2607 return unexpected(BAD_VALUE);
2608}
2609
2610ConversionResult<AudioDualMonoMode>
2611legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(audio_dual_mono_mode_t legacy) {
2612 switch (legacy) {
2613 case AUDIO_DUAL_MONO_MODE_OFF:
2614 return AudioDualMonoMode::OFF;
2615 case AUDIO_DUAL_MONO_MODE_LR:
2616 return AudioDualMonoMode::LR;
2617 case AUDIO_DUAL_MONO_MODE_LL:
2618 return AudioDualMonoMode::LL;
2619 case AUDIO_DUAL_MONO_MODE_RR:
2620 return AudioDualMonoMode::RR;
2621 }
2622 return unexpected(BAD_VALUE);
2623}
2624
2625ConversionResult<audio_timestretch_fallback_mode_t>
2626aidl2legacy_TimestretchFallbackMode_audio_timestretch_fallback_mode_t(
2627 AudioPlaybackRate::TimestretchFallbackMode aidl) {
2628 switch (aidl) {
2629 case AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_CUT_REPEAT:
2630 return AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT;
2631 case AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_DEFAULT:
2632 return AUDIO_TIMESTRETCH_FALLBACK_DEFAULT;
2633 case AudioPlaybackRate::TimestretchFallbackMode::MUTE:
2634 return AUDIO_TIMESTRETCH_FALLBACK_MUTE;
2635 case AudioPlaybackRate::TimestretchFallbackMode::FAIL:
2636 return AUDIO_TIMESTRETCH_FALLBACK_FAIL;
2637 }
2638 return unexpected(BAD_VALUE);
2639}
2640
2641ConversionResult<AudioPlaybackRate::TimestretchFallbackMode>
2642legacy2aidl_audio_timestretch_fallback_mode_t_TimestretchFallbackMode(
2643 audio_timestretch_fallback_mode_t legacy) {
2644 switch (legacy) {
2645 case AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT:
2646 return AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_CUT_REPEAT;
2647 case AUDIO_TIMESTRETCH_FALLBACK_DEFAULT:
2648 return AudioPlaybackRate::TimestretchFallbackMode::SYS_RESERVED_DEFAULT;
2649 case AUDIO_TIMESTRETCH_FALLBACK_MUTE:
2650 return AudioPlaybackRate::TimestretchFallbackMode::MUTE;
2651 case AUDIO_TIMESTRETCH_FALLBACK_FAIL:
2652 return AudioPlaybackRate::TimestretchFallbackMode::FAIL;
2653 }
2654 return unexpected(BAD_VALUE);
2655}
2656
2657ConversionResult<audio_timestretch_stretch_mode_t>
2658aidl2legacy_TimestretchMode_audio_timestretch_stretch_mode_t(
2659 AudioPlaybackRate::TimestretchMode aidl) {
2660 switch (aidl) {
2661 case AudioPlaybackRate::TimestretchMode::DEFAULT:
2662 return AUDIO_TIMESTRETCH_STRETCH_DEFAULT;
2663 case AudioPlaybackRate::TimestretchMode::VOICE:
2664 return AUDIO_TIMESTRETCH_STRETCH_VOICE;
2665 }
2666 return unexpected(BAD_VALUE);
2667}
2668
2669ConversionResult<AudioPlaybackRate::TimestretchMode>
2670legacy2aidl_audio_timestretch_stretch_mode_t_TimestretchMode(
2671 audio_timestretch_stretch_mode_t legacy) {
2672 switch (legacy) {
2673 case AUDIO_TIMESTRETCH_STRETCH_DEFAULT:
2674 return AudioPlaybackRate::TimestretchMode::DEFAULT;
2675 case AUDIO_TIMESTRETCH_STRETCH_VOICE:
2676 return AudioPlaybackRate::TimestretchMode::VOICE;
2677 }
2678 return unexpected(BAD_VALUE);
2679}
2680
2681ConversionResult<audio_playback_rate_t>
2682aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(const AudioPlaybackRate& aidl) {
2683 audio_playback_rate_t legacy;
2684 legacy.mSpeed = aidl.speed;
2685 legacy.mPitch = aidl.pitch;
2686 legacy.mFallbackMode = VALUE_OR_RETURN(
2687 aidl2legacy_TimestretchFallbackMode_audio_timestretch_fallback_mode_t(
2688 aidl.fallbackMode));
2689 legacy.mStretchMode = VALUE_OR_RETURN(
2690 aidl2legacy_TimestretchMode_audio_timestretch_stretch_mode_t(aidl.timestretchMode));
2691 return legacy;
2692}
2693
2694ConversionResult<AudioPlaybackRate>
2695legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(const audio_playback_rate_t& legacy) {
2696 AudioPlaybackRate aidl;
2697 aidl.speed = legacy.mSpeed;
2698 aidl.pitch = legacy.mPitch;
2699 aidl.fallbackMode = VALUE_OR_RETURN(
2700 legacy2aidl_audio_timestretch_fallback_mode_t_TimestretchFallbackMode(
2701 legacy.mFallbackMode));
2702 aidl.timestretchMode = VALUE_OR_RETURN(
2703 legacy2aidl_audio_timestretch_stretch_mode_t_TimestretchMode(legacy.mStretchMode));
2704 return aidl;
2705}
2706
2707ConversionResult<audio_latency_mode_t>
2708aidl2legacy_AudioLatencyMode_audio_latency_mode_t(AudioLatencyMode aidl) {
2709 switch (aidl) {
2710 case AudioLatencyMode::FREE:
2711 return AUDIO_LATENCY_MODE_FREE;
2712 case AudioLatencyMode::LOW:
2713 return AUDIO_LATENCY_MODE_LOW;
Mikhail Naganov4eb56562023-03-06 17:34:34 -0800[diff] [blame]2714 case AudioLatencyMode::DYNAMIC_SPATIAL_AUDIO_SOFTWARE:
2715 return AUDIO_LATENCY_MODE_DYNAMIC_SPATIAL_AUDIO_SOFTWARE;
2716 case AudioLatencyMode::DYNAMIC_SPATIAL_AUDIO_HARDWARE:
2717 return AUDIO_LATENCY_MODE_DYNAMIC_SPATIAL_AUDIO_HARDWARE;
Mikhail Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]2718 }
2719 return unexpected(BAD_VALUE);
2720}
2721ConversionResult<AudioLatencyMode>
2722legacy2aidl_audio_latency_mode_t_AudioLatencyMode(audio_latency_mode_t legacy) {
2723 switch (legacy) {
2724 case AUDIO_LATENCY_MODE_FREE:
2725 return AudioLatencyMode::FREE;
2726 case AUDIO_LATENCY_MODE_LOW:
2727 return AudioLatencyMode::LOW;
Mikhail Naganov4eb56562023-03-06 17:34:34 -0800[diff] [blame]2728 case AUDIO_LATENCY_MODE_DYNAMIC_SPATIAL_AUDIO_SOFTWARE:
2729 return AudioLatencyMode::DYNAMIC_SPATIAL_AUDIO_SOFTWARE;
2730 case AUDIO_LATENCY_MODE_DYNAMIC_SPATIAL_AUDIO_HARDWARE:
2731 return AudioLatencyMode::DYNAMIC_SPATIAL_AUDIO_HARDWARE;
Mikhail Naganovb1a075b2022-12-18 02:48:14 +0000[diff] [blame]2732 }
2733 return unexpected(BAD_VALUE);
2734}
2735
Mikhail Naganov2a6a3012023-02-13 11:45:03 -0800[diff] [blame]2736ConversionResult<audio_microphone_location_t>
2737aidl2legacy_MicrophoneInfoLocation_audio_microphone_location_t(MicrophoneInfo::Location aidl) {
2738 switch (aidl) {
2739 case MicrophoneInfo::Location::UNKNOWN:
2740 return AUDIO_MICROPHONE_LOCATION_UNKNOWN;
2741 case MicrophoneInfo::Location::MAINBODY:
2742 return AUDIO_MICROPHONE_LOCATION_MAINBODY;
2743 case MicrophoneInfo::Location::MAINBODY_MOVABLE:
2744 return AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE;
2745 case MicrophoneInfo::Location::PERIPHERAL:
2746 return AUDIO_MICROPHONE_LOCATION_PERIPHERAL;
2747 }
2748 return unexpected(BAD_VALUE);
2749}
2750ConversionResult<MicrophoneInfo::Location>
2751legacy2aidl_audio_microphone_location_t_MicrophoneInfoLocation(audio_microphone_location_t legacy) {
2752 switch (legacy) {
2753 case AUDIO_MICROPHONE_LOCATION_UNKNOWN:
2754 return MicrophoneInfo::Location::UNKNOWN;
2755 case AUDIO_MICROPHONE_LOCATION_MAINBODY:
2756 return MicrophoneInfo::Location::MAINBODY;
2757 case AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE:
2758 return MicrophoneInfo::Location::MAINBODY_MOVABLE;
2759 case AUDIO_MICROPHONE_LOCATION_PERIPHERAL:
2760 return MicrophoneInfo::Location::PERIPHERAL;
2761 }
2762 return unexpected(BAD_VALUE);
2763}
2764
2765ConversionResult<audio_microphone_group_t> aidl2legacy_int32_t_audio_microphone_group_t(
2766 int32_t aidl) {
2767 return convertReinterpret<audio_microphone_group_t>(aidl);
2768}
2769
2770ConversionResult<int32_t> legacy2aidl_audio_microphone_group_t_int32_t(
2771 audio_microphone_group_t legacy) {
2772 return convertReinterpret<int32_t>(legacy);
2773}
2774
2775ConversionResult<audio_microphone_directionality_t>
2776aidl2legacy_MicrophoneInfoDirectionality_audio_microphone_directionality_t(
2777 MicrophoneInfo::Directionality aidl) {
2778 switch (aidl) {
2779 case MicrophoneInfo::Directionality::UNKNOWN:
2780 return AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN;
2781 case MicrophoneInfo::Directionality::OMNI:
2782 return AUDIO_MICROPHONE_DIRECTIONALITY_OMNI;
2783 case MicrophoneInfo::Directionality::BI_DIRECTIONAL:
2784 return AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL;
2785 case MicrophoneInfo::Directionality::CARDIOID:
2786 return AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID;
2787 case MicrophoneInfo::Directionality::HYPER_CARDIOID:
2788 return AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID;
2789 case MicrophoneInfo::Directionality::SUPER_CARDIOID:
2790 return AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID;
2791 }
2792 return unexpected(BAD_VALUE);
2793}
2794ConversionResult<MicrophoneInfo::Directionality>
2795legacy2aidl_audio_microphone_directionality_t_MicrophoneInfoDirectionality(
2796 audio_microphone_directionality_t legacy) {
2797 switch (legacy) {
2798 case AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN:
2799 return MicrophoneInfo::Directionality::UNKNOWN;
2800 case AUDIO_MICROPHONE_DIRECTIONALITY_OMNI:
2801 return MicrophoneInfo::Directionality::OMNI;
2802 case AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL:
2803 return MicrophoneInfo::Directionality::BI_DIRECTIONAL;
2804 case AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID:
2805 return MicrophoneInfo::Directionality::CARDIOID;
2806 case AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID:
2807 return MicrophoneInfo::Directionality::HYPER_CARDIOID;
2808 case AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID:
2809 return MicrophoneInfo::Directionality::SUPER_CARDIOID;
2810 }
2811 return unexpected(BAD_VALUE);
2812}
2813
2814ConversionResult<audio_microphone_coordinate>
2815aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
2816 const MicrophoneInfo::Coordinate& aidl) {
2817 audio_microphone_coordinate legacy;
2818 legacy.x = aidl.x;
2819 legacy.y = aidl.y;
2820 legacy.z = aidl.z;
2821 return legacy;
2822}
2823ConversionResult<MicrophoneInfo::Coordinate>
2824legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
2825 const audio_microphone_coordinate& legacy) {
2826 MicrophoneInfo::Coordinate aidl;
2827 aidl.x = legacy.x;
2828 aidl.y = legacy.y;
2829 aidl.z = legacy.z;
2830 return aidl;
2831}
2832
2833ConversionResult<audio_microphone_channel_mapping_t>
2834aidl2legacy_MicrophoneDynamicInfoChannelMapping_audio_microphone_channel_mapping_t(
2835 MicrophoneDynamicInfo::ChannelMapping aidl) {
2836 switch (aidl) {
2837 case MicrophoneDynamicInfo::ChannelMapping::UNUSED:
2838 return AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
2839 case MicrophoneDynamicInfo::ChannelMapping::DIRECT:
2840 return AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT;
2841 case MicrophoneDynamicInfo::ChannelMapping::PROCESSED:
2842 return AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED;
2843 }
2844 return unexpected(BAD_VALUE);
2845}
2846ConversionResult<MicrophoneDynamicInfo::ChannelMapping>
2847legacy2aidl_audio_microphone_channel_mapping_t_MicrophoneDynamicInfoChannelMapping(
2848 audio_microphone_channel_mapping_t legacy) {
2849 switch (legacy) {
2850 case AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED:
2851 return MicrophoneDynamicInfo::ChannelMapping::UNUSED;
2852 case AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT:
2853 return MicrophoneDynamicInfo::ChannelMapping::DIRECT;
2854 case AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED:
2855 return MicrophoneDynamicInfo::ChannelMapping::PROCESSED;
2856 }
2857 return unexpected(BAD_VALUE);
2858}
2859
2860ConversionResult<audio_microphone_characteristic_t>
2861aidl2legacy_MicrophoneInfos_audio_microphone_characteristic_t(
2862 const MicrophoneInfo& aidlInfo, const MicrophoneDynamicInfo& aidlDynamic) {
2863 static const audio_microphone_coordinate kCoordinateUnknown = {
2864 AUDIO_MICROPHONE_COORDINATE_UNKNOWN, AUDIO_MICROPHONE_COORDINATE_UNKNOWN,
2865 AUDIO_MICROPHONE_COORDINATE_UNKNOWN };
2866 audio_microphone_characteristic_t legacy{};
2867 if (aidlInfo.id != aidlDynamic.id) {
2868 return unexpected(BAD_VALUE);
2869 }
2870 // Note: in the legacy structure, 'device_id' is the mic's ID, 'id' is APM port id.
2871 RETURN_IF_ERROR(aidl2legacy_string(aidlInfo.id, legacy.device_id, AUDIO_MICROPHONE_ID_MAX_LEN));
2872 RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
2873 aidlInfo.device, &legacy.device, legacy.address));
2874 legacy.location = VALUE_OR_RETURN(
2875 aidl2legacy_MicrophoneInfoLocation_audio_microphone_location_t(aidlInfo.location));
2876 legacy.group = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_microphone_group_t(aidlInfo.group));
2877 // For some reason, the legacy field is unsigned, however in the SDK layer it is signed,
2878 // as it is in AIDL. So, use UINT_MAX for INDEX_IN_THE_GROUP_UNKNOWN which is -1.
2879 if (aidlInfo.indexInTheGroup != MicrophoneInfo::INDEX_IN_THE_GROUP_UNKNOWN) {
2880 legacy.index_in_the_group = VALUE_OR_RETURN(
2881 convertReinterpret<unsigned int>(aidlInfo.indexInTheGroup));
2882 } else {
2883 legacy.index_in_the_group = UINT_MAX;
2884 }
2885 if (aidlInfo.sensitivity.has_value()) {
2886 legacy.sensitivity = aidlInfo.sensitivity.value().leveldBFS;
2887 legacy.max_spl = aidlInfo.sensitivity.value().maxSpldB;
2888 legacy.min_spl = aidlInfo.sensitivity.value().minSpldB;
2889 } else {
2890 legacy.sensitivity = AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN;
2891 legacy.max_spl = AUDIO_MICROPHONE_SPL_UNKNOWN;
2892 legacy.min_spl = AUDIO_MICROPHONE_SPL_UNKNOWN;
2893 }
2894 legacy.directionality = VALUE_OR_RETURN(
2895 aidl2legacy_MicrophoneInfoDirectionality_audio_microphone_directionality_t(
2896 aidlInfo.directionality));
2897 if (aidlInfo.frequencyResponse.size() > AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES) {
2898 return unexpected(BAD_VALUE);
2899 }
2900 legacy.num_frequency_responses = 0;
2901 for (const auto& p: aidlInfo.frequencyResponse) {
2902 legacy.frequency_responses[0][legacy.num_frequency_responses] = p.frequencyHz;
2903 legacy.frequency_responses[1][legacy.num_frequency_responses++] = p.leveldB;
2904 }
2905 if (aidlInfo.position.has_value()) {
2906 legacy.geometric_location = VALUE_OR_RETURN(
2907 aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
2908 aidlInfo.position.value()));
2909 } else {
2910 legacy.geometric_location = kCoordinateUnknown;
2911 }
2912 if (aidlInfo.orientation.has_value()) {
2913 legacy.orientation = VALUE_OR_RETURN(
2914 aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
2915 aidlInfo.orientation.value()));
2916 } else {
2917 legacy.orientation = kCoordinateUnknown;
2918 }
2919 if (aidlDynamic.channelMapping.size() > AUDIO_CHANNEL_COUNT_MAX) {
2920 return unexpected(BAD_VALUE);
2921 }
2922 size_t i = 0;
2923 for (; i < aidlDynamic.channelMapping.size(); ++i) {
2924 legacy.channel_mapping[i] = VALUE_OR_RETURN(
2925 aidl2legacy_MicrophoneDynamicInfoChannelMapping_audio_microphone_channel_mapping_t(
2926 aidlDynamic.channelMapping[i]));
2927 }
2928 for (; i < AUDIO_CHANNEL_COUNT_MAX; ++i) {
2929 legacy.channel_mapping[i] = AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
2930 }
2931 return legacy;
2932}
2933
2934status_t
2935legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfos(
2936 const audio_microphone_characteristic_t& legacy,
2937 MicrophoneInfo* aidlInfo, MicrophoneDynamicInfo* aidlDynamic) {
2938 aidlInfo->id = VALUE_OR_RETURN_STATUS(
2939 legacy2aidl_string(legacy.device_id, AUDIO_MICROPHONE_ID_MAX_LEN));
2940 aidlDynamic->id = aidlInfo->id;
2941 aidlInfo->device = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_device_AudioDevice(
2942 legacy.device, legacy.address));
2943 aidlInfo->location = VALUE_OR_RETURN_STATUS(
2944 legacy2aidl_audio_microphone_location_t_MicrophoneInfoLocation(legacy.location));
2945 aidlInfo->group = VALUE_OR_RETURN_STATUS(
2946 legacy2aidl_audio_microphone_group_t_int32_t(legacy.group));
2947 // For some reason, the legacy field is unsigned, however in the SDK layer it is signed,
2948 // as it is in AIDL. So, use UINT_MAX for INDEX_IN_THE_GROUP_UNKNOWN which is -1.
2949 if (legacy.index_in_the_group != UINT_MAX) {
2950 aidlInfo->indexInTheGroup = VALUE_OR_RETURN_STATUS(
2951 convertReinterpret<int32_t>(legacy.index_in_the_group));
2952 } else {
2953 aidlInfo->indexInTheGroup = MicrophoneInfo::INDEX_IN_THE_GROUP_UNKNOWN;
2954 }
2955 if (legacy.sensitivity != AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN &&
2956 legacy.max_spl != AUDIO_MICROPHONE_SPL_UNKNOWN &&
2957 legacy.min_spl != AUDIO_MICROPHONE_SPL_UNKNOWN) {
2958 MicrophoneInfo::Sensitivity sensitivity;
2959 sensitivity.leveldBFS = legacy.sensitivity;
2960 sensitivity.maxSpldB = legacy.max_spl;
2961 sensitivity.minSpldB = legacy.min_spl;
2962 aidlInfo->sensitivity = std::move(sensitivity);
2963 } else {
2964 aidlInfo->sensitivity = {};
2965 }
2966 aidlInfo->directionality = VALUE_OR_RETURN_STATUS(
2967 legacy2aidl_audio_microphone_directionality_t_MicrophoneInfoDirectionality(
2968 legacy.directionality));
2969 if (legacy.num_frequency_responses > AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES) {
2970 return BAD_VALUE;
2971 }
2972 aidlInfo->frequencyResponse.resize(legacy.num_frequency_responses);
2973 for (size_t i = 0; i < legacy.num_frequency_responses; ++i) {
2974 aidlInfo->frequencyResponse[i].frequencyHz = legacy.frequency_responses[0][i];
2975 aidlInfo->frequencyResponse[i].leveldB = legacy.frequency_responses[1][i];
2976 }
2977 if (legacy.geometric_location.x != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
2978 legacy.geometric_location.y != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
2979 legacy.geometric_location.z != AUDIO_MICROPHONE_COORDINATE_UNKNOWN) {
2980 aidlInfo->position = VALUE_OR_RETURN_STATUS(
2981 legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
2982 legacy.geometric_location));
2983 } else {
2984 aidlInfo->position = {};
2985 }
2986 if (legacy.orientation.x != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
2987 legacy.orientation.y != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
2988 legacy.orientation.z != AUDIO_MICROPHONE_COORDINATE_UNKNOWN) {
2989 aidlInfo->orientation = VALUE_OR_RETURN_STATUS(
2990 legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
2991 legacy.orientation));
2992 } else {
2993 aidlInfo->orientation = {};
2994 }
2995 size_t channelsUsed = AUDIO_CHANNEL_COUNT_MAX;
2996 while (channelsUsed != 0 &&
2997 legacy.channel_mapping[--channelsUsed] == AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED) {}
2998 // Doing an increment is correct even when channel 0 is 'UNUSED',
2999 // that's because AIDL requires to have at least 1 element in the mapping.
3000 ++channelsUsed;
3001 aidlDynamic->channelMapping.resize(channelsUsed);
3002 for (size_t i = 0; i < channelsUsed; ++i) {
3003 aidlDynamic->channelMapping[i] = VALUE_OR_RETURN_STATUS(
3004 legacy2aidl_audio_microphone_channel_mapping_t_MicrophoneDynamicInfoChannelMapping(
3005 legacy.channel_mapping[i]));
3006 }
3007 return OK;
3008}
3009
Shunkai Yao4b574cf2022-12-14 04:27:19 +0000[diff] [blame]3010} // namespace android
3011
3012#if defined(BACKEND_NDK)
3013} // aidl
Mikhail Naganov72cd0682023-01-17 17:58:26 -0800[diff] [blame]3014#endif