blob: 9a6bfab1d51d31a810252d3af26016d7eb564aec [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
19#include <system/audio.h>
20#include <utils/Log.h>
21
22#include "media/AidlConversion.h"
23
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080024#include <media/ShmemCompat.h>
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -070025
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070026////////////////////////////////////////////////////////////////////////////////////////////////////
27// Utilities
28
29namespace android {
30
31using base::unexpected;
32
33namespace {
34
35////////////////////////////////////////////////////////////////////////////////////////////////////
36// The code below establishes:
37// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
38// enum types (in which case it evaluates to std::underlying_type_T<T>).
39
40template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
41struct IntegralTypeOfStruct {
42 using Type = T;
43};
44
45template<typename T>
46struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
47 using Type = std::underlying_type_t<T>;
48};
49
50template<typename T>
51using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;
52
53////////////////////////////////////////////////////////////////////////////////////////////////////
54// Utilities for handling bitmasks.
55
56template<typename Enum>
57Enum index2enum_index(int index) {
58 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
59 return static_cast<Enum>(index);
60}
61
62template<typename Enum>
63Enum index2enum_bitmask(int index) {
64 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
65 return static_cast<Enum>(1 << index);
66}
67
68template<typename Mask, typename Enum>
69Mask enumToMask_bitmask(Enum e) {
70 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
71 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
72 return static_cast<Mask>(e);
73}
74
75template<typename Mask, typename Enum>
76Mask enumToMask_index(Enum e) {
77 static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
78 static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
79 return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
80 << static_cast<int>(e));
81}
82
83template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
84ConversionResult<DestMask> convertBitmask(
85 SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
86 const std::function<SrcEnum(int)>& srcIndexToEnum,
87 const std::function<DestMask(DestEnum)>& destEnumToMask) {
88 using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
89 using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;
90
91 UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
92 UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);
93
94 int srcBitIndex = 0;
95 while (usrc != 0) {
96 if (usrc & 1) {
97 SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
98 DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
99 DestMask destMask = destEnumToMask(destEnum);
100 dest |= destMask;
101 }
102 ++srcBitIndex;
103 usrc >>= 1;
104 }
105 return static_cast<DestMask>(dest);
106}
107
108template<typename Mask, typename Enum>
109bool bitmaskIsSet(Mask mask, Enum index) {
110 return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
111}
112
113////////////////////////////////////////////////////////////////////////////////////////////////////
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700114// Utilities for working with AIDL unions.
115// UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
116// value of the respective field, or BAD_VALUE if the union is not set to the requested field.
117// UNION_SET(obj, fieldname, value) sets the requested field to the given value.
118
119template<typename T, typename T::Tag tag>
120using UnionFieldType = std::decay_t<decltype(std::declval<T>().template get<tag>())>;
121
122template<typename T, typename T::Tag tag>
123ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) {
124 if (u.getTag() != tag) {
125 return unexpected(BAD_VALUE);
126 }
127 return u.template get<tag>();
128}
129
130#define UNION_GET(u, field) \
131 unionGetField<std::decay_t<decltype(u)>, std::decay_t<decltype(u)>::Tag::field>(u)
132
133#define UNION_SET(u, field, value) \
134 (u).set<std::decay_t<decltype(u)>::Tag::field>(value)
135
136////////////////////////////////////////////////////////////////////////////////////////////////////
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700137
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700138enum class Direction {
139 INPUT, OUTPUT
140};
141
142ConversionResult<Direction> direction(media::AudioPortRole role, media::AudioPortType type) {
143 switch (type) {
144 case media::AudioPortType::DEVICE:
145 switch (role) {
146 case media::AudioPortRole::SOURCE:
147 return Direction::INPUT;
148 case media::AudioPortRole::SINK:
149 return Direction::OUTPUT;
150 default:
151 break;
152 }
153 break;
154 case media::AudioPortType::MIX:
155 switch (role) {
156 case media::AudioPortRole::SOURCE:
157 return Direction::OUTPUT;
158 case media::AudioPortRole::SINK:
159 return Direction::INPUT;
160 default:
161 break;
162 }
163 break;
164 default:
165 break;
166 }
167 return unexpected(BAD_VALUE);
168}
169
170ConversionResult<Direction> direction(audio_port_role_t role, audio_port_type_t type) {
171 switch (type) {
172 case AUDIO_PORT_TYPE_DEVICE:
173 switch (role) {
174 case AUDIO_PORT_ROLE_SOURCE:
175 return Direction::INPUT;
176 case AUDIO_PORT_ROLE_SINK:
177 return Direction::OUTPUT;
178 default:
179 break;
180 }
181 break;
182 case AUDIO_PORT_TYPE_MIX:
183 switch (role) {
184 case AUDIO_PORT_ROLE_SOURCE:
185 return Direction::OUTPUT;
186 case AUDIO_PORT_ROLE_SINK:
187 return Direction::INPUT;
188 default:
189 break;
190 }
191 break;
192 default:
193 break;
194 }
195 return unexpected(BAD_VALUE);
196}
197
198} // namespace
199
200////////////////////////////////////////////////////////////////////////////////////////////////////
201// Converters
202
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700203status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
204 if (aidl.size() > maxSize - 1) {
205 return BAD_VALUE;
206 }
207 aidl.copy(dest, aidl.size());
208 dest[aidl.size()] = '\0';
209 return OK;
210}
211
212ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
213 if (legacy == nullptr) {
214 return unexpected(BAD_VALUE);
215 }
216 if (strnlen(legacy, maxSize) == maxSize) {
217 // No null-terminator.
218 return unexpected(BAD_VALUE);
219 }
220 return std::string(legacy);
221}
222
223ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
224 return convertReinterpret<audio_module_handle_t>(aidl);
225}
226
227ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
228 return convertReinterpret<int32_t>(legacy);
229}
230
231ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
232 return convertReinterpret<audio_io_handle_t>(aidl);
233}
234
235ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
236 return convertReinterpret<int32_t>(legacy);
237}
238
239ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
240 return convertReinterpret<audio_port_handle_t>(aidl);
241}
242
243ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
244 return convertReinterpret<int32_t>(legacy);
245}
246
247ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
248 return convertReinterpret<audio_patch_handle_t>(aidl);
249}
250
251ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
252 return convertReinterpret<int32_t>(legacy);
253}
254
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800255ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
256 return convertReinterpret<audio_unique_id_t>(aidl);
257}
258
259ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
260 return convertReinterpret<int32_t>(legacy);
261}
262
263ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
264 return convertReinterpret<pid_t>(aidl);
265}
266
267ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
268 return convertReinterpret<int32_t>(legacy);
269}
270
271ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
272 return convertReinterpret<uid_t>(aidl);
273}
274
275ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
276 return convertReinterpret<int32_t>(legacy);
277}
278
279ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
280 return String16(aidl.data(), aidl.size());
281}
282
283ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
284 return std::string(String8(legacy).c_str());
285}
286
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700287// The legacy enum is unnamed. Thus, we use int.
288ConversionResult<int> aidl2legacy_AudioPortConfigType(media::AudioPortConfigType aidl) {
289 switch (aidl) {
290 case media::AudioPortConfigType::SAMPLE_RATE:
291 return AUDIO_PORT_CONFIG_SAMPLE_RATE;
292 case media::AudioPortConfigType::CHANNEL_MASK:
293 return AUDIO_PORT_CONFIG_CHANNEL_MASK;
294 case media::AudioPortConfigType::FORMAT:
295 return AUDIO_PORT_CONFIG_FORMAT;
Hayden Gomes1117ea22020-11-20 11:06:37 -0800296 case media::AudioPortConfigType::GAIN:
297 return AUDIO_PORT_CONFIG_GAIN;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700298 case media::AudioPortConfigType::FLAGS:
299 return AUDIO_PORT_CONFIG_FLAGS;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700300 }
Hayden Gomes1117ea22020-11-20 11:06:37 -0800301 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700302}
303
304// The legacy enum is unnamed. Thus, we use int.
305ConversionResult<media::AudioPortConfigType> legacy2aidl_AudioPortConfigType(int legacy) {
306 switch (legacy) {
307 case AUDIO_PORT_CONFIG_SAMPLE_RATE:
308 return media::AudioPortConfigType::SAMPLE_RATE;
309 case AUDIO_PORT_CONFIG_CHANNEL_MASK:
310 return media::AudioPortConfigType::CHANNEL_MASK;
311 case AUDIO_PORT_CONFIG_FORMAT:
312 return media::AudioPortConfigType::FORMAT;
Hayden Gomes1117ea22020-11-20 11:06:37 -0800313 case AUDIO_PORT_CONFIG_GAIN:
314 return media::AudioPortConfigType::GAIN;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700315 case AUDIO_PORT_CONFIG_FLAGS:
316 return media::AudioPortConfigType::FLAGS;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700317 }
Hayden Gomes1117ea22020-11-20 11:06:37 -0800318 return unexpected(BAD_VALUE);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700319}
320
321ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl) {
322 return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(
323 aidl, aidl2legacy_AudioPortConfigType,
324 // AudioPortConfigType enum is index-based.
325 index2enum_index<media::AudioPortConfigType>,
326 // AUDIO_PORT_CONFIG_* flags are mask-based.
327 enumToMask_bitmask<unsigned int, int>);
328}
329
330ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) {
331 return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(
332 legacy, legacy2aidl_AudioPortConfigType,
333 // AUDIO_PORT_CONFIG_* flags are mask-based.
334 index2enum_bitmask<unsigned>,
335 // AudioPortConfigType enum is index-based.
336 enumToMask_index<int32_t, media::AudioPortConfigType>);
337}
338
339ConversionResult<audio_channel_mask_t> aidl2legacy_int32_t_audio_channel_mask_t(int32_t aidl) {
340 // TODO(ytai): should we convert bit-by-bit?
341 // One problem here is that the representation is both opaque and is different based on the
342 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
343 return convertReinterpret<audio_channel_mask_t>(aidl);
344}
345
346ConversionResult<int32_t> legacy2aidl_audio_channel_mask_t_int32_t(audio_channel_mask_t legacy) {
347 // TODO(ytai): should we convert bit-by-bit?
348 // One problem here is that the representation is both opaque and is different based on the
349 // context (input vs. output). Can determine based on type and role, as per useInChannelMask().
350 return convertReinterpret<int32_t>(legacy);
351}
352
353ConversionResult<audio_io_config_event> aidl2legacy_AudioIoConfigEvent_audio_io_config_event(
354 media::AudioIoConfigEvent aidl) {
355 switch (aidl) {
356 case media::AudioIoConfigEvent::OUTPUT_REGISTERED:
357 return AUDIO_OUTPUT_REGISTERED;
358 case media::AudioIoConfigEvent::OUTPUT_OPENED:
359 return AUDIO_OUTPUT_OPENED;
360 case media::AudioIoConfigEvent::OUTPUT_CLOSED:
361 return AUDIO_OUTPUT_CLOSED;
362 case media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED:
363 return AUDIO_OUTPUT_CONFIG_CHANGED;
364 case media::AudioIoConfigEvent::INPUT_REGISTERED:
365 return AUDIO_INPUT_REGISTERED;
366 case media::AudioIoConfigEvent::INPUT_OPENED:
367 return AUDIO_INPUT_OPENED;
368 case media::AudioIoConfigEvent::INPUT_CLOSED:
369 return AUDIO_INPUT_CLOSED;
370 case media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED:
371 return AUDIO_INPUT_CONFIG_CHANGED;
372 case media::AudioIoConfigEvent::CLIENT_STARTED:
373 return AUDIO_CLIENT_STARTED;
374 default:
375 return unexpected(BAD_VALUE);
376 }
377}
378
379ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_AudioIoConfigEvent(
380 audio_io_config_event legacy) {
381 switch (legacy) {
382 case AUDIO_OUTPUT_REGISTERED:
383 return media::AudioIoConfigEvent::OUTPUT_REGISTERED;
384 case AUDIO_OUTPUT_OPENED:
385 return media::AudioIoConfigEvent::OUTPUT_OPENED;
386 case AUDIO_OUTPUT_CLOSED:
387 return media::AudioIoConfigEvent::OUTPUT_CLOSED;
388 case AUDIO_OUTPUT_CONFIG_CHANGED:
389 return media::AudioIoConfigEvent::OUTPUT_CONFIG_CHANGED;
390 case AUDIO_INPUT_REGISTERED:
391 return media::AudioIoConfigEvent::INPUT_REGISTERED;
392 case AUDIO_INPUT_OPENED:
393 return media::AudioIoConfigEvent::INPUT_OPENED;
394 case AUDIO_INPUT_CLOSED:
395 return media::AudioIoConfigEvent::INPUT_CLOSED;
396 case AUDIO_INPUT_CONFIG_CHANGED:
397 return media::AudioIoConfigEvent::INPUT_CONFIG_CHANGED;
398 case AUDIO_CLIENT_STARTED:
399 return media::AudioIoConfigEvent::CLIENT_STARTED;
400 default:
401 return unexpected(BAD_VALUE);
402 }
403}
404
405ConversionResult<audio_port_role_t> aidl2legacy_AudioPortRole_audio_port_role_t(
406 media::AudioPortRole aidl) {
407 switch (aidl) {
408 case media::AudioPortRole::NONE:
409 return AUDIO_PORT_ROLE_NONE;
410 case media::AudioPortRole::SOURCE:
411 return AUDIO_PORT_ROLE_SOURCE;
412 case media::AudioPortRole::SINK:
413 return AUDIO_PORT_ROLE_SINK;
414 default:
415 return unexpected(BAD_VALUE);
416 }
417}
418
419ConversionResult<media::AudioPortRole> legacy2aidl_audio_port_role_t_AudioPortRole(
420 audio_port_role_t legacy) {
421 switch (legacy) {
422 case AUDIO_PORT_ROLE_NONE:
423 return media::AudioPortRole::NONE;
424 case AUDIO_PORT_ROLE_SOURCE:
425 return media::AudioPortRole::SOURCE;
426 case AUDIO_PORT_ROLE_SINK:
427 return media::AudioPortRole::SINK;
428 default:
429 return unexpected(BAD_VALUE);
430 }
431}
432
433ConversionResult<audio_port_type_t> aidl2legacy_AudioPortType_audio_port_type_t(
434 media::AudioPortType aidl) {
435 switch (aidl) {
436 case media::AudioPortType::NONE:
437 return AUDIO_PORT_TYPE_NONE;
438 case media::AudioPortType::DEVICE:
439 return AUDIO_PORT_TYPE_DEVICE;
440 case media::AudioPortType::MIX:
441 return AUDIO_PORT_TYPE_MIX;
442 case media::AudioPortType::SESSION:
443 return AUDIO_PORT_TYPE_SESSION;
444 default:
445 return unexpected(BAD_VALUE);
446 }
447}
448
449ConversionResult<media::AudioPortType> legacy2aidl_audio_port_type_t_AudioPortType(
450 audio_port_type_t legacy) {
451 switch (legacy) {
452 case AUDIO_PORT_TYPE_NONE:
453 return media::AudioPortType::NONE;
454 case AUDIO_PORT_TYPE_DEVICE:
455 return media::AudioPortType::DEVICE;
456 case AUDIO_PORT_TYPE_MIX:
457 return media::AudioPortType::MIX;
458 case AUDIO_PORT_TYPE_SESSION:
459 return media::AudioPortType::SESSION;
460 default:
461 return unexpected(BAD_VALUE);
462 }
463}
464
465ConversionResult<audio_format_t> aidl2legacy_AudioFormat_audio_format_t(
466 media::audio::common::AudioFormat aidl) {
467 // This relies on AudioFormat being kept in sync with audio_format_t.
468 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
469 return static_cast<audio_format_t>(aidl);
470}
471
472ConversionResult<media::audio::common::AudioFormat> legacy2aidl_audio_format_t_AudioFormat(
473 audio_format_t legacy) {
474 // This relies on AudioFormat being kept in sync with audio_format_t.
475 static_assert(sizeof(media::audio::common::AudioFormat) == sizeof(audio_format_t));
476 return static_cast<media::audio::common::AudioFormat>(legacy);
477}
478
479ConversionResult<int> aidl2legacy_AudioGainMode_int(media::AudioGainMode aidl) {
480 switch (aidl) {
481 case media::AudioGainMode::JOINT:
482 return AUDIO_GAIN_MODE_JOINT;
483 case media::AudioGainMode::CHANNELS:
484 return AUDIO_GAIN_MODE_CHANNELS;
485 case media::AudioGainMode::RAMP:
486 return AUDIO_GAIN_MODE_RAMP;
487 default:
488 return unexpected(BAD_VALUE);
489 }
490}
491
492ConversionResult<media::AudioGainMode> legacy2aidl_int_AudioGainMode(int legacy) {
493 switch (legacy) {
494 case AUDIO_GAIN_MODE_JOINT:
495 return media::AudioGainMode::JOINT;
496 case AUDIO_GAIN_MODE_CHANNELS:
497 return media::AudioGainMode::CHANNELS;
498 case AUDIO_GAIN_MODE_RAMP:
499 return media::AudioGainMode::RAMP;
500 default:
501 return unexpected(BAD_VALUE);
502 }
503}
504
505ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t(int32_t aidl) {
506 return convertBitmask<audio_gain_mode_t, int32_t, int, media::AudioGainMode>(
507 aidl, aidl2legacy_AudioGainMode_int,
508 // AudioGainMode is index-based.
509 index2enum_index<media::AudioGainMode>,
510 // AUDIO_GAIN_MODE_* constants are mask-based.
511 enumToMask_bitmask<audio_gain_mode_t, int>);
512}
513
514ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t(audio_gain_mode_t legacy) {
515 return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, int>(
516 legacy, legacy2aidl_int_AudioGainMode,
517 // AUDIO_GAIN_MODE_* constants are mask-based.
518 index2enum_bitmask<int>,
519 // AudioGainMode is index-based.
520 enumToMask_index<int32_t, media::AudioGainMode>);
521}
522
523ConversionResult<audio_devices_t> aidl2legacy_int32_t_audio_devices_t(int32_t aidl) {
524 // TODO(ytai): bitfield?
525 return convertReinterpret<audio_devices_t>(aidl);
526}
527
528ConversionResult<int32_t> legacy2aidl_audio_devices_t_int32_t(audio_devices_t legacy) {
529 // TODO(ytai): bitfield?
530 return convertReinterpret<int32_t>(legacy);
531}
532
533ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
534 const media::AudioGainConfig& aidl, media::AudioPortRole role, media::AudioPortType type) {
535 audio_gain_config legacy;
536 legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
537 legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t(aidl.mode));
538 legacy.channel_mask =
539 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
540 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
541 const bool isJoint = bitmaskIsSet(aidl.mode, media::AudioGainMode::JOINT);
542 size_t numValues = isJoint ? 1
543 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
544 : audio_channel_count_from_out_mask(legacy.channel_mask);
545 if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
546 return unexpected(BAD_VALUE);
547 }
548 for (size_t i = 0; i < numValues; ++i) {
549 legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
550 }
551 legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
552 return legacy;
553}
554
555ConversionResult<media::AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
556 const audio_gain_config& legacy, audio_port_role_t role, audio_port_type_t type) {
557 media::AudioGainConfig aidl;
558 aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
559 aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t(legacy.mode));
560 aidl.channelMask =
561 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
562 const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;
563 const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
564 size_t numValues = isJoint ? 1
565 : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
566 : audio_channel_count_from_out_mask(legacy.channel_mask);
567 aidl.values.resize(numValues);
568 for (size_t i = 0; i < numValues; ++i) {
569 aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
570 }
571 aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
572 return aidl;
573}
574
575ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
576 media::AudioInputFlags aidl) {
577 switch (aidl) {
578 case media::AudioInputFlags::FAST:
579 return AUDIO_INPUT_FLAG_FAST;
580 case media::AudioInputFlags::HW_HOTWORD:
581 return AUDIO_INPUT_FLAG_HW_HOTWORD;
582 case media::AudioInputFlags::RAW:
583 return AUDIO_INPUT_FLAG_RAW;
584 case media::AudioInputFlags::SYNC:
585 return AUDIO_INPUT_FLAG_SYNC;
586 case media::AudioInputFlags::MMAP_NOIRQ:
587 return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
588 case media::AudioInputFlags::VOIP_TX:
589 return AUDIO_INPUT_FLAG_VOIP_TX;
590 case media::AudioInputFlags::HW_AV_SYNC:
591 return AUDIO_INPUT_FLAG_HW_AV_SYNC;
592 case media::AudioInputFlags::DIRECT:
593 return AUDIO_INPUT_FLAG_DIRECT;
594 default:
595 return unexpected(BAD_VALUE);
596 }
597}
598
599ConversionResult<media::AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
600 audio_input_flags_t legacy) {
601 switch (legacy) {
602 case AUDIO_INPUT_FLAG_FAST:
603 return media::AudioInputFlags::FAST;
604 case AUDIO_INPUT_FLAG_HW_HOTWORD:
605 return media::AudioInputFlags::HW_HOTWORD;
606 case AUDIO_INPUT_FLAG_RAW:
607 return media::AudioInputFlags::RAW;
608 case AUDIO_INPUT_FLAG_SYNC:
609 return media::AudioInputFlags::SYNC;
610 case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
611 return media::AudioInputFlags::MMAP_NOIRQ;
612 case AUDIO_INPUT_FLAG_VOIP_TX:
613 return media::AudioInputFlags::VOIP_TX;
614 case AUDIO_INPUT_FLAG_HW_AV_SYNC:
615 return media::AudioInputFlags::HW_AV_SYNC;
616 case AUDIO_INPUT_FLAG_DIRECT:
617 return media::AudioInputFlags::DIRECT;
618 default:
619 return unexpected(BAD_VALUE);
620 }
621}
622
623ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
624 media::AudioOutputFlags aidl) {
625 switch (aidl) {
626 case media::AudioOutputFlags::DIRECT:
627 return AUDIO_OUTPUT_FLAG_DIRECT;
628 case media::AudioOutputFlags::PRIMARY:
629 return AUDIO_OUTPUT_FLAG_PRIMARY;
630 case media::AudioOutputFlags::FAST:
631 return AUDIO_OUTPUT_FLAG_FAST;
632 case media::AudioOutputFlags::DEEP_BUFFER:
633 return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
634 case media::AudioOutputFlags::COMPRESS_OFFLOAD:
635 return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
636 case media::AudioOutputFlags::NON_BLOCKING:
637 return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
638 case media::AudioOutputFlags::HW_AV_SYNC:
639 return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
640 case media::AudioOutputFlags::TTS:
641 return AUDIO_OUTPUT_FLAG_TTS;
642 case media::AudioOutputFlags::RAW:
643 return AUDIO_OUTPUT_FLAG_RAW;
644 case media::AudioOutputFlags::SYNC:
645 return AUDIO_OUTPUT_FLAG_SYNC;
646 case media::AudioOutputFlags::IEC958_NONAUDIO:
647 return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
648 case media::AudioOutputFlags::DIRECT_PCM:
649 return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
650 case media::AudioOutputFlags::MMAP_NOIRQ:
651 return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
652 case media::AudioOutputFlags::VOIP_RX:
653 return AUDIO_OUTPUT_FLAG_VOIP_RX;
654 case media::AudioOutputFlags::INCALL_MUSIC:
655 return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
656 default:
657 return unexpected(BAD_VALUE);
658 }
659}
660
661ConversionResult<media::AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
662 audio_output_flags_t legacy) {
663 switch (legacy) {
664 case AUDIO_OUTPUT_FLAG_DIRECT:
665 return media::AudioOutputFlags::DIRECT;
666 case AUDIO_OUTPUT_FLAG_PRIMARY:
667 return media::AudioOutputFlags::PRIMARY;
668 case AUDIO_OUTPUT_FLAG_FAST:
669 return media::AudioOutputFlags::FAST;
670 case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
671 return media::AudioOutputFlags::DEEP_BUFFER;
672 case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
673 return media::AudioOutputFlags::COMPRESS_OFFLOAD;
674 case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
675 return media::AudioOutputFlags::NON_BLOCKING;
676 case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
677 return media::AudioOutputFlags::HW_AV_SYNC;
678 case AUDIO_OUTPUT_FLAG_TTS:
679 return media::AudioOutputFlags::TTS;
680 case AUDIO_OUTPUT_FLAG_RAW:
681 return media::AudioOutputFlags::RAW;
682 case AUDIO_OUTPUT_FLAG_SYNC:
683 return media::AudioOutputFlags::SYNC;
684 case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
685 return media::AudioOutputFlags::IEC958_NONAUDIO;
686 case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
687 return media::AudioOutputFlags::DIRECT_PCM;
688 case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
689 return media::AudioOutputFlags::MMAP_NOIRQ;
690 case AUDIO_OUTPUT_FLAG_VOIP_RX:
691 return media::AudioOutputFlags::VOIP_RX;
692 case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
693 return media::AudioOutputFlags::INCALL_MUSIC;
694 default:
695 return unexpected(BAD_VALUE);
696 }
697}
698
699ConversionResult<audio_input_flags_t> aidl2legacy_audio_input_flags_mask(int32_t aidl) {
700 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
701
702 LegacyMask converted = VALUE_OR_RETURN(
703 (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(
704 aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
705 index2enum_index<media::AudioInputFlags>,
706 enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
707 return static_cast<audio_input_flags_t>(converted);
708}
709
710ConversionResult<int32_t> legacy2aidl_audio_input_flags_mask(audio_input_flags_t legacy) {
711 using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
712
713 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
714 return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(
715 legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
716 index2enum_bitmask<audio_input_flags_t>,
717 enumToMask_index<int32_t, media::AudioInputFlags>);
718}
719
720ConversionResult<audio_output_flags_t> aidl2legacy_audio_output_flags_mask(int32_t aidl) {
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700721 return convertBitmask<audio_output_flags_t,
722 int32_t,
723 audio_output_flags_t,
724 media::AudioOutputFlags>(
725 aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
726 index2enum_index<media::AudioOutputFlags>,
727 enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700728}
729
730ConversionResult<int32_t> legacy2aidl_audio_output_flags_mask(audio_output_flags_t legacy) {
731 using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
732
733 LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
734 return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(
735 legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
736 index2enum_bitmask<audio_output_flags_t>,
737 enumToMask_index<int32_t, media::AudioOutputFlags>);
738}
739
740ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
741 const media::AudioIoFlags& aidl, media::AudioPortRole role, media::AudioPortType type) {
742 audio_io_flags legacy;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700743 Direction dir = VALUE_OR_RETURN(direction(role, type));
744 switch (dir) {
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700745 case Direction::INPUT: {
746 legacy.input = VALUE_OR_RETURN(
747 aidl2legacy_audio_input_flags_mask(VALUE_OR_RETURN(UNION_GET(aidl, input))));
748 }
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700749 break;
750
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700751 case Direction::OUTPUT: {
752 legacy.output = VALUE_OR_RETURN(
753 aidl2legacy_audio_output_flags_mask(VALUE_OR_RETURN(UNION_GET(aidl, output))));
754 }
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700755 break;
756 }
757
758 return legacy;
759}
760
761ConversionResult<media::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
762 const audio_io_flags& legacy, audio_port_role_t role, audio_port_type_t type) {
763 media::AudioIoFlags aidl;
764
765 Direction dir = VALUE_OR_RETURN(direction(role, type));
766 switch (dir) {
767 case Direction::INPUT:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700768 UNION_SET(aidl, input,
769 VALUE_OR_RETURN(legacy2aidl_audio_input_flags_mask(legacy.input)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700770 break;
771 case Direction::OUTPUT:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700772 UNION_SET(aidl, output,
773 VALUE_OR_RETURN(legacy2aidl_audio_output_flags_mask(legacy.output)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700774 break;
775 }
776 return aidl;
777}
778
779ConversionResult<audio_port_config_device_ext> aidl2legacy_AudioPortConfigDeviceExt(
780 const media::AudioPortConfigDeviceExt& aidl) {
781 audio_port_config_device_ext legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700782 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700783 legacy.type = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.type));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700784 RETURN_IF_ERROR(aidl2legacy_string(aidl.address, legacy.address, AUDIO_DEVICE_MAX_ADDRESS_LEN));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700785 return legacy;
786}
787
788ConversionResult<media::AudioPortConfigDeviceExt> legacy2aidl_AudioPortConfigDeviceExt(
789 const audio_port_config_device_ext& legacy) {
790 media::AudioPortConfigDeviceExt aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700791 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700792 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.type));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -0700793 aidl.address = VALUE_OR_RETURN(
794 legacy2aidl_string(legacy.address, AUDIO_DEVICE_MAX_ADDRESS_LEN));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700795 return aidl;
796}
797
798ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
799 media::AudioStreamType aidl) {
800 switch (aidl) {
801 case media::AudioStreamType::DEFAULT:
802 return AUDIO_STREAM_DEFAULT;
803 case media::AudioStreamType::VOICE_CALL:
804 return AUDIO_STREAM_VOICE_CALL;
805 case media::AudioStreamType::SYSTEM:
806 return AUDIO_STREAM_SYSTEM;
807 case media::AudioStreamType::RING:
808 return AUDIO_STREAM_RING;
809 case media::AudioStreamType::MUSIC:
810 return AUDIO_STREAM_MUSIC;
811 case media::AudioStreamType::ALARM:
812 return AUDIO_STREAM_ALARM;
813 case media::AudioStreamType::NOTIFICATION:
814 return AUDIO_STREAM_NOTIFICATION;
815 case media::AudioStreamType::BLUETOOTH_SCO:
816 return AUDIO_STREAM_BLUETOOTH_SCO;
817 case media::AudioStreamType::ENFORCED_AUDIBLE:
818 return AUDIO_STREAM_ENFORCED_AUDIBLE;
819 case media::AudioStreamType::DTMF:
820 return AUDIO_STREAM_DTMF;
821 case media::AudioStreamType::TTS:
822 return AUDIO_STREAM_TTS;
823 case media::AudioStreamType::ACCESSIBILITY:
824 return AUDIO_STREAM_ACCESSIBILITY;
825 case media::AudioStreamType::ASSISTANT:
826 return AUDIO_STREAM_ASSISTANT;
827 case media::AudioStreamType::REROUTING:
828 return AUDIO_STREAM_REROUTING;
829 case media::AudioStreamType::PATCH:
830 return AUDIO_STREAM_PATCH;
831 case media::AudioStreamType::CALL_ASSISTANT:
832 return AUDIO_STREAM_CALL_ASSISTANT;
833 default:
834 return unexpected(BAD_VALUE);
835 }
836}
837
838ConversionResult<media::AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
839 audio_stream_type_t legacy) {
840 switch (legacy) {
841 case AUDIO_STREAM_DEFAULT:
842 return media::AudioStreamType::DEFAULT;
843 case AUDIO_STREAM_VOICE_CALL:
844 return media::AudioStreamType::VOICE_CALL;
845 case AUDIO_STREAM_SYSTEM:
846 return media::AudioStreamType::SYSTEM;
847 case AUDIO_STREAM_RING:
848 return media::AudioStreamType::RING;
849 case AUDIO_STREAM_MUSIC:
850 return media::AudioStreamType::MUSIC;
851 case AUDIO_STREAM_ALARM:
852 return media::AudioStreamType::ALARM;
853 case AUDIO_STREAM_NOTIFICATION:
854 return media::AudioStreamType::NOTIFICATION;
855 case AUDIO_STREAM_BLUETOOTH_SCO:
856 return media::AudioStreamType::BLUETOOTH_SCO;
857 case AUDIO_STREAM_ENFORCED_AUDIBLE:
858 return media::AudioStreamType::ENFORCED_AUDIBLE;
859 case AUDIO_STREAM_DTMF:
860 return media::AudioStreamType::DTMF;
861 case AUDIO_STREAM_TTS:
862 return media::AudioStreamType::TTS;
863 case AUDIO_STREAM_ACCESSIBILITY:
864 return media::AudioStreamType::ACCESSIBILITY;
865 case AUDIO_STREAM_ASSISTANT:
866 return media::AudioStreamType::ASSISTANT;
867 case AUDIO_STREAM_REROUTING:
868 return media::AudioStreamType::REROUTING;
869 case AUDIO_STREAM_PATCH:
870 return media::AudioStreamType::PATCH;
871 case AUDIO_STREAM_CALL_ASSISTANT:
872 return media::AudioStreamType::CALL_ASSISTANT;
873 default:
874 return unexpected(BAD_VALUE);
875 }
876}
877
878ConversionResult<audio_source_t> aidl2legacy_AudioSourceType_audio_source_t(
879 media::AudioSourceType aidl) {
880 switch (aidl) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800881 case media::AudioSourceType::INVALID:
882 // This value does not have an enum
883 return AUDIO_SOURCE_INVALID;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700884 case media::AudioSourceType::DEFAULT:
885 return AUDIO_SOURCE_DEFAULT;
886 case media::AudioSourceType::MIC:
887 return AUDIO_SOURCE_MIC;
888 case media::AudioSourceType::VOICE_UPLINK:
889 return AUDIO_SOURCE_VOICE_UPLINK;
890 case media::AudioSourceType::VOICE_DOWNLINK:
891 return AUDIO_SOURCE_VOICE_DOWNLINK;
892 case media::AudioSourceType::VOICE_CALL:
893 return AUDIO_SOURCE_VOICE_CALL;
894 case media::AudioSourceType::CAMCORDER:
895 return AUDIO_SOURCE_CAMCORDER;
896 case media::AudioSourceType::VOICE_RECOGNITION:
897 return AUDIO_SOURCE_VOICE_RECOGNITION;
898 case media::AudioSourceType::VOICE_COMMUNICATION:
899 return AUDIO_SOURCE_VOICE_COMMUNICATION;
900 case media::AudioSourceType::REMOTE_SUBMIX:
901 return AUDIO_SOURCE_REMOTE_SUBMIX;
902 case media::AudioSourceType::UNPROCESSED:
903 return AUDIO_SOURCE_UNPROCESSED;
904 case media::AudioSourceType::VOICE_PERFORMANCE:
905 return AUDIO_SOURCE_VOICE_PERFORMANCE;
906 case media::AudioSourceType::ECHO_REFERENCE:
907 return AUDIO_SOURCE_ECHO_REFERENCE;
908 case media::AudioSourceType::FM_TUNER:
909 return AUDIO_SOURCE_FM_TUNER;
910 case media::AudioSourceType::HOTWORD:
911 return AUDIO_SOURCE_HOTWORD;
912 default:
913 return unexpected(BAD_VALUE);
914 }
915}
916
917ConversionResult<media::AudioSourceType> legacy2aidl_audio_source_t_AudioSourceType(
918 audio_source_t legacy) {
919 switch (legacy) {
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800920 case AUDIO_SOURCE_INVALID:
921 return media::AudioSourceType::INVALID;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700922 case AUDIO_SOURCE_DEFAULT:
923 return media::AudioSourceType::DEFAULT;
924 case AUDIO_SOURCE_MIC:
925 return media::AudioSourceType::MIC;
926 case AUDIO_SOURCE_VOICE_UPLINK:
927 return media::AudioSourceType::VOICE_UPLINK;
928 case AUDIO_SOURCE_VOICE_DOWNLINK:
929 return media::AudioSourceType::VOICE_DOWNLINK;
930 case AUDIO_SOURCE_VOICE_CALL:
931 return media::AudioSourceType::VOICE_CALL;
932 case AUDIO_SOURCE_CAMCORDER:
933 return media::AudioSourceType::CAMCORDER;
934 case AUDIO_SOURCE_VOICE_RECOGNITION:
935 return media::AudioSourceType::VOICE_RECOGNITION;
936 case AUDIO_SOURCE_VOICE_COMMUNICATION:
937 return media::AudioSourceType::VOICE_COMMUNICATION;
938 case AUDIO_SOURCE_REMOTE_SUBMIX:
939 return media::AudioSourceType::REMOTE_SUBMIX;
940 case AUDIO_SOURCE_UNPROCESSED:
941 return media::AudioSourceType::UNPROCESSED;
942 case AUDIO_SOURCE_VOICE_PERFORMANCE:
943 return media::AudioSourceType::VOICE_PERFORMANCE;
944 case AUDIO_SOURCE_ECHO_REFERENCE:
945 return media::AudioSourceType::ECHO_REFERENCE;
946 case AUDIO_SOURCE_FM_TUNER:
947 return media::AudioSourceType::FM_TUNER;
948 case AUDIO_SOURCE_HOTWORD:
949 return media::AudioSourceType::HOTWORD;
950 default:
951 return unexpected(BAD_VALUE);
952 }
953}
954
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800955ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
956 return convertReinterpret<audio_session_t>(aidl);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700957}
958
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800959ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
960 return convertReinterpret<int32_t>(legacy);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700961}
962
963// This type is unnamed in the original definition, thus we name it here.
964using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);
965
966ConversionResult<audio_port_config_mix_ext_usecase> aidl2legacy_AudioPortConfigMixExtUseCase(
967 const media::AudioPortConfigMixExtUseCase& aidl, media::AudioPortRole role) {
968 audio_port_config_mix_ext_usecase legacy;
969
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700970 switch (role) {
971 case media::AudioPortRole::NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700972 // Just verify that the union is empty.
973 VALUE_OR_RETURN(UNION_GET(aidl, nothing));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700974 break;
975
976 case media::AudioPortRole::SOURCE:
977 // This is not a bug. A SOURCE role corresponds to the stream field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700978 legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
979 VALUE_OR_RETURN(UNION_GET(aidl, stream))));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700980 break;
981
982 case media::AudioPortRole::SINK:
983 // This is not a bug. A SINK role corresponds to the source field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -0700984 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(
985 VALUE_OR_RETURN(UNION_GET(aidl, source))));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700986 break;
987
988 default:
989 LOG_ALWAYS_FATAL("Shouldn't get here");
990 }
991 return legacy;
992}
993
994ConversionResult<media::AudioPortConfigMixExtUseCase> legacy2aidl_AudioPortConfigMixExtUseCase(
995 const audio_port_config_mix_ext_usecase& legacy, audio_port_role_t role) {
996 media::AudioPortConfigMixExtUseCase aidl;
997
998 switch (role) {
999 case AUDIO_PORT_ROLE_NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001000 UNION_SET(aidl, nothing, false);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001001 break;
1002 case AUDIO_PORT_ROLE_SOURCE:
1003 // This is not a bug. A SOURCE role corresponds to the stream field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001004 UNION_SET(aidl, stream, VALUE_OR_RETURN(
1005 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001006 break;
1007 case AUDIO_PORT_ROLE_SINK:
1008 // This is not a bug. A SINK role corresponds to the source field.
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001009 UNION_SET(aidl, source,
1010 VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001011 break;
1012 default:
1013 LOG_ALWAYS_FATAL("Shouldn't get here");
1014 }
1015 return aidl;
1016}
1017
1018ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortConfigMixExt(
1019 const media::AudioPortConfigMixExt& aidl, media::AudioPortRole role) {
1020 audio_port_config_mix_ext legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001021 legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidl.hwModule));
1022 legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001023 legacy.usecase = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigMixExtUseCase(aidl.usecase, role));
1024 return legacy;
1025}
1026
1027ConversionResult<media::AudioPortConfigMixExt> legacy2aidl_AudioPortConfigMixExt(
1028 const audio_port_config_mix_ext& legacy, audio_port_role_t role) {
1029 media::AudioPortConfigMixExt aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001030 aidl.hwModule = VALUE_OR_RETURN(legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
1031 aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001032 aidl.usecase = VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExtUseCase(legacy.usecase, role));
1033 return aidl;
1034}
1035
1036ConversionResult<audio_port_config_session_ext> aidl2legacy_AudioPortConfigSessionExt(
1037 const media::AudioPortConfigSessionExt& aidl) {
1038 audio_port_config_session_ext legacy;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001039 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.session));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001040 return legacy;
1041}
1042
1043ConversionResult<media::AudioPortConfigSessionExt> legacy2aidl_AudioPortConfigSessionExt(
1044 const audio_port_config_session_ext& legacy) {
1045 media::AudioPortConfigSessionExt aidl;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001046 aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(legacy.session));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001047 return aidl;
1048}
1049
1050// This type is unnamed in the original definition, thus we name it here.
1051using audio_port_config_ext = decltype(audio_port_config::ext);
1052
1053ConversionResult<audio_port_config_ext> aidl2legacy_AudioPortConfigExt(
1054 const media::AudioPortConfigExt& aidl, media::AudioPortType type,
1055 media::AudioPortRole role) {
1056 audio_port_config_ext legacy;
1057 // Our way of representing a union in AIDL is to have multiple vectors and require that at most
1058 // one of the them has size 1 and the rest are empty.
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001059 switch (type) {
1060 case media::AudioPortType::NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001061 // Just verify that the union is empty.
1062 VALUE_OR_RETURN(UNION_GET(aidl, nothing));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001063 break;
1064 case media::AudioPortType::DEVICE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001065 legacy.device = VALUE_OR_RETURN(
1066 aidl2legacy_AudioPortConfigDeviceExt(VALUE_OR_RETURN(UNION_GET(aidl, device))));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001067 break;
1068 case media::AudioPortType::MIX:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001069 legacy.mix = VALUE_OR_RETURN(
1070 aidl2legacy_AudioPortConfigMixExt(VALUE_OR_RETURN(UNION_GET(aidl, mix)), role));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001071 break;
1072 case media::AudioPortType::SESSION:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001073 legacy.session = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigSessionExt(
1074 VALUE_OR_RETURN(UNION_GET(aidl, session))));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001075 break;
1076 default:
1077 LOG_ALWAYS_FATAL("Shouldn't get here");
1078 }
1079 return legacy;
1080}
1081
1082ConversionResult<media::AudioPortConfigExt> legacy2aidl_AudioPortConfigExt(
1083 const audio_port_config_ext& legacy, audio_port_type_t type, audio_port_role_t role) {
1084 media::AudioPortConfigExt aidl;
1085
1086 switch (type) {
1087 case AUDIO_PORT_TYPE_NONE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001088 UNION_SET(aidl, nothing, false);
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001089 break;
1090 case AUDIO_PORT_TYPE_DEVICE:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001091 UNION_SET(aidl, device,
1092 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigDeviceExt(legacy.device)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001093 break;
1094 case AUDIO_PORT_TYPE_MIX:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001095 UNION_SET(aidl, mix,
1096 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigMixExt(legacy.mix, role)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001097 break;
1098 case AUDIO_PORT_TYPE_SESSION:
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001099 UNION_SET(aidl, session,
1100 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigSessionExt(legacy.session)));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001101 break;
1102 default:
1103 LOG_ALWAYS_FATAL("Shouldn't get here");
1104 }
1105 return aidl;
1106}
1107
1108ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_config(
1109 const media::AudioPortConfig& aidl) {
1110 audio_port_config legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001111 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001112 legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.role));
1113 legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioPortType_audio_port_type_t(aidl.type));
1114 legacy.config_mask = VALUE_OR_RETURN(aidl2legacy_int32_t_config_mask(aidl.configMask));
1115 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::SAMPLE_RATE)) {
1116 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sampleRate));
1117 }
1118 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::CHANNEL_MASK)) {
1119 legacy.channel_mask =
1120 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1121 }
1122 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FORMAT)) {
1123 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1124 }
1125 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::GAIN)) {
1126 legacy.gain = VALUE_OR_RETURN(
1127 aidl2legacy_AudioGainConfig_audio_gain_config(aidl.gain, aidl.role, aidl.type));
1128 }
1129 if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FLAGS)) {
1130 legacy.flags = VALUE_OR_RETURN(
1131 aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags, aidl.role, aidl.type));
1132 }
1133 legacy.ext = VALUE_OR_RETURN(aidl2legacy_AudioPortConfigExt(aidl.ext, aidl.type, aidl.role));
1134 return legacy;
1135}
1136
1137ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPortConfig(
1138 const audio_port_config& legacy) {
1139 media::AudioPortConfig aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001140 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001141 aidl.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));
1142 aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
1143 aidl.configMask = VALUE_OR_RETURN(legacy2aidl_config_mask_int32_t(legacy.config_mask));
1144 if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
1145 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1146 }
1147 if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
1148 aidl.channelMask =
1149 VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
1150 }
1151 if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {
1152 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1153 }
1154 if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {
1155 aidl.gain = VALUE_OR_RETURN(legacy2aidl_audio_gain_config_AudioGainConfig(
1156 legacy.gain, legacy.role, legacy.type));
1157 }
1158 if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {
1159 aidl.flags = VALUE_OR_RETURN(
1160 legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, legacy.role, legacy.type));
1161 }
1162 aidl.ext =
1163 VALUE_OR_RETURN(legacy2aidl_AudioPortConfigExt(legacy.ext, legacy.type, legacy.role));
1164 return aidl;
1165}
1166
1167ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch(
1168 const media::AudioPatch& aidl) {
1169 struct audio_patch legacy;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001170 legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_patch_handle_t(aidl.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001171 legacy.num_sinks = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sinks.size()));
1172 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1173 return unexpected(BAD_VALUE);
1174 }
1175 for (size_t i = 0; i < legacy.num_sinks; ++i) {
1176 legacy.sinks[i] =
1177 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sinks[i]));
1178 }
1179 legacy.num_sources = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sources.size()));
1180 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1181 return unexpected(BAD_VALUE);
1182 }
1183 for (size_t i = 0; i < legacy.num_sources; ++i) {
1184 legacy.sources[i] =
1185 VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sources[i]));
1186 }
1187 return legacy;
1188}
1189
1190ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch(
1191 const struct audio_patch& legacy) {
1192 media::AudioPatch aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001193 aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_patch_handle_t_int32_t(legacy.id));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001194
1195 if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
1196 return unexpected(BAD_VALUE);
1197 }
1198 for (unsigned int i = 0; i < legacy.num_sinks; ++i) {
1199 aidl.sinks.push_back(
1200 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sinks[i])));
1201 }
1202 if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
1203 return unexpected(BAD_VALUE);
1204 }
1205 for (unsigned int i = 0; i < legacy.num_sources; ++i) {
1206 aidl.sources.push_back(
1207 VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sources[i])));
1208 }
1209 return aidl;
1210}
1211
1212ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(
1213 const media::AudioIoDescriptor& aidl) {
1214 sp<AudioIoDescriptor> legacy(new AudioIoDescriptor());
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001215 legacy->mIoHandle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001216 legacy->mPatch = VALUE_OR_RETURN(aidl2legacy_AudioPatch_audio_patch(aidl.patch));
1217 legacy->mSamplingRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));
1218 legacy->mFormat = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1219 legacy->mChannelMask =
1220 VALUE_OR_RETURN(aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
1221 legacy->mFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
1222 legacy->mFrameCountHAL = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));
1223 legacy->mLatency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001224 legacy->mPortId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001225 return legacy;
1226}
1227
1228ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(
1229 const sp<AudioIoDescriptor>& legacy) {
1230 media::AudioIoDescriptor aidl;
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001231 aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->mIoHandle));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001232 aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->mPatch));
1233 aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mSamplingRate));
1234 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy->mFormat));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001235 aidl.channelMask = VALUE_OR_RETURN(
1236 legacy2aidl_audio_channel_mask_t_int32_t(legacy->mChannelMask));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001237 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCount));
1238 aidl.frameCountHAL = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->mFrameCountHAL));
1239 aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mLatency));
Ytai Ben-Tsvi49298c52020-10-15 10:56:48 -07001240 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy->mPortId));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001241 return aidl;
1242}
1243
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001244ConversionResult<AudioClient> aidl2legacy_AudioClient(const media::AudioClient& aidl) {
1245 AudioClient legacy;
1246 legacy.clientUid = VALUE_OR_RETURN(aidl2legacy_int32_t_uid_t(aidl.clientUid));
1247 legacy.clientPid = VALUE_OR_RETURN(aidl2legacy_int32_t_pid_t(aidl.clientPid));
1248 legacy.clientTid = VALUE_OR_RETURN(aidl2legacy_int32_t_pid_t(aidl.clientTid));
1249 legacy.packageName = VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.packageName));
1250 return legacy;
1251}
1252
1253ConversionResult<media::AudioClient> legacy2aidl_AudioClient(const AudioClient& legacy) {
1254 media::AudioClient aidl;
1255 aidl.clientUid = VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.clientUid));
1256 aidl.clientPid = VALUE_OR_RETURN(legacy2aidl_pid_t_int32_t(legacy.clientPid));
1257 aidl.clientTid = VALUE_OR_RETURN(legacy2aidl_pid_t_int32_t(legacy.clientTid));
1258 aidl.packageName = VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.packageName));
1259 return aidl;
1260}
1261
1262ConversionResult<audio_content_type_t>
1263aidl2legacy_AudioContentType_audio_content_type_t(media::AudioContentType aidl) {
1264 switch (aidl) {
1265 case media::AudioContentType::UNKNOWN:
1266 return AUDIO_CONTENT_TYPE_UNKNOWN;
1267 case media::AudioContentType::SPEECH:
1268 return AUDIO_CONTENT_TYPE_SPEECH;
1269 case media::AudioContentType::MUSIC:
1270 return AUDIO_CONTENT_TYPE_MUSIC;
1271 case media::AudioContentType::MOVIE:
1272 return AUDIO_CONTENT_TYPE_MOVIE;
1273 case media::AudioContentType::SONIFICATION:
1274 return AUDIO_CONTENT_TYPE_SONIFICATION;
1275 }
1276 return unexpected(BAD_VALUE);
1277}
1278
1279ConversionResult<media::AudioContentType>
1280legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
1281 switch (legacy) {
1282 case AUDIO_CONTENT_TYPE_UNKNOWN:
1283 return media::AudioContentType::UNKNOWN;
1284 case AUDIO_CONTENT_TYPE_SPEECH:
1285 return media::AudioContentType::SPEECH;
1286 case AUDIO_CONTENT_TYPE_MUSIC:
1287 return media::AudioContentType::MUSIC;
1288 case AUDIO_CONTENT_TYPE_MOVIE:
1289 return media::AudioContentType::MOVIE;
1290 case AUDIO_CONTENT_TYPE_SONIFICATION:
1291 return media::AudioContentType::SONIFICATION;
1292 }
1293 return unexpected(BAD_VALUE);
1294}
1295
1296ConversionResult<audio_usage_t>
1297aidl2legacy_AudioUsage_audio_usage_t(media::AudioUsage aidl) {
1298 switch (aidl) {
1299 case media::AudioUsage::UNKNOWN:
1300 return AUDIO_USAGE_UNKNOWN;
1301 case media::AudioUsage::MEDIA:
1302 return AUDIO_USAGE_MEDIA;
1303 case media::AudioUsage::VOICE_COMMUNICATION:
1304 return AUDIO_USAGE_VOICE_COMMUNICATION;
1305 case media::AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
1306 return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1307 case media::AudioUsage::ALARM:
1308 return AUDIO_USAGE_ALARM;
1309 case media::AudioUsage::NOTIFICATION:
1310 return AUDIO_USAGE_NOTIFICATION;
1311 case media::AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
1312 return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1313 case media::AudioUsage::NOTIFICATION_COMMUNICATION_REQUEST:
1314 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
1315 case media::AudioUsage::NOTIFICATION_COMMUNICATION_INSTANT:
1316 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
1317 case media::AudioUsage::NOTIFICATION_COMMUNICATION_DELAYED:
1318 return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
1319 case media::AudioUsage::NOTIFICATION_EVENT:
1320 return AUDIO_USAGE_NOTIFICATION_EVENT;
1321 case media::AudioUsage::ASSISTANCE_ACCESSIBILITY:
1322 return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1323 case media::AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
1324 return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
1325 case media::AudioUsage::ASSISTANCE_SONIFICATION:
1326 return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1327 case media::AudioUsage::GAME:
1328 return AUDIO_USAGE_GAME;
1329 case media::AudioUsage::VIRTUAL_SOURCE:
1330 return AUDIO_USAGE_VIRTUAL_SOURCE;
1331 case media::AudioUsage::ASSISTANT:
1332 return AUDIO_USAGE_ASSISTANT;
1333 case media::AudioUsage::CALL_ASSISTANT:
1334 return AUDIO_USAGE_CALL_ASSISTANT;
1335 case media::AudioUsage::EMERGENCY:
1336 return AUDIO_USAGE_EMERGENCY;
1337 case media::AudioUsage::SAFETY:
1338 return AUDIO_USAGE_SAFETY;
1339 case media::AudioUsage::VEHICLE_STATUS:
1340 return AUDIO_USAGE_VEHICLE_STATUS;
1341 case media::AudioUsage::ANNOUNCEMENT:
1342 return AUDIO_USAGE_ANNOUNCEMENT;
1343 }
1344 return unexpected(BAD_VALUE);
1345}
1346
1347ConversionResult<media::AudioUsage>
1348legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
1349 switch (legacy) {
1350 case AUDIO_USAGE_UNKNOWN:
1351 return media::AudioUsage::UNKNOWN;
1352 case AUDIO_USAGE_MEDIA:
1353 return media::AudioUsage::MEDIA;
1354 case AUDIO_USAGE_VOICE_COMMUNICATION:
1355 return media::AudioUsage::VOICE_COMMUNICATION;
1356 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
1357 return media::AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
1358 case AUDIO_USAGE_ALARM:
1359 return media::AudioUsage::ALARM;
1360 case AUDIO_USAGE_NOTIFICATION:
1361 return media::AudioUsage::NOTIFICATION;
1362 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
1363 return media::AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
1364 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
1365 return media::AudioUsage::NOTIFICATION_COMMUNICATION_REQUEST;
1366 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
1367 return media::AudioUsage::NOTIFICATION_COMMUNICATION_INSTANT;
1368 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
1369 return media::AudioUsage::NOTIFICATION_COMMUNICATION_DELAYED;
1370 case AUDIO_USAGE_NOTIFICATION_EVENT:
1371 return media::AudioUsage::NOTIFICATION_EVENT;
1372 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
1373 return media::AudioUsage::ASSISTANCE_ACCESSIBILITY;
1374 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
1375 return media::AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
1376 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
1377 return media::AudioUsage::ASSISTANCE_SONIFICATION;
1378 case AUDIO_USAGE_GAME:
1379 return media::AudioUsage::GAME;
1380 case AUDIO_USAGE_VIRTUAL_SOURCE:
1381 return media::AudioUsage::VIRTUAL_SOURCE;
1382 case AUDIO_USAGE_ASSISTANT:
1383 return media::AudioUsage::ASSISTANT;
1384 case AUDIO_USAGE_CALL_ASSISTANT:
1385 return media::AudioUsage::CALL_ASSISTANT;
1386 case AUDIO_USAGE_EMERGENCY:
1387 return media::AudioUsage::EMERGENCY;
1388 case AUDIO_USAGE_SAFETY:
1389 return media::AudioUsage::SAFETY;
1390 case AUDIO_USAGE_VEHICLE_STATUS:
1391 return media::AudioUsage::VEHICLE_STATUS;
1392 case AUDIO_USAGE_ANNOUNCEMENT:
1393 return media::AudioUsage::ANNOUNCEMENT;
1394 }
1395 return unexpected(BAD_VALUE);
1396}
1397
1398ConversionResult<audio_flags_mask_t>
1399aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl) {
1400 switch (aidl) {
1401 case media::AudioFlag::AUDIBILITY_ENFORCED:
1402 return AUDIO_FLAG_AUDIBILITY_ENFORCED;
1403 case media::AudioFlag::SECURE:
1404 return AUDIO_FLAG_SECURE;
1405 case media::AudioFlag::SCO:
1406 return AUDIO_FLAG_SCO;
1407 case media::AudioFlag::BEACON:
1408 return AUDIO_FLAG_BEACON;
1409 case media::AudioFlag::HW_AV_SYNC:
1410 return AUDIO_FLAG_HW_AV_SYNC;
1411 case media::AudioFlag::HW_HOTWORD:
1412 return AUDIO_FLAG_HW_HOTWORD;
1413 case media::AudioFlag::BYPASS_INTERRUPTION_POLICY:
1414 return AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY;
1415 case media::AudioFlag::BYPASS_MUTE:
1416 return AUDIO_FLAG_BYPASS_MUTE;
1417 case media::AudioFlag::LOW_LATENCY:
1418 return AUDIO_FLAG_LOW_LATENCY;
1419 case media::AudioFlag::DEEP_BUFFER:
1420 return AUDIO_FLAG_DEEP_BUFFER;
1421 case media::AudioFlag::NO_MEDIA_PROJECTION:
1422 return AUDIO_FLAG_NO_MEDIA_PROJECTION;
1423 case media::AudioFlag::MUTE_HAPTIC:
1424 return AUDIO_FLAG_MUTE_HAPTIC;
1425 case media::AudioFlag::NO_SYSTEM_CAPTURE:
1426 return AUDIO_FLAG_NO_SYSTEM_CAPTURE;
1427 case media::AudioFlag::CAPTURE_PRIVATE:
1428 return AUDIO_FLAG_CAPTURE_PRIVATE;
1429 }
1430 return unexpected(BAD_VALUE);
1431}
1432
1433ConversionResult<media::AudioFlag>
1434legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy) {
1435 switch (legacy) {
1436 case AUDIO_FLAG_NONE:
1437 return unexpected(BAD_VALUE);
1438 case AUDIO_FLAG_AUDIBILITY_ENFORCED:
1439 return media::AudioFlag::AUDIBILITY_ENFORCED;
1440 case AUDIO_FLAG_SECURE:
1441 return media::AudioFlag::SECURE;
1442 case AUDIO_FLAG_SCO:
1443 return media::AudioFlag::SCO;
1444 case AUDIO_FLAG_BEACON:
1445 return media::AudioFlag::BEACON;
1446 case AUDIO_FLAG_HW_AV_SYNC:
1447 return media::AudioFlag::HW_AV_SYNC;
1448 case AUDIO_FLAG_HW_HOTWORD:
1449 return media::AudioFlag::HW_HOTWORD;
1450 case AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY:
1451 return media::AudioFlag::BYPASS_INTERRUPTION_POLICY;
1452 case AUDIO_FLAG_BYPASS_MUTE:
1453 return media::AudioFlag::BYPASS_MUTE;
1454 case AUDIO_FLAG_LOW_LATENCY:
1455 return media::AudioFlag::LOW_LATENCY;
1456 case AUDIO_FLAG_DEEP_BUFFER:
1457 return media::AudioFlag::DEEP_BUFFER;
1458 case AUDIO_FLAG_NO_MEDIA_PROJECTION:
1459 return media::AudioFlag::NO_MEDIA_PROJECTION;
1460 case AUDIO_FLAG_MUTE_HAPTIC:
1461 return media::AudioFlag::MUTE_HAPTIC;
1462 case AUDIO_FLAG_NO_SYSTEM_CAPTURE:
1463 return media::AudioFlag::NO_SYSTEM_CAPTURE;
1464 case AUDIO_FLAG_CAPTURE_PRIVATE:
1465 return media::AudioFlag::CAPTURE_PRIVATE;
1466 }
1467 return unexpected(BAD_VALUE);
1468}
1469
1470ConversionResult<audio_flags_mask_t>
1471aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {
1472 return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(
1473 aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, index2enum_index<media::AudioFlag>,
1474 enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);
1475}
1476
1477ConversionResult<int32_t>
1478legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {
1479 return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001480 legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,
1481 index2enum_bitmask<audio_flags_mask_t>,
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001482 enumToMask_index<int32_t, media::AudioFlag>);
1483}
1484
1485ConversionResult<audio_attributes_t>
1486aidl2legacy_AudioAttributesInternal_audio_attributes_t(const media::AudioAttributesInternal& aidl) {
1487 audio_attributes_t legacy;
1488 legacy.content_type = VALUE_OR_RETURN(
1489 aidl2legacy_AudioContentType_audio_content_type_t(aidl.contentType));
1490 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1491 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(aidl.source));
1492 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_flags_mask_t_mask(aidl.flags));
1493 RETURN_IF_ERROR(aidl2legacy_string(aidl.tags, legacy.tags, sizeof(legacy.tags)));
1494 return legacy;
1495}
1496
1497ConversionResult<media::AudioAttributesInternal>
1498legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t& legacy) {
1499 media::AudioAttributesInternal aidl;
1500 aidl.contentType = VALUE_OR_RETURN(
1501 legacy2aidl_audio_content_type_t_AudioContentType(legacy.content_type));
1502 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1503 aidl.source = VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source));
1504 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_flags_mask_t_int32_t_mask(legacy.flags));
1505 aidl.tags = VALUE_OR_RETURN(legacy2aidl_string(legacy.tags, sizeof(legacy.tags)));
1506 return aidl;
1507}
1508
1509ConversionResult<audio_encapsulation_mode_t>
1510aidl2legacy_audio_encapsulation_mode_t_AudioEncapsulationMode(media::AudioEncapsulationMode aidl) {
1511 switch (aidl) {
1512 case media::AudioEncapsulationMode::NONE:
1513 return AUDIO_ENCAPSULATION_MODE_NONE;
1514 case media::AudioEncapsulationMode::ELEMENTARY_STREAM:
1515 return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
1516 case media::AudioEncapsulationMode::HANDLE:
1517 return AUDIO_ENCAPSULATION_MODE_HANDLE;
1518 }
1519 return unexpected(BAD_VALUE);
1520}
1521
1522ConversionResult<media::AudioEncapsulationMode>
1523legacy2aidl_AudioEncapsulationMode_audio_encapsulation_mode_t(audio_encapsulation_mode_t legacy) {
1524 switch (legacy) {
1525 case AUDIO_ENCAPSULATION_MODE_NONE:
1526 return media::AudioEncapsulationMode::NONE;
1527 case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
1528 return media::AudioEncapsulationMode::ELEMENTARY_STREAM;
1529 case AUDIO_ENCAPSULATION_MODE_HANDLE:
1530 return media::AudioEncapsulationMode::HANDLE;
1531 }
1532 return unexpected(BAD_VALUE);
1533}
1534
1535ConversionResult<audio_offload_info_t>
1536aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const media::AudioOffloadInfo& aidl) {
1537 audio_offload_info_t legacy;
1538 legacy.version = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.version));
1539 legacy.size = sizeof(audio_offload_info_t);
1540 audio_config_base_t config = VALUE_OR_RETURN(
1541 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config));
1542 legacy.sample_rate = config.sample_rate;
1543 legacy.channel_mask = config.channel_mask;
1544 legacy.format = config.format;
1545 legacy.stream_type = VALUE_OR_RETURN(
1546 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
1547 legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRate));
1548 legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
1549 legacy.has_video = aidl.hasVideo;
1550 legacy.is_streaming = aidl.isStreaming;
1551 legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
1552 legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
1553 legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
1554 legacy.encapsulation_mode = VALUE_OR_RETURN(
1555 aidl2legacy_audio_encapsulation_mode_t_AudioEncapsulationMode(aidl.encapsulationMode));
1556 legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
1557 legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
1558 return legacy;
1559}
1560
1561ConversionResult<media::AudioOffloadInfo>
1562legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
1563 media::AudioOffloadInfo aidl;
1564 // Version 0.1 fields.
1565 if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
1566 return unexpected(BAD_VALUE);
1567 }
1568 aidl.version = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.version));
1569 aidl.config.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
1570 aidl.config.channelMask = VALUE_OR_RETURN(
1571 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
1572 aidl.config.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1573 aidl.streamType = VALUE_OR_RETURN(
1574 legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
1575 aidl.bitRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
1576 aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
1577 aidl.hasVideo = legacy.has_video;
1578 aidl.isStreaming = legacy.is_streaming;
1579 aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
1580 aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
1581 aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
1582
1583 // Version 0.2 fields.
1584 if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
1585 if (legacy.size <
1586 offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
1587 return unexpected(BAD_VALUE);
1588 }
1589 aidl.encapsulationMode = VALUE_OR_RETURN(
1590 legacy2aidl_AudioEncapsulationMode_audio_encapsulation_mode_t(
1591 legacy.encapsulation_mode));
1592 aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
1593 aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
1594 }
1595 return aidl;
1596}
1597
1598ConversionResult<audio_config_t>
1599aidl2legacy_AudioConfig_audio_config_t(const media::AudioConfig& aidl) {
1600 audio_config_t legacy;
1601 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001602 legacy.channel_mask = VALUE_OR_RETURN(
1603 aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001604 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001605 legacy.offload_info = VALUE_OR_RETURN(
1606 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001607 legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
1608 return legacy;
1609}
1610
1611ConversionResult<media::AudioConfig>
1612legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy) {
1613 media::AudioConfig aidl;
1614 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001615 aidl.channelMask = VALUE_OR_RETURN(
1616 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001617 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001618 aidl.offloadInfo = VALUE_OR_RETURN(
1619 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001620 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
1621 return aidl;
1622}
1623
1624ConversionResult<audio_config_base_t>
1625aidl2legacy_AudioConfigBase_audio_config_base_t(const media::AudioConfigBase& aidl) {
1626 audio_config_base_t legacy;
1627 legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001628 legacy.channel_mask = VALUE_OR_RETURN(
1629 aidl2legacy_int32_t_audio_channel_mask_t(aidl.channelMask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001630 legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormat_audio_format_t(aidl.format));
1631 return legacy;
1632}
1633
1634ConversionResult<media::AudioConfigBase>
1635legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy) {
1636 media::AudioConfigBase aidl;
1637 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
Ytai Ben-Tsvia3815202020-10-28 14:58:08 -07001638 aidl.channelMask = VALUE_OR_RETURN(
1639 legacy2aidl_audio_channel_mask_t_int32_t(legacy.channel_mask));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001640 aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormat(legacy.format));
1641 return aidl;
1642}
1643
1644ConversionResult<sp<IMemory>>
1645aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion& aidl) {
1646 sp<IMemory> legacy;
1647 if (!convertSharedFileRegionToIMemory(aidl, &legacy)) {
1648 return unexpected(BAD_VALUE);
1649 }
1650 return legacy;
1651}
1652
1653ConversionResult<media::SharedFileRegion>
1654legacy2aidl_IMemory_SharedFileRegion(const sp<IMemory>& legacy) {
1655 media::SharedFileRegion aidl;
1656 if (!convertIMemoryToSharedFileRegion(legacy, &aidl)) {
1657 return unexpected(BAD_VALUE);
1658 }
1659 return aidl;
1660}
1661
1662ConversionResult<sp<IMemory>>
1663aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion>& aidl) {
1664 sp<IMemory> legacy;
1665 if (!convertNullableSharedFileRegionToIMemory(aidl, &legacy)) {
1666 return unexpected(BAD_VALUE);
1667 }
1668 return legacy;
1669}
1670
1671ConversionResult<std::optional<media::SharedFileRegion>>
1672legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy) {
1673 std::optional<media::SharedFileRegion> aidl;
1674 if (!convertNullableIMemoryToSharedFileRegion(legacy, &aidl)) {
1675 return unexpected(BAD_VALUE);
1676 }
1677 return aidl;
1678}
1679
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001680ConversionResult<AudioTimestamp>
1681aidl2legacy_AudioTimestamp(const media::AudioTimestampInternal& aidl) {
1682 AudioTimestamp legacy;
1683 legacy.mPosition = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.position));
1684 legacy.mTime.tv_sec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sec));
1685 legacy.mTime.tv_nsec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.nsec));
1686 return legacy;
1687}
1688
1689ConversionResult<media::AudioTimestampInternal>
1690legacy2aidl_AudioTimestamp(const AudioTimestamp& legacy) {
1691 media::AudioTimestampInternal aidl;
1692 aidl.position = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mPosition));
1693 aidl.sec = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.mTime.tv_sec));
1694 aidl.nsec = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mTime.tv_nsec));
1695 return aidl;
1696}
1697
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07001698} // namespace android