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