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