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