blob: aba4646b56453d240f9d7f7af1588f7db60adf4a [file] [log] [blame]
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001/*
2 * Copyright (C) 2020 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
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070017#define LOG_TAG "AidlConversion"
18//#define LOG_NDEBUG 0
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070019#include <utils/Log.h>
20
21#include "media/AidlConversion.h"
22
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080023#include <media/ShmemCompat.h>
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -070024
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070025////////////////////////////////////////////////////////////////////////////////////////////////////
26// Utilities
27
28namespace android {
29
30using base::unexpected;
31
32namespace {
33
34////////////////////////////////////////////////////////////////////////////////////////////////////
35// The code below establishes:
36// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
37// enum types (in which case it evaluates to std::underlying_type_T<T>).
38
39template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
40struct IntegralTypeOfStruct {
41 using Type = T;
42};
43
44template<typename T>
45struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
46 using Type = std::underlying_type_t<T>;
47};
48
49template<typename T>
50using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;
51
52////////////////////////////////////////////////////////////////////////////////////////////////////
53// Utilities for handling bitmasks.
54
55template<typename Enum>
56Enum index2enum_index(int index) {
57 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
58 return static_cast<Enum>(index);
59}
60
61template<typename Enum>
62Enum index2enum_bitmask(int index) {
63 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
64 return static_cast<Enum>(1 << index);
65}
66
67template<typename Mask, typename Enum>
68Mask enumToMask_bitmask(Enum e) {
69 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
70 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
71 return static_cast<Mask>(e);
72}
73
74template<typename Mask, typename Enum>
75Mask enumToMask_index(Enum e) {
76 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
77 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
78 return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
79 << static_cast<int>(e));
80}
81
82template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
83ConversionResult<DestMask> convertBitmask(
84 SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
85 const std::function<SrcEnum(int)>& srcIndexToEnum,
86 const std::function<DestMask(DestEnum)>& destEnumToMask) {
87 using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
88 using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;
89
90 UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
91 UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);
92
93 int srcBitIndex = 0;
94 while (usrc != 0) {
95 if (usrc & 1) {
96 SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
97 DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
98 DestMask destMask = destEnumToMask(destEnum);
99 dest |= destMask;
100 }
101 ++srcBitIndex;
102 usrc >>= 1;
103 }
104 return static_cast<DestMask>(dest);
105}
106
107template<typename Mask, typename Enum>
108bool bitmaskIsSet(Mask mask, Enum index) {
109 return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
110}
111
112////////////////////////////////////////////////////////////////////////////////////////////////////
113
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700114enum class Direction {
115 INPUT, OUTPUT
116};
117
118ConversionResult<Direction> direction(media::AudioPortRole role, media::AudioPortType type) {
119 switch (type) {
Andy Hung3f69c162020-12-09 12:08:48 -0800120 case media::AudioPortType::NONE:
121 case media::AudioPortType::SESSION:
122 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700123 case media::AudioPortType::DEVICE:
124 switch (role) {
Andy Hung3f69c162020-12-09 12:08:48 -0800125 case media::AudioPortRole::NONE:
126 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700127 case media::AudioPortRole::SOURCE:
128 return Direction::INPUT;
129 case media::AudioPortRole::SINK:
130 return Direction::OUTPUT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700131 }
132 break;
133 case media::AudioPortType::MIX:
134 switch (role) {
Andy Hung3f69c162020-12-09 12:08:48 -0800135 case media::AudioPortRole::NONE:
136 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700137 case media::AudioPortRole::SOURCE:
138 return Direction::OUTPUT;
139 case media::AudioPortRole::SINK:
140 return Direction::INPUT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700141 }
142 break;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700143 }
144 return unexpected(BAD_VALUE);
145}
146
147ConversionResult<Direction> direction(audio_port_role_t role, audio_port_type_t type) {
148 switch (type) {
Andy Hung3f69c162020-12-09 12:08:48 -0800149 case AUDIO_PORT_TYPE_NONE:
150 case AUDIO_PORT_TYPE_SESSION:
151 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700152 case AUDIO_PORT_TYPE_DEVICE:
153 switch (role) {
Andy Hung3f69c162020-12-09 12:08:48 -0800154 case AUDIO_PORT_ROLE_NONE:
155 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700156 case AUDIO_PORT_ROLE_SOURCE:
157 return Direction::INPUT;
158 case AUDIO_PORT_ROLE_SINK:
159 return Direction::OUTPUT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700160 }
161 break;
162 case AUDIO_PORT_TYPE_MIX:
163 switch (role) {
Andy Hung3f69c162020-12-09 12:08:48 -0800164 case AUDIO_PORT_ROLE_NONE:
165 break; // must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700166 case AUDIO_PORT_ROLE_SOURCE:
167 return Direction::OUTPUT;
168 case AUDIO_PORT_ROLE_SINK:
169 return Direction::INPUT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700170 }
171 break;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700172 }
173 return unexpected(BAD_VALUE);
174}
175
176} // namespace
177
178////////////////////////////////////////////////////////////////////////////////////////////////////
179// Converters
180
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700181status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
182 if (aidl.size() > maxSize - 1) {
183 return BAD_VALUE;
184 }
185 aidl.copy(dest, aidl.size());
186 dest[aidl.size()] = '\0';
187 return OK;
188}
189
190ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
191 if (legacy == nullptr) {
192 return unexpected(BAD_VALUE);
193 }
194 if (strnlen(legacy, maxSize) == maxSize) {
195 // No null-terminator.
196 return unexpected(BAD_VALUE);
197 }
198 return std::string(legacy);
199}
200
201ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
202 return convertReinterpret<audio_module_handle_t>(aidl);
203}
204
205ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
206 return convertReinterpret<int32_t>(legacy);
207}
208
209ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
210 return convertReinterpret<audio_io_handle_t>(aidl);
211}
212
213ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
214 return convertReinterpret<int32_t>(legacy);
215}
216
217ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
218 return convertReinterpret<audio_port_handle_t>(aidl);
219}
220
221ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
222 return convertReinterpret<int32_t>(legacy);
223}
224
225ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
226 return convertReinterpret<audio_patch_handle_t>(aidl);
227}
228
229ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
230 return convertReinterpret<int32_t>(legacy);
231}
232
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800233ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
234 return convertReinterpret<audio_unique_id_t>(aidl);
235}
236
237ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
238 return convertReinterpret<int32_t>(legacy);
239}
240
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800241ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl) {
242 return convertReinterpret<audio_hw_sync_t>(aidl);
243}
244
245ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy) {
246 return convertReinterpret<int32_t>(legacy);
247}
248
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800249ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
250 return convertReinterpret<pid_t>(aidl);
251}
252
253ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
254 return convertReinterpret<int32_t>(legacy);
255}
256
257ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
258 return convertReinterpret<uid_t>(aidl);
259}
260
261ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
262 return convertReinterpret<int32_t>(legacy);
263}
264
265ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
266 return String16(aidl.data(), aidl.size());
267}
268
269ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
270 return std::string(String8(legacy).c_str());
271}
272
Ytai Ben-Tsvice182942020-11-04 14:48:01 -0800273ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {
274 return String8(aidl.data(), aidl.size());
275}
276
277ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {
278 return std::string(legacy.c_str());
279}
280
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700281// The legacy enum is unnamed. Thus, we use int.
282ConversionResult<int> aidl2legacy_AudioPortConfigType(media::AudioPortConfigType aidl) {
283 switch (aidl) {
284 case media::AudioPortConfigType::SAMPLE_RATE:
285 return AUDIO_PORT_CONFIG_SAMPLE_RATE;
286 case media::AudioPortConfigType::CHANNEL_MASK:
287 return AUDIO_PORT_CONFIG_CHANNEL_MASK;
288 case media::AudioPortConfigType::FORMAT:
289 return AUDIO_PORT_CONFIG_FORMAT;
Hayden Gomes1117ea22020-11-20 11:06:37 -0800290 case media::AudioPortConfigType::GAIN:
291 return AUDIO_PORT_CONFIG_GAIN;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700292 case media::AudioPortConfigType::FLAGS:
293 return AUDIO_PORT_CONFIG_FLAGS;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700294 }
Hayden Gomes1117ea22020-11-20 11:06:37 -0800295 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700296}
297
298// The legacy enum is unnamed. Thus, we use int.
299ConversionResult<media::AudioPortConfigType> legacy2aidl_AudioPortConfigType(int legacy) {
300 switch (legacy) {
301 case AUDIO_PORT_CONFIG_SAMPLE_RATE:
302 return media::AudioPortConfigType::SAMPLE_RATE;
303 case AUDIO_PORT_CONFIG_CHANNEL_MASK:
304 return media::AudioPortConfigType::CHANNEL_MASK;
305 case AUDIO_PORT_CONFIG_FORMAT:
306 return media::AudioPortConfigType::FORMAT;
Hayden Gomes1117ea22020-11-20 11:06:37 -0800307 case AUDIO_PORT_CONFIG_GAIN:
308 return media::AudioPortConfigType::GAIN;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700309 case AUDIO_PORT_CONFIG_FLAGS:
310 return media::AudioPortConfigType::FLAGS;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700311 }
Hayden Gomes1117ea22020-11-20 11:06:37 -0800312 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700313}
314
315ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl) {
316 return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(
317 aidl, aidl2legacy_AudioPortConfigType,
318 // AudioPortConfigType enum is index-based.
319 index2enum_index<media::AudioPortConfigType>,
320 // AUDIO_PORT_CONFIG_* flags are mask-based.
321 enumToMask_bitmask<unsigned int, int>);
322}
323
324ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) {
325 return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(
326 legacy, legacy2aidl_AudioPortConfigType,
327 // AUDIO_PORT_CONFIG_* flags are mask-based.
328 index2enum_bitmask<unsigned>,
329 // AudioPortConfigType enum is index-based.
330 enumToMask_index<int32_t, media::AudioPortConfigType>);
331}
332
333ConversionResult<audio_channel_mask_t> aidl2legacy_int32_t_audio_channel_mask_t(int32_t aidl) {
334 // TODO(ytai): should we convert bit-by-bit?
335 // One problem here is that the representation is both opaque and is different based on the
336 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
337 return convertReinterpret<audio_channel_mask_t>(aidl);
338}
339
340ConversionResult<int32_t> legacy2aidl_audio_channel_mask_t_int32_t(audio_channel_mask_t legacy) {
341 // TODO(ytai): should we convert bit-by-bit?
342 // One problem here is that the representation is both opaque and is different based on the
343 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
344 return convertReinterpret<int32_t>(legacy);
345}
346
347ConversionResult<audio_io_config_event> aidl2legacy_AudioIoConfigEvent_audio_io_config_event(
348 media::AudioIoConfigEvent aidl) {
349 switch (aidl) {
350 case media::AudioIoConfigEvent::OUTPUT_REGISTERED:
351 return AUDIO_OUTPUT_REGISTERED;
352 case media::AudioIoConfigEvent::OUTPUT_OPENED:
353 return AUDIO_OUTPUT_OPENED;
354 case media::AudioIoConfigEvent::OUTPUT_CLOSED:
355 return AUDIO_OUTPUT_CLOSED;
356 case media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED:
357 return AUDIO_OUTPUT_CONFIG_CHANGED;
358 case media::AudioIoConfigEvent::INPUT_REGISTERED:
359 return AUDIO_INPUT_REGISTERED;
360 case media::AudioIoConfigEvent::INPUT_OPENED:
361 return AUDIO_INPUT_OPENED;
362 case media::AudioIoConfigEvent::INPUT_CLOSED:
363 return AUDIO_INPUT_CLOSED;
364 case media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED:
365 return AUDIO_INPUT_CONFIG_CHANGED;
366 case media::AudioIoConfigEvent::CLIENT_STARTED:
367 return AUDIO_CLIENT_STARTED;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700368 }
Andy Hung3f69c162020-12-09 12:08:48 -0800369 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700370}
371
372ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_AudioIoConfigEvent(
373 audio_io_config_event legacy) {
374 switch (legacy) {
375 case AUDIO_OUTPUT_REGISTERED:
376 return media::AudioIoConfigEvent::OUTPUT_REGISTERED;
377 case AUDIO_OUTPUT_OPENED:
378 return media::AudioIoConfigEvent::OUTPUT_OPENED;
379 case AUDIO_OUTPUT_CLOSED:
380 return media::AudioIoConfigEvent::OUTPUT_CLOSED;
381 case AUDIO_OUTPUT_CONFIG_CHANGED:
382 return media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED;
383 case AUDIO_INPUT_REGISTERED:
384 return media::AudioIoConfigEvent::INPUT_REGISTERED;
385 case AUDIO_INPUT_OPENED:
386 return media::AudioIoConfigEvent::INPUT_OPENED;
387 case AUDIO_INPUT_CLOSED:
388 return media::AudioIoConfigEvent::INPUT_CLOSED;
389 case AUDIO_INPUT_CONFIG_CHANGED:
390 return media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED;
391 case AUDIO_CLIENT_STARTED:
392 return media::AudioIoConfigEvent::CLIENT_STARTED;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700393 }
Andy Hung3f69c162020-12-09 12:08:48 -0800394 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700395}
396
397ConversionResult<audio_port_role_t> aidl2legacy_AudioPortRole_audio_port_role_t(
398 media::AudioPortRole aidl) {
399 switch (aidl) {
400 case media::AudioPortRole::NONE:
401 return AUDIO_PORT_ROLE_NONE;
402 case media::AudioPortRole::SOURCE:
403 return AUDIO_PORT_ROLE_SOURCE;
404 case media::AudioPortRole::SINK:
405 return AUDIO_PORT_ROLE_SINK;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700406 }
Andy Hung3f69c162020-12-09 12:08:48 -0800407 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700408}
409
410ConversionResult<media::AudioPortRole> legacy2aidl_audio_port_role_t_AudioPortRole(
411 audio_port_role_t legacy) {
412 switch (legacy) {
413 case AUDIO_PORT_ROLE_NONE:
414 return media::AudioPortRole::NONE;
415 case AUDIO_PORT_ROLE_SOURCE:
416 return media::AudioPortRole::SOURCE;
417 case AUDIO_PORT_ROLE_SINK:
418 return media::AudioPortRole::SINK;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700419 }
Andy Hung3f69c162020-12-09 12:08:48 -0800420 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700421}
422
423ConversionResult<audio_port_type_t> aidl2legacy_AudioPortType_audio_port_type_t(
424 media::AudioPortType aidl) {
425 switch (aidl) {
426 case media::AudioPortType::NONE:
427 return AUDIO_PORT_TYPE_NONE;
428 case media::AudioPortType::DEVICE:
429 return AUDIO_PORT_TYPE_DEVICE;
430 case media::AudioPortType::MIX:
431 return AUDIO_PORT_TYPE_MIX;
432 case media::AudioPortType::SESSION:
433 return AUDIO_PORT_TYPE_SESSION;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700434 }
Andy Hung3f69c162020-12-09 12:08:48 -0800435 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700436}
437
438ConversionResult<media::AudioPortType> legacy2aidl_audio_port_type_t_AudioPortType(
439 audio_port_type_t legacy) {
440 switch (legacy) {
441 case AUDIO_PORT_TYPE_NONE:
442 return media::AudioPortType::NONE;
443 case AUDIO_PORT_TYPE_DEVICE:
444 return media::AudioPortType::DEVICE;
445 case AUDIO_PORT_TYPE_MIX:
446 return media::AudioPortType::MIX;
447 case AUDIO_PORT_TYPE_SESSION:
448 return media::AudioPortType::SESSION;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700449 }
Andy Hung3f69c162020-12-09 12:08:48 -0800450 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700451}
452
453ConversionResult<audio_format_t> aidl2legacy_AudioFormat_audio_format_t(
454 media::audio::common::AudioFormat aidl) {
455 // This relies on AudioFormat being kept in sync with audio_format_t.
456 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
457 return static_cast<audio_format_t>(aidl);
458}
459
460ConversionResult<media::audio::common::AudioFormat> legacy2aidl_audio_format_t_AudioFormat(
461 audio_format_t legacy) {
462 // This relies on AudioFormat being kept in sync with audio_format_t.
463 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
464 return static_cast<media::audio::common::AudioFormat>(legacy);
465}
466
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800467ConversionResult<audio_gain_mode_t> aidl2legacy_AudioGainMode_audio_gain_mode_t(media::AudioGainMode aidl) {
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700468 switch (aidl) {
469 case media::AudioGainMode::JOINT:
470 return AUDIO_GAIN_MODE_JOINT;
471 case media::AudioGainMode::CHANNELS:
472 return AUDIO_GAIN_MODE_CHANNELS;
473 case media::AudioGainMode::RAMP:
474 return AUDIO_GAIN_MODE_RAMP;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700475 }
Andy Hung3f69c162020-12-09 12:08:48 -0800476 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700477}
478
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800479ConversionResult<media::AudioGainMode> legacy2aidl_audio_gain_mode_t_AudioGainMode(audio_gain_mode_t legacy) {
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700480 switch (legacy) {
481 case AUDIO_GAIN_MODE_JOINT:
482 return media::AudioGainMode::JOINT;
483 case AUDIO_GAIN_MODE_CHANNELS:
484 return media::AudioGainMode::CHANNELS;
485 case AUDIO_GAIN_MODE_RAMP:
486 return media::AudioGainMode::RAMP;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700487 }
Andy Hung3f69c162020-12-09 12:08:48 -0800488 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700489}
490
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800491ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl) {
492 return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, media::AudioGainMode>(
493 aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700494 // AudioGainMode is index-based.
495 index2enum_index<media::AudioGainMode>,
496 // AUDIO_GAIN_MODE_* constants are mask-based.
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800497 enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700498}
499
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800500ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_mask_int32_t(audio_gain_mode_t legacy) {
501 return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, audio_gain_mode_t>(
502 legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700503 // AUDIO_GAIN_MODE_* constants are mask-based.
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800504 index2enum_bitmask<audio_gain_mode_t>,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700505 // AudioGainMode is index-based.
506 enumToMask_index<int32_t, media::AudioGainMode>);
507}
508
509ConversionResult<audio_devices_t> aidl2legacy_int32_t_audio_devices_t(int32_t aidl) {
510 // TODO(ytai): bitfield?
511 return convertReinterpret<audio_devices_t>(aidl);
512}
513
514ConversionResult<int32_t> legacy2aidl_audio_devices_t_int32_t(audio_devices_t legacy) {
515 // TODO(ytai): bitfield?
516 return convertReinterpret<int32_t>(legacy);
517}
518
519ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
520 const media::AudioGainConfig& aidl, media::AudioPortRole role, media::AudioPortType type) {
521 audio_gain_config legacy;
522 legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800523 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700524 legacy.channel_mask =
525 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
526 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
527 const bool isJoint = bitmaskIsSet(aidl.mode, media::AudioGainMode::JOINT);
528 size_t numValues = isJoint ? 1
529 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
530 : audio_channel_count_from_out_mask(legacy.channel_mask);
531 if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
532 return unexpected(BAD_VALUE);
533 }
534 for (size_t i = 0; i < numValues; ++i) {
535 legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
536 }
537 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
538 return legacy;
539}
540
541ConversionResult<media::AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
542 const audio_gain_config& legacy, audio_port_role_t role, audio_port_type_t type) {
543 media::AudioGainConfig aidl;
544 aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800545 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_mask_int32_t(legacy.mode));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700546 aidl.channelMask =
547 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
548 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
549 const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
550 size_t numValues = isJoint ? 1
551 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
552 : audio_channel_count_from_out_mask(legacy.channel_mask);
553 aidl.values.resize(numValues);
554 for (size_t i = 0; i < numValues; ++i) {
555 aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
556 }
557 aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
558 return aidl;
559}
560
561ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
562 media::AudioInputFlags aidl) {
563 switch (aidl) {
564 case media::AudioInputFlags::FAST:
565 return AUDIO_INPUT_FLAG_FAST;
566 case media::AudioInputFlags::HW_HOTWORD:
567 return AUDIO_INPUT_FLAG_HW_HOTWORD;
568 case media::AudioInputFlags::RAW:
569 return AUDIO_INPUT_FLAG_RAW;
570 case media::AudioInputFlags::SYNC:
571 return AUDIO_INPUT_FLAG_SYNC;
572 case media::AudioInputFlags::MMAP_NOIRQ:
573 return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
574 case media::AudioInputFlags::VOIP_TX:
575 return AUDIO_INPUT_FLAG_VOIP_TX;
576 case media::AudioInputFlags::HW_AV_SYNC:
577 return AUDIO_INPUT_FLAG_HW_AV_SYNC;
578 case media::AudioInputFlags::DIRECT:
579 return AUDIO_INPUT_FLAG_DIRECT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700580 }
Andy Hung3f69c162020-12-09 12:08:48 -0800581 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700582}
583
584ConversionResult<media::AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
585 audio_input_flags_t legacy) {
586 switch (legacy) {
Andy Hung3f69c162020-12-09 12:08:48 -0800587 case AUDIO_INPUT_FLAG_NONE:
588 break; // shouldn't get here. must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700589 case AUDIO_INPUT_FLAG_FAST:
590 return media::AudioInputFlags::FAST;
591 case AUDIO_INPUT_FLAG_HW_HOTWORD:
592 return media::AudioInputFlags::HW_HOTWORD;
593 case AUDIO_INPUT_FLAG_RAW:
594 return media::AudioInputFlags::RAW;
595 case AUDIO_INPUT_FLAG_SYNC:
596 return media::AudioInputFlags::SYNC;
597 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
598 return media::AudioInputFlags::MMAP_NOIRQ;
599 case AUDIO_INPUT_FLAG_VOIP_TX:
600 return media::AudioInputFlags::VOIP_TX;
601 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
602 return media::AudioInputFlags::HW_AV_SYNC;
603 case AUDIO_INPUT_FLAG_DIRECT:
604 return media::AudioInputFlags::DIRECT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700605 }
Andy Hung3f69c162020-12-09 12:08:48 -0800606 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700607}
608
609ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
610 media::AudioOutputFlags aidl) {
611 switch (aidl) {
612 case media::AudioOutputFlags::DIRECT:
613 return AUDIO_OUTPUT_FLAG_DIRECT;
614 case media::AudioOutputFlags::PRIMARY:
615 return AUDIO_OUTPUT_FLAG_PRIMARY;
616 case media::AudioOutputFlags::FAST:
617 return AUDIO_OUTPUT_FLAG_FAST;
618 case media::AudioOutputFlags::DEEP_BUFFER:
619 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
620 case media::AudioOutputFlags::COMPRESS_OFFLOAD:
621 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
622 case media::AudioOutputFlags::NON_BLOCKING:
623 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
624 case media::AudioOutputFlags::HW_AV_SYNC:
625 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
626 case media::AudioOutputFlags::TTS:
627 return AUDIO_OUTPUT_FLAG_TTS;
628 case media::AudioOutputFlags::RAW:
629 return AUDIO_OUTPUT_FLAG_RAW;
630 case media::AudioOutputFlags::SYNC:
631 return AUDIO_OUTPUT_FLAG_SYNC;
632 case media::AudioOutputFlags::IEC958_NONAUDIO:
633 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
634 case media::AudioOutputFlags::DIRECT_PCM:
635 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
636 case media::AudioOutputFlags::MMAP_NOIRQ:
637 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
638 case media::AudioOutputFlags::VOIP_RX:
639 return AUDIO_OUTPUT_FLAG_VOIP_RX;
640 case media::AudioOutputFlags::INCALL_MUSIC:
641 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
Eric Laurent90fe31c2020-11-26 20:06:35 +0100642 case media::AudioOutputFlags::GAPLESS_OFFLOAD:
643 return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700644 }
Andy Hung3f69c162020-12-09 12:08:48 -0800645 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700646}
647
648ConversionResult<media::AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
649 audio_output_flags_t legacy) {
650 switch (legacy) {
Andy Hung3f69c162020-12-09 12:08:48 -0800651 case AUDIO_OUTPUT_FLAG_NONE:
652 break; // shouldn't get here. must be listed -Werror,-Wswitch
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700653 case AUDIO_OUTPUT_FLAG_DIRECT:
654 return media::AudioOutputFlags::DIRECT;
655 case AUDIO_OUTPUT_FLAG_PRIMARY:
656 return media::AudioOutputFlags::PRIMARY;
657 case AUDIO_OUTPUT_FLAG_FAST:
658 return media::AudioOutputFlags::FAST;
659 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
660 return media::AudioOutputFlags::DEEP_BUFFER;
661 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
662 return media::AudioOutputFlags::COMPRESS_OFFLOAD;
663 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
664 return media::AudioOutputFlags::NON_BLOCKING;
665 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
666 return media::AudioOutputFlags::HW_AV_SYNC;
667 case AUDIO_OUTPUT_FLAG_TTS:
668 return media::AudioOutputFlags::TTS;
669 case AUDIO_OUTPUT_FLAG_RAW:
670 return media::AudioOutputFlags::RAW;
671 case AUDIO_OUTPUT_FLAG_SYNC:
672 return media::AudioOutputFlags::SYNC;
673 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
674 return media::AudioOutputFlags::IEC958_NONAUDIO;
675 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
676 return media::AudioOutputFlags::DIRECT_PCM;
677 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
678 return media::AudioOutputFlags::MMAP_NOIRQ;
679 case AUDIO_OUTPUT_FLAG_VOIP_RX:
680 return media::AudioOutputFlags::VOIP_RX;
681 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
682 return media::AudioOutputFlags::INCALL_MUSIC;
Eric Laurent90fe31c2020-11-26 20:06:35 +0100683 case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
684 return media::AudioOutputFlags::GAPLESS_OFFLOAD;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700685 }
Andy Hung3f69c162020-12-09 12:08:48 -0800686 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700687}
688
689ConversionResult<audio_input_flags_t> aidl2legacy_audio_input_flags_mask(int32_t aidl) {
690 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
691
692 LegacyMask converted = VALUE_OR_RETURN(
693 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(
694 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
695 index2enum_index<media::AudioInputFlags>,
696 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
697 return static_cast<audio_input_flags_t>(converted);
698}
699
700ConversionResult<int32_t> legacy2aidl_audio_input_flags_mask(audio_input_flags_t legacy) {
701 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
702
703 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
704 return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(
705 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
706 index2enum_bitmask<audio_input_flags_t>,
707 enumToMask_index<int32_t, media::AudioInputFlags>);
708}
709
710ConversionResult<audio_output_flags_t> aidl2legacy_audio_output_flags_mask(int32_t aidl) {
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700711 return convertBitmask<audio_output_flags_t,
712 int32_t,
713 audio_output_flags_t,
714 media::AudioOutputFlags>(
715 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
716 index2enum_index<media::AudioOutputFlags>,
717 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700718}
719
720ConversionResult<int32_t> legacy2aidl_audio_output_flags_mask(audio_output_flags_t legacy) {
721 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
722
723 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
724 return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(
725 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
726 index2enum_bitmask<audio_output_flags_t>,
727 enumToMask_index<int32_t, media::AudioOutputFlags>);
728}
729
730ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
731 const media::AudioIoFlags& aidl, media::AudioPortRole role, media::AudioPortType type) {
732 audio_io_flags legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700733 Direction dir = VALUE_OR_RETURN(direction(role, type));
734 switch (dir) {
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700735 case Direction::INPUT: {
736 legacy.input = VALUE_OR_RETURN(
737 aidl2legacy_audio_input_flags_mask(VALUE_OR_RETURN(UNION_GET(aidl, input))));
738 }
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700739 break;
740
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700741 case Direction::OUTPUT: {
742 legacy.output = VALUE_OR_RETURN(
743 aidl2legacy_audio_output_flags_mask(VALUE_OR_RETURN(UNION_GET(aidl, output))));
744 }
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700745 break;
746 }
747
748 return legacy;
749}
750
751ConversionResult<media::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
752 const audio_io_flags& legacy, audio_port_role_t role, audio_port_type_t type) {
753 media::AudioIoFlags aidl;
754
755 Direction dir = VALUE_OR_RETURN(direction(role, type));
756 switch (dir) {
757 case Direction::INPUT:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700758 UNION_SET(aidl, input,
759 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_mask(legacy.input)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700760 break;
761 case Direction::OUTPUT:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700762 UNION_SET(aidl, output,
763 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_mask(legacy.output)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700764 break;
765 }
766 return aidl;
767}
768
769ConversionResult<audio_port_config_device_ext> aidl2legacy_AudioPortConfigDeviceExt(
770 const media::AudioPortConfigDeviceExt& aidl) {
771 audio_port_config_device_ext legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700772 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700773 legacy.type = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.type));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700774 RETURN_IF_ERROR(aidl2legacy_string(aidl.address, legacy.address, AUDIO_DEVICE_MAX_ADDRESS_LEN));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700775 return legacy;
776}
777
778ConversionResult<media::AudioPortConfigDeviceExt> legacy2aidl_AudioPortConfigDeviceExt(
779 const audio_port_config_device_ext& legacy) {
780 media::AudioPortConfigDeviceExt aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700781 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700782 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.type));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700783 aidl.address = VALUE_OR_RETURN(
784 legacy2aidl_string(legacy.address, AUDIO_DEVICE_MAX_ADDRESS_LEN));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700785 return aidl;
786}
787
788ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
789 media::AudioStreamType aidl) {
790 switch (aidl) {
791 case media::AudioStreamType::DEFAULT:
792 return AUDIO_STREAM_DEFAULT;
793 case media::AudioStreamType::VOICE_CALL:
794 return AUDIO_STREAM_VOICE_CALL;
795 case media::AudioStreamType::SYSTEM:
796 return AUDIO_STREAM_SYSTEM;
797 case media::AudioStreamType::RING:
798 return AUDIO_STREAM_RING;
799 case media::AudioStreamType::MUSIC:
800 return AUDIO_STREAM_MUSIC;
801 case media::AudioStreamType::ALARM:
802 return AUDIO_STREAM_ALARM;
803 case media::AudioStreamType::NOTIFICATION:
804 return AUDIO_STREAM_NOTIFICATION;
805 case media::AudioStreamType::BLUETOOTH_SCO:
806 return AUDIO_STREAM_BLUETOOTH_SCO;
807 case media::AudioStreamType::ENFORCED_AUDIBLE:
808 return AUDIO_STREAM_ENFORCED_AUDIBLE;
809 case media::AudioStreamType::DTMF:
810 return AUDIO_STREAM_DTMF;
811 case media::AudioStreamType::TTS:
812 return AUDIO_STREAM_TTS;
813 case media::AudioStreamType::ACCESSIBILITY:
814 return AUDIO_STREAM_ACCESSIBILITY;
815 case media::AudioStreamType::ASSISTANT:
816 return AUDIO_STREAM_ASSISTANT;
817 case media::AudioStreamType::REROUTING:
818 return AUDIO_STREAM_REROUTING;
819 case media::AudioStreamType::PATCH:
820 return AUDIO_STREAM_PATCH;
821 case media::AudioStreamType::CALL_ASSISTANT:
822 return AUDIO_STREAM_CALL_ASSISTANT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700823 }
Andy Hung3f69c162020-12-09 12:08:48 -0800824 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700825}
826
827ConversionResult<media::AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
828 audio_stream_type_t legacy) {
829 switch (legacy) {
830 case AUDIO_STREAM_DEFAULT:
831 return media::AudioStreamType::DEFAULT;
832 case AUDIO_STREAM_VOICE_CALL:
833 return media::AudioStreamType::VOICE_CALL;
834 case AUDIO_STREAM_SYSTEM:
835 return media::AudioStreamType::SYSTEM;
836 case AUDIO_STREAM_RING:
837 return media::AudioStreamType::RING;
838 case AUDIO_STREAM_MUSIC:
839 return media::AudioStreamType::MUSIC;
840 case AUDIO_STREAM_ALARM:
841 return media::AudioStreamType::ALARM;
842 case AUDIO_STREAM_NOTIFICATION:
843 return media::AudioStreamType::NOTIFICATION;
844 case AUDIO_STREAM_BLUETOOTH_SCO:
845 return media::AudioStreamType::BLUETOOTH_SCO;
846 case AUDIO_STREAM_ENFORCED_AUDIBLE:
847 return media::AudioStreamType::ENFORCED_AUDIBLE;
848 case AUDIO_STREAM_DTMF:
849 return media::AudioStreamType::DTMF;
850 case AUDIO_STREAM_TTS:
851 return media::AudioStreamType::TTS;
852 case AUDIO_STREAM_ACCESSIBILITY:
853 return media::AudioStreamType::ACCESSIBILITY;
854 case AUDIO_STREAM_ASSISTANT:
855 return media::AudioStreamType::ASSISTANT;
856 case AUDIO_STREAM_REROUTING:
857 return media::AudioStreamType::REROUTING;
858 case AUDIO_STREAM_PATCH:
859 return media::AudioStreamType::PATCH;
860 case AUDIO_STREAM_CALL_ASSISTANT:
861 return media::AudioStreamType::CALL_ASSISTANT;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700862 }
Andy Hung3f69c162020-12-09 12:08:48 -0800863 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700864}
865
866ConversionResult<audio_source_t> aidl2legacy_AudioSourceType_audio_source_t(
867 media::AudioSourceType aidl) {
868 switch (aidl) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800869 case media::AudioSourceType::INVALID:
870 // This value does not have an enum
871 return AUDIO_SOURCE_INVALID;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700872 case media::AudioSourceType::DEFAULT:
873 return AUDIO_SOURCE_DEFAULT;
874 case media::AudioSourceType::MIC:
875 return AUDIO_SOURCE_MIC;
876 case media::AudioSourceType::VOICE_UPLINK:
877 return AUDIO_SOURCE_VOICE_UPLINK;
878 case media::AudioSourceType::VOICE_DOWNLINK:
879 return AUDIO_SOURCE_VOICE_DOWNLINK;
880 case media::AudioSourceType::VOICE_CALL:
881 return AUDIO_SOURCE_VOICE_CALL;
882 case media::AudioSourceType::CAMCORDER:
883 return AUDIO_SOURCE_CAMCORDER;
884 case media::AudioSourceType::VOICE_RECOGNITION:
885 return AUDIO_SOURCE_VOICE_RECOGNITION;
886 case media::AudioSourceType::VOICE_COMMUNICATION:
887 return AUDIO_SOURCE_VOICE_COMMUNICATION;
888 case media::AudioSourceType::REMOTE_SUBMIX:
889 return AUDIO_SOURCE_REMOTE_SUBMIX;
890 case media::AudioSourceType::UNPROCESSED:
891 return AUDIO_SOURCE_UNPROCESSED;
892 case media::AudioSourceType::VOICE_PERFORMANCE:
893 return AUDIO_SOURCE_VOICE_PERFORMANCE;
894 case media::AudioSourceType::ECHO_REFERENCE:
895 return AUDIO_SOURCE_ECHO_REFERENCE;
896 case media::AudioSourceType::FM_TUNER:
897 return AUDIO_SOURCE_FM_TUNER;
898 case media::AudioSourceType::HOTWORD:
899 return AUDIO_SOURCE_HOTWORD;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700900 }
Andy Hung3f69c162020-12-09 12:08:48 -0800901 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700902}
903
904ConversionResult<media::AudioSourceType> legacy2aidl_audio_source_t_AudioSourceType(
905 audio_source_t legacy) {
906 switch (legacy) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800907 case AUDIO_SOURCE_INVALID:
908 return media::AudioSourceType::INVALID;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700909 case AUDIO_SOURCE_DEFAULT:
910 return media::AudioSourceType::DEFAULT;
911 case AUDIO_SOURCE_MIC:
912 return media::AudioSourceType::MIC;
913 case AUDIO_SOURCE_VOICE_UPLINK:
914 return media::AudioSourceType::VOICE_UPLINK;
915 case AUDIO_SOURCE_VOICE_DOWNLINK:
916 return media::AudioSourceType::VOICE_DOWNLINK;
917 case AUDIO_SOURCE_VOICE_CALL:
918 return media::AudioSourceType::VOICE_CALL;
919 case AUDIO_SOURCE_CAMCORDER:
920 return media::AudioSourceType::CAMCORDER;
921 case AUDIO_SOURCE_VOICE_RECOGNITION:
922 return media::AudioSourceType::VOICE_RECOGNITION;
923 case AUDIO_SOURCE_VOICE_COMMUNICATION:
924 return media::AudioSourceType::VOICE_COMMUNICATION;
925 case AUDIO_SOURCE_REMOTE_SUBMIX:
926 return media::AudioSourceType::REMOTE_SUBMIX;
927 case AUDIO_SOURCE_UNPROCESSED:
928 return media::AudioSourceType::UNPROCESSED;
929 case AUDIO_SOURCE_VOICE_PERFORMANCE:
930 return media::AudioSourceType::VOICE_PERFORMANCE;
931 case AUDIO_SOURCE_ECHO_REFERENCE:
932 return media::AudioSourceType::ECHO_REFERENCE;
933 case AUDIO_SOURCE_FM_TUNER:
934 return media::AudioSourceType::FM_TUNER;
935 case AUDIO_SOURCE_HOTWORD:
936 return media::AudioSourceType::HOTWORD;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700937 }
Andy Hung3f69c162020-12-09 12:08:48 -0800938 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700939}
940
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800941ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
942 return convertReinterpret<audio_session_t>(aidl);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700943}
944
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800945ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
946 return convertReinterpret<int32_t>(legacy);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700947}
948
949// This type is unnamed in the original definition, thus we name it here.
950using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);
951
952ConversionResult<audio_port_config_mix_ext_usecase> aidl2legacy_AudioPortConfigMixExtUseCase(
953 const media::AudioPortConfigMixExtUseCase& aidl, media::AudioPortRole role) {
954 audio_port_config_mix_ext_usecase legacy;
955
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700956 switch (role) {
957 case media::AudioPortRole::NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700958 // Just verify that the union is empty.
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800959 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
Andy Hung3f69c162020-12-09 12:08:48 -0800960 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700961
962 case media::AudioPortRole::SOURCE:
963 // This is not a bug. A SOURCE role corresponds to the stream field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700964 legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
965 VALUE_OR_RETURN(UNION_GET(aidl, stream))));
Andy Hung3f69c162020-12-09 12:08:48 -0800966 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700967
968 case media::AudioPortRole::SINK:
969 // This is not a bug. A SINK role corresponds to the source field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700970 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(
971 VALUE_OR_RETURN(UNION_GET(aidl, source))));
Andy Hung3f69c162020-12-09 12:08:48 -0800972 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700973 }
Andy Hung3f69c162020-12-09 12:08:48 -0800974 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700975}
976
977ConversionResult<media::AudioPortConfigMixExtUseCase> legacy2aidl_AudioPortConfigMixExtUseCase(
978 const audio_port_config_mix_ext_usecase& legacy, audio_port_role_t role) {
979 media::AudioPortConfigMixExtUseCase aidl;
980
981 switch (role) {
982 case AUDIO_PORT_ROLE_NONE:
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -0800983 UNION_SET(aidl, unspecified, false);
Andy Hung3f69c162020-12-09 12:08:48 -0800984 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700985 case AUDIO_PORT_ROLE_SOURCE:
986 // This is not a bug. A SOURCE role corresponds to the stream field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700987 UNION_SET(aidl, stream, VALUE_OR_RETURN(
988 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));
Andy Hung3f69c162020-12-09 12:08:48 -0800989 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700990 case AUDIO_PORT_ROLE_SINK:
991 // This is not a bug. A SINK role corresponds to the source field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700992 UNION_SET(aidl, source,
993 VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source)));
Andy Hung3f69c162020-12-09 12:08:48 -0800994 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700995 }
Andy Hung3f69c162020-12-09 12:08:48 -0800996 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700997}
998
999ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortConfigMixExt(
1000 const media::AudioPortConfigMixExt& aidl, media::AudioPortRole role) {
1001 audio_port_config_mix_ext legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001002 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
1003 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001004 legacy.usecase = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigMixExtUseCase(aidl.usecase, role));
1005 return legacy;
1006}
1007
1008ConversionResult<media::AudioPortConfigMixExt> legacy2aidl_AudioPortConfigMixExt(
1009 const audio_port_config_mix_ext& legacy, audio_port_role_t role) {
1010 media::AudioPortConfigMixExt aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001011 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1012 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001013 aidl.usecase = VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExtUseCase(legacy.usecase, role));
1014 return aidl;
1015}
1016
1017ConversionResult<audio_port_config_session_ext> aidl2legacy_AudioPortConfigSessionExt(
1018 const media::AudioPortConfigSessionExt& aidl) {
1019 audio_port_config_session_ext legacy;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001020 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.session));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001021 return legacy;
1022}
1023
1024ConversionResult<media::AudioPortConfigSessionExt> legacy2aidl_AudioPortConfigSessionExt(
1025 const audio_port_config_session_ext& legacy) {
1026 media::AudioPortConfigSessionExt aidl;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001027 aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(legacy.session));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001028 return aidl;
1029}
1030
1031// This type is unnamed in the original definition, thus we name it here.
1032using audio_port_config_ext = decltype(audio_port_config::ext);
1033
1034ConversionResult<audio_port_config_ext> aidl2legacy_AudioPortConfigExt(
1035 const media::AudioPortConfigExt& aidl, media::AudioPortType type,
1036 media::AudioPortRole role) {
1037 audio_port_config_ext legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001038 switch (type) {
1039 case media::AudioPortType::NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001040 // Just verify that the union is empty.
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001041 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
Andy Hung3f69c162020-12-09 12:08:48 -08001042 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001043 case media::AudioPortType::DEVICE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001044 legacy.device = VALUE_OR_RETURN(
1045 aidl2legacy_AudioPortConfigDeviceExt(VALUE_OR_RETURN(UNION_GET(aidl, device))));
Andy Hung3f69c162020-12-09 12:08:48 -08001046 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001047 case media::AudioPortType::MIX:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001048 legacy.mix = VALUE_OR_RETURN(
1049 aidl2legacy_AudioPortConfigMixExt(VALUE_OR_RETURN(UNION_GET(aidl, mix)), role));
Andy Hung3f69c162020-12-09 12:08:48 -08001050 return legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001051 case media::AudioPortType::SESSION:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001052 legacy.session = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigSessionExt(
1053 VALUE_OR_RETURN(UNION_GET(aidl, session))));
Andy Hung3f69c162020-12-09 12:08:48 -08001054 return legacy;
1055
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001056 }
Andy Hung3f69c162020-12-09 12:08:48 -08001057 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001058}
1059
1060ConversionResult<media::AudioPortConfigExt> legacy2aidl_AudioPortConfigExt(
1061 const audio_port_config_ext& legacy, audio_port_type_t type, audio_port_role_t role) {
1062 media::AudioPortConfigExt aidl;
1063
1064 switch (type) {
1065 case AUDIO_PORT_TYPE_NONE:
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001066 UNION_SET(aidl, unspecified, false);
Andy Hung3f69c162020-12-09 12:08:48 -08001067 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001068 case AUDIO_PORT_TYPE_DEVICE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001069 UNION_SET(aidl, device,
1070 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigDeviceExt(legacy.device)));
Andy Hung3f69c162020-12-09 12:08:48 -08001071 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001072 case AUDIO_PORT_TYPE_MIX:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001073 UNION_SET(aidl, mix,
1074 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExt(legacy.mix, role)));
Andy Hung3f69c162020-12-09 12:08:48 -08001075 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001076 case AUDIO_PORT_TYPE_SESSION:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001077 UNION_SET(aidl, session,
1078 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigSessionExt(legacy.session)));
Andy Hung3f69c162020-12-09 12:08:48 -08001079 return aidl;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001080 }
Andy Hung3f69c162020-12-09 12:08:48 -08001081 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001082}
1083
1084ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_config(
1085 const media::AudioPortConfig& aidl) {
1086 audio_port_config legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001087 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001088 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.role));
1089 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.type));
1090 legacy.config_mask = VALUE_OR_RETURN(aidl2legacy_int32_t_config_mask(aidl.configMask));
1091 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::SAMPLE_RATE)) {
1092 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sampleRate));
1093 }
1094 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::CHANNEL_MASK)) {
1095 legacy.channel_mask =
1096 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1097 }
1098 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FORMAT)) {
1099 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1100 }
1101 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::GAIN)) {
1102 legacy.gain = VALUE_OR_RETURN(
1103 aidl2legacy_AudioGainConfig_audio_gain_config(aidl.gain, aidl.role, aidl.type));
1104 }
1105 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FLAGS)) {
1106 legacy.flags = VALUE_OR_RETURN(
1107 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags, aidl.role, aidl.type));
1108 }
1109 legacy.ext = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigExt(aidl.ext, aidl.type, aidl.role));
1110 return legacy;
1111}
1112
1113ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPortConfig(
1114 const audio_port_config& legacy) {
1115 media::AudioPortConfig aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001116 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001117 aidl.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
1118 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
1119 aidl.configMask = VALUE_OR_RETURN(legacy2aidl_config_mask_int32_t(legacy.config_mask));
1120 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
1121 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1122 }
1123 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
1124 aidl.channelMask =
1125 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
1126 }
1127 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
1128 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1129 }
1130 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
1131 aidl.gain = VALUE_OR_RETURN(legacy2aidl_audio_gain_config_AudioGainConfig(
1132 legacy.gain, legacy.role, legacy.type));
1133 }
1134 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
1135 aidl.flags = VALUE_OR_RETURN(
1136 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, legacy.role, legacy.type));
1137 }
1138 aidl.ext =
1139 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigExt(legacy.ext, legacy.type, legacy.role));
1140 return aidl;
1141}
1142
1143ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch(
1144 const media::AudioPatch& aidl) {
1145 struct audio_patch legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001146 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_patch_handle_t(aidl.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001147 legacy.num_sinks = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sinks.size()));
1148 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1149 return unexpected(BAD_VALUE);
1150 }
1151 for (size_t i = 0; i < legacy.num_sinks; ++i) {
1152 legacy.sinks[i] =
1153 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sinks[i]));
1154 }
1155 legacy.num_sources = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sources.size()));
1156 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1157 return unexpected(BAD_VALUE);
1158 }
1159 for (size_t i = 0; i < legacy.num_sources; ++i) {
1160 legacy.sources[i] =
1161 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sources[i]));
1162 }
1163 return legacy;
1164}
1165
1166ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch(
1167 const struct audio_patch& legacy) {
1168 media::AudioPatch aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001169 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_patch_handle_t_int32_t(legacy.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001170
1171 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1172 return unexpected(BAD_VALUE);
1173 }
1174 for (unsigned int i = 0; i < legacy.num_sinks; ++i) {
1175 aidl.sinks.push_back(
1176 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sinks[i])));
1177 }
1178 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1179 return unexpected(BAD_VALUE);
1180 }
1181 for (unsigned int i = 0; i < legacy.num_sources; ++i) {
1182 aidl.sources.push_back(
1183 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sources[i])));
1184 }
1185 return aidl;
1186}
1187
1188ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(
1189 const media::AudioIoDescriptor& aidl) {
1190 sp<AudioIoDescriptor> legacy(new AudioIoDescriptor());
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001191 legacy->mIoHandle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001192 legacy->mPatch = VALUE_OR_RETURN(aidl2legacy_AudioPatch_audio_patch(aidl.patch));
1193 legacy->mSamplingRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));
1194 legacy->mFormat = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1195 legacy->mChannelMask =
1196 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1197 legacy->mFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
1198 legacy->mFrameCountHAL = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));
1199 legacy->mLatency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001200 legacy->mPortId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001201 return legacy;
1202}
1203
1204ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(
1205 const sp<AudioIoDescriptor>& legacy) {
1206 media::AudioIoDescriptor aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001207 aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->mIoHandle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001208 aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->mPatch));
1209 aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mSamplingRate));
1210 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy->mFormat));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001211 aidl.channelMask = VALUE_OR_RETURN(
1212 legacy2aidl_audio_channel_mask_t_int32_t(legacy->mChannelMask));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001213 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCount));
1214 aidl.frameCountHAL = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCountHAL));
1215 aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mLatency));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001216 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy->mPortId));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001217 return aidl;
1218}
1219
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001220ConversionResult<AudioClient> aidl2legacy_AudioClient(const media::AudioClient& aidl) {
1221 AudioClient legacy;
1222 legacy.clientUid = VALUE_OR_RETURN(aidl2legacy_int32_t_uid_t(aidl.clientUid));
1223 legacy.clientPid = VALUE_OR_RETURN(aidl2legacy_int32_t_pid_t(aidl.clientPid));
1224 legacy.clientTid = VALUE_OR_RETURN(aidl2legacy_int32_t_pid_t(aidl.clientTid));
1225 legacy.packageName = VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.packageName));
1226 return legacy;
1227}
1228
1229ConversionResult<media::AudioClient> legacy2aidl_AudioClient(const AudioClient& legacy) {
1230 media::AudioClient aidl;
1231 aidl.clientUid = VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.clientUid));
1232 aidl.clientPid = VALUE_OR_RETURN(legacy2aidl_pid_t_int32_t(legacy.clientPid));
1233 aidl.clientTid = VALUE_OR_RETURN(legacy2aidl_pid_t_int32_t(legacy.clientTid));
1234 aidl.packageName = VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.packageName));
1235 return aidl;
1236}
1237
1238ConversionResult<audio_content_type_t>
1239aidl2legacy_AudioContentType_audio_content_type_t(media::AudioContentType aidl) {
1240 switch (aidl) {
1241 case media::AudioContentType::UNKNOWN:
1242 return AUDIO_CONTENT_TYPE_UNKNOWN;
1243 case media::AudioContentType::SPEECH:
1244 return AUDIO_CONTENT_TYPE_SPEECH;
1245 case media::AudioContentType::MUSIC:
1246 return AUDIO_CONTENT_TYPE_MUSIC;
1247 case media::AudioContentType::MOVIE:
1248 return AUDIO_CONTENT_TYPE_MOVIE;
1249 case media::AudioContentType::SONIFICATION:
1250 return AUDIO_CONTENT_TYPE_SONIFICATION;
1251 }
1252 return unexpected(BAD_VALUE);
1253}
1254
1255ConversionResult<media::AudioContentType>
1256legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
1257 switch (legacy) {
1258 case AUDIO_CONTENT_TYPE_UNKNOWN:
1259 return media::AudioContentType::UNKNOWN;
1260 case AUDIO_CONTENT_TYPE_SPEECH:
1261 return media::AudioContentType::SPEECH;
1262 case AUDIO_CONTENT_TYPE_MUSIC:
1263 return media::AudioContentType::MUSIC;
1264 case AUDIO_CONTENT_TYPE_MOVIE:
1265 return media::AudioContentType::MOVIE;
1266 case AUDIO_CONTENT_TYPE_SONIFICATION:
1267 return media::AudioContentType::SONIFICATION;
1268 }
1269 return unexpected(BAD_VALUE);
1270}
1271
1272ConversionResult<audio_usage_t>
1273aidl2legacy_AudioUsage_audio_usage_t(media::AudioUsage aidl) {
1274 switch (aidl) {
1275 case media::AudioUsage::UNKNOWN:
1276 return AUDIO_USAGE_UNKNOWN;
1277 case media::AudioUsage::MEDIA:
1278 return AUDIO_USAGE_MEDIA;
1279 case media::AudioUsage::VOICE_COMMUNICATION:
1280 return AUDIO_USAGE_VOICE_COMMUNICATION;
1281 case media::AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
1282 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1283 case media::AudioUsage::ALARM:
1284 return AUDIO_USAGE_ALARM;
1285 case media::AudioUsage::NOTIFICATION:
1286 return AUDIO_USAGE_NOTIFICATION;
1287 case media::AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
1288 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1289 case media::AudioUsage::NOTIFICATION_COMMUNICATION_REQUEST:
1290 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
1291 case media::AudioUsage::NOTIFICATION_COMMUNICATION_INSTANT:
1292 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
1293 case media::AudioUsage::NOTIFICATION_COMMUNICATION_DELAYED:
1294 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
1295 case media::AudioUsage::NOTIFICATION_EVENT:
1296 return AUDIO_USAGE_NOTIFICATION_EVENT;
1297 case media::AudioUsage::ASSISTANCE_ACCESSIBILITY:
1298 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1299 case media::AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
1300 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
1301 case media::AudioUsage::ASSISTANCE_SONIFICATION:
1302 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1303 case media::AudioUsage::GAME:
1304 return AUDIO_USAGE_GAME;
1305 case media::AudioUsage::VIRTUAL_SOURCE:
1306 return AUDIO_USAGE_VIRTUAL_SOURCE;
1307 case media::AudioUsage::ASSISTANT:
1308 return AUDIO_USAGE_ASSISTANT;
1309 case media::AudioUsage::CALL_ASSISTANT:
1310 return AUDIO_USAGE_CALL_ASSISTANT;
1311 case media::AudioUsage::EMERGENCY:
1312 return AUDIO_USAGE_EMERGENCY;
1313 case media::AudioUsage::SAFETY:
1314 return AUDIO_USAGE_SAFETY;
1315 case media::AudioUsage::VEHICLE_STATUS:
1316 return AUDIO_USAGE_VEHICLE_STATUS;
1317 case media::AudioUsage::ANNOUNCEMENT:
1318 return AUDIO_USAGE_ANNOUNCEMENT;
1319 }
1320 return unexpected(BAD_VALUE);
1321}
1322
1323ConversionResult<media::AudioUsage>
1324legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
1325 switch (legacy) {
1326 case AUDIO_USAGE_UNKNOWN:
1327 return media::AudioUsage::UNKNOWN;
1328 case AUDIO_USAGE_MEDIA:
1329 return media::AudioUsage::MEDIA;
1330 case AUDIO_USAGE_VOICE_COMMUNICATION:
1331 return media::AudioUsage::VOICE_COMMUNICATION;
1332 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
1333 return media::AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
1334 case AUDIO_USAGE_ALARM:
1335 return media::AudioUsage::ALARM;
1336 case AUDIO_USAGE_NOTIFICATION:
1337 return media::AudioUsage::NOTIFICATION;
1338 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
1339 return media::AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
1340 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
1341 return media::AudioUsage::NOTIFICATION_COMMUNICATION_REQUEST;
1342 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
1343 return media::AudioUsage::NOTIFICATION_COMMUNICATION_INSTANT;
1344 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
1345 return media::AudioUsage::NOTIFICATION_COMMUNICATION_DELAYED;
1346 case AUDIO_USAGE_NOTIFICATION_EVENT:
1347 return media::AudioUsage::NOTIFICATION_EVENT;
1348 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
1349 return media::AudioUsage::ASSISTANCE_ACCESSIBILITY;
1350 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
1351 return media::AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
1352 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
1353 return media::AudioUsage::ASSISTANCE_SONIFICATION;
1354 case AUDIO_USAGE_GAME:
1355 return media::AudioUsage::GAME;
1356 case AUDIO_USAGE_VIRTUAL_SOURCE:
1357 return media::AudioUsage::VIRTUAL_SOURCE;
1358 case AUDIO_USAGE_ASSISTANT:
1359 return media::AudioUsage::ASSISTANT;
1360 case AUDIO_USAGE_CALL_ASSISTANT:
1361 return media::AudioUsage::CALL_ASSISTANT;
1362 case AUDIO_USAGE_EMERGENCY:
1363 return media::AudioUsage::EMERGENCY;
1364 case AUDIO_USAGE_SAFETY:
1365 return media::AudioUsage::SAFETY;
1366 case AUDIO_USAGE_VEHICLE_STATUS:
1367 return media::AudioUsage::VEHICLE_STATUS;
1368 case AUDIO_USAGE_ANNOUNCEMENT:
1369 return media::AudioUsage::ANNOUNCEMENT;
1370 }
1371 return unexpected(BAD_VALUE);
1372}
1373
1374ConversionResult<audio_flags_mask_t>
1375aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl) {
1376 switch (aidl) {
1377 case media::AudioFlag::AUDIBILITY_ENFORCED:
1378 return AUDIO_FLAG_AUDIBILITY_ENFORCED;
1379 case media::AudioFlag::SECURE:
1380 return AUDIO_FLAG_SECURE;
1381 case media::AudioFlag::SCO:
1382 return AUDIO_FLAG_SCO;
1383 case media::AudioFlag::BEACON:
1384 return AUDIO_FLAG_BEACON;
1385 case media::AudioFlag::HW_AV_SYNC:
1386 return AUDIO_FLAG_HW_AV_SYNC;
1387 case media::AudioFlag::HW_HOTWORD:
1388 return AUDIO_FLAG_HW_HOTWORD;
1389 case media::AudioFlag::BYPASS_INTERRUPTION_POLICY:
1390 return AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY;
1391 case media::AudioFlag::BYPASS_MUTE:
1392 return AUDIO_FLAG_BYPASS_MUTE;
1393 case media::AudioFlag::LOW_LATENCY:
1394 return AUDIO_FLAG_LOW_LATENCY;
1395 case media::AudioFlag::DEEP_BUFFER:
1396 return AUDIO_FLAG_DEEP_BUFFER;
1397 case media::AudioFlag::NO_MEDIA_PROJECTION:
1398 return AUDIO_FLAG_NO_MEDIA_PROJECTION;
1399 case media::AudioFlag::MUTE_HAPTIC:
1400 return AUDIO_FLAG_MUTE_HAPTIC;
1401 case media::AudioFlag::NO_SYSTEM_CAPTURE:
1402 return AUDIO_FLAG_NO_SYSTEM_CAPTURE;
1403 case media::AudioFlag::CAPTURE_PRIVATE:
1404 return AUDIO_FLAG_CAPTURE_PRIVATE;
1405 }
1406 return unexpected(BAD_VALUE);
1407}
1408
1409ConversionResult<media::AudioFlag>
1410legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy) {
1411 switch (legacy) {
1412 case AUDIO_FLAG_NONE:
1413 return unexpected(BAD_VALUE);
1414 case AUDIO_FLAG_AUDIBILITY_ENFORCED:
1415 return media::AudioFlag::AUDIBILITY_ENFORCED;
1416 case AUDIO_FLAG_SECURE:
1417 return media::AudioFlag::SECURE;
1418 case AUDIO_FLAG_SCO:
1419 return media::AudioFlag::SCO;
1420 case AUDIO_FLAG_BEACON:
1421 return media::AudioFlag::BEACON;
1422 case AUDIO_FLAG_HW_AV_SYNC:
1423 return media::AudioFlag::HW_AV_SYNC;
1424 case AUDIO_FLAG_HW_HOTWORD:
1425 return media::AudioFlag::HW_HOTWORD;
1426 case AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY:
1427 return media::AudioFlag::BYPASS_INTERRUPTION_POLICY;
1428 case AUDIO_FLAG_BYPASS_MUTE:
1429 return media::AudioFlag::BYPASS_MUTE;
1430 case AUDIO_FLAG_LOW_LATENCY:
1431 return media::AudioFlag::LOW_LATENCY;
1432 case AUDIO_FLAG_DEEP_BUFFER:
1433 return media::AudioFlag::DEEP_BUFFER;
1434 case AUDIO_FLAG_NO_MEDIA_PROJECTION:
1435 return media::AudioFlag::NO_MEDIA_PROJECTION;
1436 case AUDIO_FLAG_MUTE_HAPTIC:
1437 return media::AudioFlag::MUTE_HAPTIC;
1438 case AUDIO_FLAG_NO_SYSTEM_CAPTURE:
1439 return media::AudioFlag::NO_SYSTEM_CAPTURE;
1440 case AUDIO_FLAG_CAPTURE_PRIVATE:
1441 return media::AudioFlag::CAPTURE_PRIVATE;
1442 }
1443 return unexpected(BAD_VALUE);
1444}
1445
1446ConversionResult<audio_flags_mask_t>
1447aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {
1448 return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(
1449 aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, index2enum_index<media::AudioFlag>,
1450 enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);
1451}
1452
1453ConversionResult<int32_t>
1454legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {
1455 return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001456 legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,
1457 index2enum_bitmask<audio_flags_mask_t>,
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001458 enumToMask_index<int32_t, media::AudioFlag>);
1459}
1460
1461ConversionResult<audio_attributes_t>
1462aidl2legacy_AudioAttributesInternal_audio_attributes_t(const media::AudioAttributesInternal& aidl) {
1463 audio_attributes_t legacy;
1464 legacy.content_type = VALUE_OR_RETURN(
1465 aidl2legacy_AudioContentType_audio_content_type_t(aidl.contentType));
1466 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1467 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(aidl.source));
1468 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_flags_mask_t_mask(aidl.flags));
1469 RETURN_IF_ERROR(aidl2legacy_string(aidl.tags, legacy.tags, sizeof(legacy.tags)));
1470 return legacy;
1471}
1472
1473ConversionResult<media::AudioAttributesInternal>
1474legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t& legacy) {
1475 media::AudioAttributesInternal aidl;
1476 aidl.contentType = VALUE_OR_RETURN(
1477 legacy2aidl_audio_content_type_t_AudioContentType(legacy.content_type));
1478 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1479 aidl.source = VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source));
1480 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_flags_mask_t_int32_t_mask(legacy.flags));
1481 aidl.tags = VALUE_OR_RETURN(legacy2aidl_string(legacy.tags, sizeof(legacy.tags)));
1482 return aidl;
1483}
1484
1485ConversionResult<audio_encapsulation_mode_t>
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08001486aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(media::AudioEncapsulationMode aidl) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001487 switch (aidl) {
1488 case media::AudioEncapsulationMode::NONE:
1489 return AUDIO_ENCAPSULATION_MODE_NONE;
1490 case media::AudioEncapsulationMode::ELEMENTARY_STREAM:
1491 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
1492 case media::AudioEncapsulationMode::HANDLE:
1493 return AUDIO_ENCAPSULATION_MODE_HANDLE;
1494 }
1495 return unexpected(BAD_VALUE);
1496}
1497
1498ConversionResult<media::AudioEncapsulationMode>
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08001499legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001500 switch (legacy) {
1501 case AUDIO_ENCAPSULATION_MODE_NONE:
1502 return media::AudioEncapsulationMode::NONE;
1503 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
1504 return media::AudioEncapsulationMode::ELEMENTARY_STREAM;
1505 case AUDIO_ENCAPSULATION_MODE_HANDLE:
1506 return media::AudioEncapsulationMode::HANDLE;
1507 }
1508 return unexpected(BAD_VALUE);
1509}
1510
1511ConversionResult<audio_offload_info_t>
1512aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const media::AudioOffloadInfo& aidl) {
1513 audio_offload_info_t legacy;
1514 legacy.version = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.version));
1515 legacy.size = sizeof(audio_offload_info_t);
1516 audio_config_base_t config = VALUE_OR_RETURN(
1517 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config));
1518 legacy.sample_rate = config.sample_rate;
1519 legacy.channel_mask = config.channel_mask;
1520 legacy.format = config.format;
1521 legacy.stream_type = VALUE_OR_RETURN(
1522 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
1523 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRate));
1524 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
1525 legacy.has_video = aidl.hasVideo;
1526 legacy.is_streaming = aidl.isStreaming;
1527 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
1528 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
1529 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1530 legacy.encapsulation_mode = VALUE_OR_RETURN(
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08001531 aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001532 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
1533 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
1534 return legacy;
1535}
1536
1537ConversionResult<media::AudioOffloadInfo>
1538legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
1539 media::AudioOffloadInfo aidl;
1540 // Version 0.1 fields.
1541 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
1542 return unexpected(BAD_VALUE);
1543 }
1544 aidl.version = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.version));
1545 aidl.config.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1546 aidl.config.channelMask = VALUE_OR_RETURN(
1547 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
1548 aidl.config.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1549 aidl.streamType = VALUE_OR_RETURN(
1550 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
1551 aidl.bitRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
1552 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
1553 aidl.hasVideo = legacy.has_video;
1554 aidl.isStreaming = legacy.is_streaming;
1555 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
1556 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
1557 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1558
1559 // Version 0.2 fields.
1560 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
1561 if (legacy.size <
1562 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
1563 return unexpected(BAD_VALUE);
1564 }
1565 aidl.encapsulationMode = VALUE_OR_RETURN(
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08001566 legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001567 legacy.encapsulation_mode));
1568 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
1569 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
1570 }
1571 return aidl;
1572}
1573
1574ConversionResult<audio_config_t>
1575aidl2legacy_AudioConfig_audio_config_t(const media::AudioConfig& aidl) {
1576 audio_config_t legacy;
1577 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001578 legacy.channel_mask = VALUE_OR_RETURN(
1579 aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001580 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001581 legacy.offload_info = VALUE_OR_RETURN(
1582 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001583 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
1584 return legacy;
1585}
1586
1587ConversionResult<media::AudioConfig>
1588legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy) {
1589 media::AudioConfig aidl;
1590 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001591 aidl.channelMask = VALUE_OR_RETURN(
1592 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001593 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001594 aidl.offloadInfo = VALUE_OR_RETURN(
1595 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001596 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
1597 return aidl;
1598}
1599
1600ConversionResult<audio_config_base_t>
1601aidl2legacy_AudioConfigBase_audio_config_base_t(const media::AudioConfigBase& aidl) {
1602 audio_config_base_t legacy;
1603 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001604 legacy.channel_mask = VALUE_OR_RETURN(
1605 aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001606 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1607 return legacy;
1608}
1609
1610ConversionResult<media::AudioConfigBase>
1611legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy) {
1612 media::AudioConfigBase aidl;
1613 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001614 aidl.channelMask = VALUE_OR_RETURN(
1615 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001616 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1617 return aidl;
1618}
1619
1620ConversionResult<sp<IMemory>>
1621aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion& aidl) {
1622 sp<IMemory> legacy;
1623 if (!convertSharedFileRegionToIMemory(aidl, &legacy)) {
1624 return unexpected(BAD_VALUE);
1625 }
1626 return legacy;
1627}
1628
1629ConversionResult<media::SharedFileRegion>
1630legacy2aidl_IMemory_SharedFileRegion(const sp<IMemory>& legacy) {
1631 media::SharedFileRegion aidl;
1632 if (!convertIMemoryToSharedFileRegion(legacy, &aidl)) {
1633 return unexpected(BAD_VALUE);
1634 }
1635 return aidl;
1636}
1637
1638ConversionResult<sp<IMemory>>
1639aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion>& aidl) {
1640 sp<IMemory> legacy;
1641 if (!convertNullableSharedFileRegionToIMemory(aidl, &legacy)) {
1642 return unexpected(BAD_VALUE);
1643 }
1644 return legacy;
1645}
1646
1647ConversionResult<std::optional<media::SharedFileRegion>>
1648legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy) {
1649 std::optional<media::SharedFileRegion> aidl;
1650 if (!convertNullableIMemoryToSharedFileRegion(legacy, &aidl)) {
1651 return unexpected(BAD_VALUE);
1652 }
1653 return aidl;
1654}
1655
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001656ConversionResult<AudioTimestamp>
1657aidl2legacy_AudioTimestamp(const media::AudioTimestampInternal& aidl) {
1658 AudioTimestamp legacy;
1659 legacy.mPosition = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.position));
1660 legacy.mTime.tv_sec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sec));
1661 legacy.mTime.tv_nsec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.nsec));
1662 return legacy;
1663}
1664
1665ConversionResult<media::AudioTimestampInternal>
1666legacy2aidl_AudioTimestamp(const AudioTimestamp& legacy) {
1667 media::AudioTimestampInternal aidl;
1668 aidl.position = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mPosition));
1669 aidl.sec = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.mTime.tv_sec));
1670 aidl.nsec = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mTime.tv_nsec));
1671 return aidl;
1672}
1673
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08001674ConversionResult<audio_uuid_t>
1675aidl2legacy_AudioUuid_audio_uuid_t(const media::AudioUuid& aidl) {
1676 audio_uuid_t legacy;
1677 legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
1678 legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
1679 legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
1680 legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
1681 if (aidl.node.size() != std::size(legacy.node)) {
1682 return unexpected(BAD_VALUE);
1683 }
1684 std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
1685 return legacy;
1686}
1687
1688ConversionResult<media::AudioUuid>
1689legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
1690 media::AudioUuid aidl;
1691 aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
1692 aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
1693 aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
1694 aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
1695 std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
1696 return aidl;
1697}
1698
1699ConversionResult<effect_descriptor_t>
1700aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor& aidl) {
1701 effect_descriptor_t legacy;
1702 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.type));
1703 legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.uuid));
1704 legacy.apiVersion = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.apiVersion));
1705 legacy.flags = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.flags));
1706 legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.cpuLoad));
1707 legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.memoryUsage));
1708 RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));
1709 RETURN_IF_ERROR(
1710 aidl2legacy_string(aidl.implementor, legacy.implementor, sizeof(legacy.implementor)));
1711 return legacy;
1712}
1713
1714ConversionResult<media::EffectDescriptor>
1715legacy2aidl_effect_descriptor_t_EffectDescriptor(const effect_descriptor_t& legacy) {
1716 media::EffectDescriptor aidl;
1717 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));
1718 aidl.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));
1719 aidl.apiVersion = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.apiVersion));
1720 aidl.flags = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.flags));
1721 aidl.cpuLoad = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.cpuLoad));
1722 aidl.memoryUsage = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.memoryUsage));
1723 aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
1724 aidl.implementor = VALUE_OR_RETURN(
1725 legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));
1726 return aidl;
1727}
1728
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08001729ConversionResult<audio_encapsulation_metadata_type_t>
1730aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
1731 media::AudioEncapsulationMetadataType aidl) {
1732 switch (aidl) {
1733 case media::AudioEncapsulationMetadataType::NONE:
1734 return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
1735 case media::AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
1736 return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
1737 case media::AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
1738 return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
1739 }
1740 return unexpected(BAD_VALUE);
1741}
1742
1743ConversionResult<media::AudioEncapsulationMetadataType>
1744legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
1745 audio_encapsulation_metadata_type_t legacy) {
1746 switch (legacy) {
1747 case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
1748 return media::AudioEncapsulationMetadataType::NONE;
1749 case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
1750 return media::AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
1751 case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
1752 return media::AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
1753 }
1754 return unexpected(BAD_VALUE);
1755}
1756
1757ConversionResult<uint32_t>
1758aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
1759 return convertBitmask<uint32_t,
1760 int32_t,
1761 audio_encapsulation_mode_t,
1762 media::AudioEncapsulationMode>(
1763 aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
1764 index2enum_index<media::AudioEncapsulationMode>,
1765 enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
1766}
1767
1768ConversionResult<int32_t>
1769legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
1770 return convertBitmask<int32_t,
1771 uint32_t,
1772 media::AudioEncapsulationMode,
1773 audio_encapsulation_mode_t>(
1774 legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
1775 index2enum_index<audio_encapsulation_mode_t>,
1776 enumToMask_index<int32_t, media::AudioEncapsulationMode>);
1777}
1778
1779ConversionResult<uint32_t>
1780aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
1781 return convertBitmask<uint32_t,
1782 int32_t,
1783 audio_encapsulation_metadata_type_t,
1784 media::AudioEncapsulationMetadataType>(
1785 aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
1786 index2enum_index<media::AudioEncapsulationMetadataType>,
1787 enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
1788}
1789
1790ConversionResult<int32_t>
1791legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
1792 return convertBitmask<int32_t,
1793 uint32_t,
1794 media::AudioEncapsulationMetadataType,
1795 audio_encapsulation_metadata_type_t>(
1796 legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
1797 index2enum_index<audio_encapsulation_metadata_type_t>,
1798 enumToMask_index<int32_t, media::AudioEncapsulationMetadataType>);
1799}
1800
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001801ConversionResult<audio_mix_latency_class_t>
1802aidl2legacy_AudioMixLatencyClass_audio_mix_latency_class_t(
1803 media::AudioMixLatencyClass aidl) {
1804 switch (aidl) {
1805 case media::AudioMixLatencyClass::LOW:
1806 return AUDIO_LATENCY_LOW;
1807 case media::AudioMixLatencyClass::NORMAL:
1808 return AUDIO_LATENCY_NORMAL;
1809 }
1810 return unexpected(BAD_VALUE);
1811}
1812
1813ConversionResult<media::AudioMixLatencyClass>
1814legacy2aidl_audio_mix_latency_class_t_AudioMixLatencyClass(
1815 audio_mix_latency_class_t legacy) {
1816 switch (legacy) {
1817 case AUDIO_LATENCY_LOW:
1818 return media::AudioMixLatencyClass::LOW;
1819 case AUDIO_LATENCY_NORMAL:
1820 return media::AudioMixLatencyClass::NORMAL;
1821 }
1822 return unexpected(BAD_VALUE);
1823}
1824
1825ConversionResult<audio_port_device_ext>
1826aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(const media::AudioPortDeviceExt& aidl) {
1827 audio_port_device_ext legacy;
1828 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
1829 legacy.type = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.device.type));
1830 RETURN_IF_ERROR(
1831 aidl2legacy_string(aidl.device.address, legacy.address, sizeof(legacy.address)));
1832 legacy.encapsulation_modes = VALUE_OR_RETURN(
1833 aidl2legacy_AudioEncapsulationMode_mask(aidl.encapsulationModes));
1834 legacy.encapsulation_metadata_types = VALUE_OR_RETURN(
1835 aidl2legacy_AudioEncapsulationMetadataType_mask(aidl.encapsulationMetadataTypes));
1836 return legacy;
1837}
1838
1839ConversionResult<media::AudioPortDeviceExt>
1840legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(const audio_port_device_ext& legacy) {
1841 media::AudioPortDeviceExt aidl;
1842 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1843 aidl.device.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.type));
1844 aidl.device.address = VALUE_OR_RETURN(
1845 legacy2aidl_string(legacy.address, sizeof(legacy.address)));
1846 aidl.encapsulationModes = VALUE_OR_RETURN(
1847 legacy2aidl_AudioEncapsulationMode_mask(legacy.encapsulation_modes));
1848 aidl.encapsulationMetadataTypes = VALUE_OR_RETURN(
1849 legacy2aidl_AudioEncapsulationMetadataType_mask(legacy.encapsulation_metadata_types));
1850 return aidl;
1851}
1852
1853ConversionResult<audio_port_mix_ext>
1854aidl2legacy_AudioPortMixExt_audio_port_mix_ext(const media::AudioPortMixExt& aidl) {
1855 audio_port_mix_ext legacy;
1856 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
1857 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
1858 legacy.latency_class = VALUE_OR_RETURN(
1859 aidl2legacy_AudioMixLatencyClass_audio_mix_latency_class_t(aidl.latencyClass));
1860 return legacy;
1861}
1862
1863ConversionResult<media::AudioPortMixExt>
1864legacy2aidl_audio_port_mix_ext_AudioPortMixExt(const audio_port_mix_ext& legacy) {
1865 media::AudioPortMixExt aidl;
1866 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1867 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
1868 aidl.latencyClass = VALUE_OR_RETURN(
1869 legacy2aidl_audio_mix_latency_class_t_AudioMixLatencyClass(legacy.latency_class));
1870 return aidl;
1871}
1872
1873ConversionResult<audio_port_session_ext>
1874aidl2legacy_AudioPortSessionExt_audio_port_session_ext(const media::AudioPortSessionExt& aidl) {
1875 audio_port_session_ext legacy;
1876 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.session));
1877 return legacy;
1878}
1879
1880ConversionResult<media::AudioPortSessionExt>
1881legacy2aidl_audio_port_session_ext_AudioPortSessionExt(const audio_port_session_ext& legacy) {
1882 media::AudioPortSessionExt aidl;
1883 aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(legacy.session));
1884 return aidl;
1885}
1886
1887// This type is unnamed in the original definition, thus we name it here.
1888using audio_port_v7_ext = decltype(audio_port_v7::ext);
1889
1890ConversionResult<audio_port_v7_ext> aidl2legacy_AudioPortExt(
1891 const media::AudioPortExt& aidl, media::AudioPortType type) {
1892 audio_port_v7_ext legacy;
1893 switch (type) {
1894 case media::AudioPortType::NONE:
1895 // Just verify that the union is empty.
1896 VALUE_OR_RETURN(UNION_GET(aidl, unspecified));
Andy Hung3f69c162020-12-09 12:08:48 -08001897 return legacy;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001898 case media::AudioPortType::DEVICE:
1899 legacy.device = VALUE_OR_RETURN(
1900 aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
1901 VALUE_OR_RETURN(UNION_GET(aidl, device))));
Andy Hung3f69c162020-12-09 12:08:48 -08001902 return legacy;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001903 case media::AudioPortType::MIX:
1904 legacy.mix = VALUE_OR_RETURN(
1905 aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
1906 VALUE_OR_RETURN(UNION_GET(aidl, mix))));
Andy Hung3f69c162020-12-09 12:08:48 -08001907 return legacy;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001908 case media::AudioPortType::SESSION:
1909 legacy.session = VALUE_OR_RETURN(aidl2legacy_AudioPortSessionExt_audio_port_session_ext(
1910 VALUE_OR_RETURN(UNION_GET(aidl, session))));
Andy Hung3f69c162020-12-09 12:08:48 -08001911 return legacy;
1912
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001913 }
Andy Hung3f69c162020-12-09 12:08:48 -08001914 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001915}
1916
1917ConversionResult<media::AudioPortExt> legacy2aidl_AudioPortExt(
1918 const audio_port_v7_ext& legacy, audio_port_type_t type) {
1919 media::AudioPortExt aidl;
1920 switch (type) {
1921 case AUDIO_PORT_TYPE_NONE:
1922 UNION_SET(aidl, unspecified, false);
Andy Hung3f69c162020-12-09 12:08:48 -08001923 return aidl;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001924 case AUDIO_PORT_TYPE_DEVICE:
1925 UNION_SET(aidl, device,
1926 VALUE_OR_RETURN(
1927 legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(legacy.device)));
Andy Hung3f69c162020-12-09 12:08:48 -08001928 return aidl;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001929 case AUDIO_PORT_TYPE_MIX:
1930 UNION_SET(aidl, mix,
1931 VALUE_OR_RETURN(legacy2aidl_audio_port_mix_ext_AudioPortMixExt(legacy.mix)));
Andy Hung3f69c162020-12-09 12:08:48 -08001932 return aidl;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001933 case AUDIO_PORT_TYPE_SESSION:
1934 UNION_SET(aidl, session,
1935 VALUE_OR_RETURN(legacy2aidl_audio_port_session_ext_AudioPortSessionExt(
1936 legacy.session)));
Andy Hung3f69c162020-12-09 12:08:48 -08001937 return aidl;
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001938 }
Andy Hung3f69c162020-12-09 12:08:48 -08001939 LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
Ytai Ben-Tsvi0cf92652020-11-23 13:23:00 -08001940}
1941
1942ConversionResult<audio_profile>
1943aidl2legacy_AudioProfile_audio_profile(const media::AudioProfile& aidl) {
1944 audio_profile legacy;
1945 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1946
1947 if (aidl.samplingRates.size() > std::size(legacy.sample_rates)) {
1948 return unexpected(BAD_VALUE);
1949 }
1950 RETURN_IF_ERROR(
1951 convertRange(aidl.samplingRates.begin(), aidl.samplingRates.end(), legacy.sample_rates,
1952 convertIntegral<int32_t, unsigned int>));
1953 legacy.num_sample_rates = aidl.samplingRates.size();
1954
1955 if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
1956 return unexpected(BAD_VALUE);
1957 }
1958 RETURN_IF_ERROR(
1959 convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
1960 aidl2legacy_int32_t_audio_channel_mask_t));
1961 legacy.num_channel_masks = aidl.channelMasks.size();
1962 return legacy;
1963}
1964
1965ConversionResult<media::AudioProfile>
1966legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy) {
1967 media::AudioProfile aidl;
1968 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1969
1970 if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
1971 return unexpected(BAD_VALUE);
1972 }
1973 RETURN_IF_ERROR(
1974 convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
1975 std::back_inserter(aidl.samplingRates),
1976 convertIntegral<unsigned int, int32_t>));
1977
1978 if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
1979 return unexpected(BAD_VALUE);
1980 }
1981 RETURN_IF_ERROR(
1982 convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
1983 std::back_inserter(aidl.channelMasks),
1984 legacy2aidl_audio_channel_mask_t_int32_t));
1985 return aidl;
1986}
1987
1988ConversionResult<audio_gain>
1989aidl2legacy_AudioGain_audio_gain(const media::AudioGain& aidl) {
1990 audio_gain legacy;
1991 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
1992 legacy.channel_mask = VALUE_OR_RETURN(
1993 aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1994 legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
1995 legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
1996 legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
1997 legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
1998 legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
1999 legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
2000 return legacy;
2001}
2002
2003ConversionResult<media::AudioGain>
2004legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy) {
2005 media::AudioGain aidl;
2006 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_mask_int32_t(legacy.mode));
2007 aidl.channelMask = VALUE_OR_RETURN(
2008 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
2009 aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
2010 aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
2011 aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
2012 aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
2013 aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
2014 aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
2015 return aidl;
2016}
2017
2018ConversionResult<audio_port_v7>
2019aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) {
2020 audio_port_v7 legacy;
2021 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
2022 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.role));
2023 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.type));
2024 RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));
2025
2026 if (aidl.profiles.size() > std::size(legacy.audio_profiles)) {
2027 return unexpected(BAD_VALUE);
2028 }
2029 RETURN_IF_ERROR(convertRange(aidl.profiles.begin(), aidl.profiles.end(), legacy.audio_profiles,
2030 aidl2legacy_AudioProfile_audio_profile));
2031 legacy.num_audio_profiles = aidl.profiles.size();
2032
2033 if (aidl.gains.size() > std::size(legacy.gains)) {
2034 return unexpected(BAD_VALUE);
2035 }
2036 RETURN_IF_ERROR(convertRange(aidl.gains.begin(), aidl.gains.end(), legacy.gains,
2037 aidl2legacy_AudioGain_audio_gain));
2038 legacy.num_gains = aidl.gains.size();
2039
2040 legacy.active_config = VALUE_OR_RETURN(
2041 aidl2legacy_AudioPortConfig_audio_port_config(aidl.activeConfig));
2042 legacy.ext = VALUE_OR_RETURN(aidl2legacy_AudioPortExt(aidl.ext, aidl.type));
2043 return legacy;
2044}
2045
2046ConversionResult<media::AudioPort>
2047legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) {
2048 media::AudioPort aidl;
2049 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
2050 aidl.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
2051 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
2052 aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
2053
2054 if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {
2055 return unexpected(BAD_VALUE);
2056 }
2057 RETURN_IF_ERROR(
2058 convertRange(legacy.audio_profiles, legacy.audio_profiles + legacy.num_audio_profiles,
2059 std::back_inserter(aidl.profiles),
2060 legacy2aidl_audio_profile_AudioProfile));
2061
2062 if (legacy.num_gains > std::size(legacy.gains)) {
2063 return unexpected(BAD_VALUE);
2064 }
2065 RETURN_IF_ERROR(
2066 convertRange(legacy.gains, legacy.gains + legacy.num_gains,
2067 std::back_inserter(aidl.gains),
2068 legacy2aidl_audio_gain_AudioGain));
2069
2070 aidl.activeConfig = VALUE_OR_RETURN(
2071 legacy2aidl_audio_port_config_AudioPortConfig(legacy.active_config));
2072 aidl.ext = VALUE_OR_RETURN(legacy2aidl_AudioPortExt(legacy.ext, legacy.type));
2073 return aidl;
2074}
2075
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08002076ConversionResult<audio_mode_t>
2077aidl2legacy_AudioMode_audio_mode_t(media::AudioMode aidl) {
2078 switch (aidl) {
2079 case media::AudioMode::INVALID:
2080 return AUDIO_MODE_INVALID;
2081 case media::AudioMode::CURRENT:
2082 return AUDIO_MODE_CURRENT;
2083 case media::AudioMode::NORMAL:
2084 return AUDIO_MODE_NORMAL;
2085 case media::AudioMode::RINGTONE:
2086 return AUDIO_MODE_RINGTONE;
2087 case media::AudioMode::IN_CALL:
2088 return AUDIO_MODE_IN_CALL;
2089 case media::AudioMode::IN_COMMUNICATION:
2090 return AUDIO_MODE_IN_COMMUNICATION;
2091 case media::AudioMode::CALL_SCREEN:
2092 return AUDIO_MODE_CALL_SCREEN;
2093 }
2094 return unexpected(BAD_VALUE);
2095}
2096
2097ConversionResult<media::AudioMode>
2098legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
2099 switch (legacy) {
2100 case AUDIO_MODE_INVALID:
2101 return media::AudioMode::INVALID;
2102 case AUDIO_MODE_CURRENT:
2103 return media::AudioMode::CURRENT;
2104 case AUDIO_MODE_NORMAL:
2105 return media::AudioMode::NORMAL;
2106 case AUDIO_MODE_RINGTONE:
2107 return media::AudioMode::RINGTONE;
2108 case AUDIO_MODE_IN_CALL:
2109 return media::AudioMode::IN_CALL;
2110 case AUDIO_MODE_IN_COMMUNICATION:
2111 return media::AudioMode::IN_COMMUNICATION;
2112 case AUDIO_MODE_CALL_SCREEN:
2113 return media::AudioMode::CALL_SCREEN;
2114 case AUDIO_MODE_CNT:
2115 break;
2116 }
2117 return unexpected(BAD_VALUE);
2118}
2119
2120ConversionResult<audio_unique_id_use_t>
2121aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(media::AudioUniqueIdUse aidl) {
2122 switch (aidl) {
2123 case media::AudioUniqueIdUse::UNSPECIFIED:
2124 return AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
2125 case media::AudioUniqueIdUse::SESSION:
2126 return AUDIO_UNIQUE_ID_USE_SESSION;
2127 case media::AudioUniqueIdUse::MODULE:
2128 return AUDIO_UNIQUE_ID_USE_MODULE;
2129 case media::AudioUniqueIdUse::EFFECT:
2130 return AUDIO_UNIQUE_ID_USE_EFFECT;
2131 case media::AudioUniqueIdUse::PATCH:
2132 return AUDIO_UNIQUE_ID_USE_PATCH;
2133 case media::AudioUniqueIdUse::OUTPUT:
2134 return AUDIO_UNIQUE_ID_USE_OUTPUT;
2135 case media::AudioUniqueIdUse::INPUT:
2136 return AUDIO_UNIQUE_ID_USE_INPUT;
2137 case media::AudioUniqueIdUse::CLIENT:
2138 return AUDIO_UNIQUE_ID_USE_CLIENT;
2139 }
2140 return unexpected(BAD_VALUE);
2141}
2142
2143ConversionResult<media::AudioUniqueIdUse>
2144legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(audio_unique_id_use_t legacy) {
2145 switch (legacy) {
2146 case AUDIO_UNIQUE_ID_USE_UNSPECIFIED:
2147 return media::AudioUniqueIdUse::UNSPECIFIED;
2148 case AUDIO_UNIQUE_ID_USE_SESSION:
2149 return media::AudioUniqueIdUse::SESSION;
2150 case AUDIO_UNIQUE_ID_USE_MODULE:
2151 return media::AudioUniqueIdUse::MODULE;
2152 case AUDIO_UNIQUE_ID_USE_EFFECT:
2153 return media::AudioUniqueIdUse::EFFECT;
2154 case AUDIO_UNIQUE_ID_USE_PATCH:
2155 return media::AudioUniqueIdUse::PATCH;
2156 case AUDIO_UNIQUE_ID_USE_OUTPUT:
2157 return media::AudioUniqueIdUse::OUTPUT;
2158 case AUDIO_UNIQUE_ID_USE_INPUT:
2159 return media::AudioUniqueIdUse::INPUT;
2160 case AUDIO_UNIQUE_ID_USE_CLIENT:
2161 return media::AudioUniqueIdUse::CLIENT;
2162 case AUDIO_UNIQUE_ID_USE_MAX:
2163 break;
2164 }
2165 return unexpected(BAD_VALUE);
2166}
2167
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002168} // namespace android