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