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