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