Support Audio common AIDL NDK conversion
Split libaudioclient AidlConversion into two:
1. Conversion methods of libaudioclient AIDL definitions stays in
libaudioclient and only support CPP backend (default) conversion.
2. Conversion methods of common AIDL definitions (which can be used by
HAL) in common folder and support both CPP (default) and NDK (define
BACKEND_NDK in CFLAGS) backend conversion.
Bug: 261129656
Test: Build flash andi run audio use cases on Panther
Change-Id: I62c95b95ad12fa9a9d3f48f3505241637a7e817a
Merged-In: I62c95b95ad12fa9a9d3f48f3505241637a7e817a
diff --git a/Android.bp b/Android.bp
index 0e0ea1f..5aa2029 100644
--- a/Android.bp
+++ b/Android.bp
@@ -75,10 +75,10 @@
"av-types-aidl-cpp",
],
header_libs: [
- "libaudioclient_aidl_conversion_util",
+ "libaudio_aidl_conversion_common_util_cpp",
],
export_header_lib_headers: [
- "libaudioclient_aidl_conversion_util",
+ "libaudio_aidl_conversion_common_util_cpp",
],
host_supported: true,
vendor_available: true,
diff --git a/media/audioaidlconversion/AidlConversionCppNdk.cpp b/media/audioaidlconversion/AidlConversionCppNdk.cpp
new file mode 100644
index 0000000..ea1ec0c
--- /dev/null
+++ b/media/audioaidlconversion/AidlConversionCppNdk.cpp
@@ -0,0 +1,2130 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <map>
+#include <utility>
+#include <vector>
+
+#define LOG_TAG "AidlConversionCppNdk"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include "media/AidlConversionCppNdk.h"
+
+#include <media/ShmemCompat.h>
+#include <media/stagefright/foundation/MediaDefs.h>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Utilities
+
+#if defined(BACKEND_NDK)
+/* AIDL String generated in NDK is different than CPP */
+#define GET_DEVICE_DESC_CONNECTION(x) AudioDeviceDescription::CONNECTION_##x
+namespace aidl {
+#else
+#define GET_DEVICE_DESC_CONNECTION(x) AudioDeviceDescription::CONNECTION_##x()
+#endif
+
+namespace android {
+
+using ::android::BAD_VALUE;
+using ::android::OK;
+using ::android::base::unexpected;
+
+using media::audio::common::AudioChannelLayout;
+using media::audio::common::AudioConfig;
+using media::audio::common::AudioConfigBase;
+using media::audio::common::AudioContentType;
+using media::audio::common::AudioDevice;
+using media::audio::common::AudioDeviceAddress;
+using media::audio::common::AudioDeviceDescription;
+using media::audio::common::AudioDeviceType;
+using media::audio::common::AudioEncapsulationMetadataType;
+using media::audio::common::AudioEncapsulationMode;
+using media::audio::common::AudioEncapsulationType;
+using media::audio::common::AudioFormatDescription;
+using media::audio::common::AudioFormatType;
+using media::audio::common::AudioGain;
+using media::audio::common::AudioGainConfig;
+using media::audio::common::AudioGainMode;
+using media::audio::common::AudioInputFlags;
+using media::audio::common::AudioIoFlags;
+using media::audio::common::AudioMode;
+using media::audio::common::AudioOffloadInfo;
+using media::audio::common::AudioOutputFlags;
+using media::audio::common::AudioPortDeviceExt;
+using media::audio::common::AudioPortExt;
+using media::audio::common::AudioPortMixExt;
+using media::audio::common::AudioPortMixExtUseCase;
+using media::audio::common::AudioProfile;
+using media::audio::common::AudioSource;
+using media::audio::common::AudioStandard;
+using media::audio::common::AudioStreamType;
+using media::audio::common::AudioUsage;
+using media::audio::common::AudioUuid;
+using media::audio::common::ExtraAudioDescriptor;
+using media::audio::common::Int;
+using media::audio::common::PcmType;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Converters
+
+::android::status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
+ if (aidl.size() > maxSize - 1) {
+ return BAD_VALUE;
+ }
+ aidl.copy(dest, aidl.size());
+ dest[aidl.size()] = '\0';
+ return OK;
+}
+
+ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
+ if (legacy == nullptr) {
+ return unexpected(BAD_VALUE);
+ }
+ if (strnlen(legacy, maxSize) == maxSize) {
+ // No null-terminator.
+ return unexpected(BAD_VALUE);
+ }
+ return std::string(legacy);
+}
+
+ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
+ return convertReinterpret<audio_module_handle_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
+ return convertReinterpret<audio_io_handle_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
+ return convertReinterpret<audio_port_handle_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
+ return convertReinterpret<audio_patch_handle_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
+ return convertReinterpret<audio_unique_id_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl) {
+ return convertReinterpret<audio_hw_sync_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
+ return convertReinterpret<pid_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
+ return convertReinterpret<uid_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
+ return String16(aidl.data(), aidl.size());
+}
+
+ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
+ return std::string(String8(legacy).c_str());
+}
+
+// TODO b/182392769: create an optional -> optional util
+ConversionResult<std::optional<String16>>
+aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl) {
+ if (!aidl.has_value()) {
+ return std::nullopt;
+ }
+ ConversionResult<String16> conversion =
+ VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.value()));
+ return conversion.value();
+}
+
+ConversionResult<std::optional<std::string_view>>
+legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy) {
+ if (!legacy.has_value()) {
+ return std::nullopt;
+ }
+ ConversionResult<std::string> conversion =
+ VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.value()));
+ return conversion.value();
+}
+
+ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {
+ return String8(aidl.data(), aidl.size());
+}
+
+ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {
+ return std::string(legacy.c_str());
+}
+
+namespace {
+
+namespace detail {
+using AudioChannelBitPair = std::pair<audio_channel_mask_t, int>;
+using AudioChannelBitPairs = std::vector<AudioChannelBitPair>;
+using AudioChannelPair = std::pair<audio_channel_mask_t, AudioChannelLayout>;
+using AudioChannelPairs = std::vector<AudioChannelPair>;
+using AudioDevicePair = std::pair<audio_devices_t, AudioDeviceDescription>;
+using AudioDevicePairs = std::vector<AudioDevicePair>;
+using AudioFormatPair = std::pair<audio_format_t, AudioFormatDescription>;
+using AudioFormatPairs = std::vector<AudioFormatPair>;
+}
+
+const detail::AudioChannelBitPairs& getInAudioChannelBits() {
+ static const detail::AudioChannelBitPairs pairs = {
+ { AUDIO_CHANNEL_IN_LEFT, AudioChannelLayout::CHANNEL_FRONT_LEFT },
+ { AUDIO_CHANNEL_IN_RIGHT, AudioChannelLayout::CHANNEL_FRONT_RIGHT },
+ // AUDIO_CHANNEL_IN_FRONT is at the end
+ { AUDIO_CHANNEL_IN_BACK, AudioChannelLayout::CHANNEL_BACK_CENTER },
+ // AUDIO_CHANNEL_IN_*_PROCESSED not supported
+ // AUDIO_CHANNEL_IN_PRESSURE not supported
+ // AUDIO_CHANNEL_IN_*_AXIS not supported
+ // AUDIO_CHANNEL_IN_VOICE_* not supported
+ { AUDIO_CHANNEL_IN_BACK_LEFT, AudioChannelLayout::CHANNEL_BACK_LEFT },
+ { AUDIO_CHANNEL_IN_BACK_RIGHT, AudioChannelLayout::CHANNEL_BACK_RIGHT },
+ { AUDIO_CHANNEL_IN_CENTER, AudioChannelLayout::CHANNEL_FRONT_CENTER },
+ { AUDIO_CHANNEL_IN_LOW_FREQUENCY, AudioChannelLayout::CHANNEL_LOW_FREQUENCY },
+ { AUDIO_CHANNEL_IN_TOP_LEFT, AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT },
+ { AUDIO_CHANNEL_IN_TOP_RIGHT, AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT },
+ // When going from aidl to legacy, IN_CENTER is used
+ { AUDIO_CHANNEL_IN_FRONT, AudioChannelLayout::CHANNEL_FRONT_CENTER }
+ };
+ return pairs;
+}
+
+const detail::AudioChannelPairs& getInAudioChannelPairs() {
+ static const detail::AudioChannelPairs pairs = {
+#define DEFINE_INPUT_LAYOUT(n) \
+ { \
+ AUDIO_CHANNEL_IN_##n, \
+ AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
+ AudioChannelLayout::LAYOUT_##n) \
+ }
+
+ DEFINE_INPUT_LAYOUT(MONO),
+ DEFINE_INPUT_LAYOUT(STEREO),
+ DEFINE_INPUT_LAYOUT(FRONT_BACK),
+ // AUDIO_CHANNEL_IN_6 not supported
+ DEFINE_INPUT_LAYOUT(2POINT0POINT2),
+ DEFINE_INPUT_LAYOUT(2POINT1POINT2),
+ DEFINE_INPUT_LAYOUT(3POINT0POINT2),
+ DEFINE_INPUT_LAYOUT(3POINT1POINT2),
+ DEFINE_INPUT_LAYOUT(5POINT1)
+#undef DEFINE_INPUT_LAYOUT
+ };
+ return pairs;
+}
+
+const detail::AudioChannelBitPairs& getOutAudioChannelBits() {
+ static const detail::AudioChannelBitPairs pairs = {
+#define DEFINE_OUTPUT_BITS(n) \
+ { AUDIO_CHANNEL_OUT_##n, AudioChannelLayout::CHANNEL_##n }
+
+ DEFINE_OUTPUT_BITS(FRONT_LEFT),
+ DEFINE_OUTPUT_BITS(FRONT_RIGHT),
+ DEFINE_OUTPUT_BITS(FRONT_CENTER),
+ DEFINE_OUTPUT_BITS(LOW_FREQUENCY),
+ DEFINE_OUTPUT_BITS(BACK_LEFT),
+ DEFINE_OUTPUT_BITS(BACK_RIGHT),
+ DEFINE_OUTPUT_BITS(FRONT_LEFT_OF_CENTER),
+ DEFINE_OUTPUT_BITS(FRONT_RIGHT_OF_CENTER),
+ DEFINE_OUTPUT_BITS(BACK_CENTER),
+ DEFINE_OUTPUT_BITS(SIDE_LEFT),
+ DEFINE_OUTPUT_BITS(SIDE_RIGHT),
+ DEFINE_OUTPUT_BITS(TOP_CENTER),
+ DEFINE_OUTPUT_BITS(TOP_FRONT_LEFT),
+ DEFINE_OUTPUT_BITS(TOP_FRONT_CENTER),
+ DEFINE_OUTPUT_BITS(TOP_FRONT_RIGHT),
+ DEFINE_OUTPUT_BITS(TOP_BACK_LEFT),
+ DEFINE_OUTPUT_BITS(TOP_BACK_CENTER),
+ DEFINE_OUTPUT_BITS(TOP_BACK_RIGHT),
+ DEFINE_OUTPUT_BITS(TOP_SIDE_LEFT),
+ DEFINE_OUTPUT_BITS(TOP_SIDE_RIGHT),
+ DEFINE_OUTPUT_BITS(BOTTOM_FRONT_LEFT),
+ DEFINE_OUTPUT_BITS(BOTTOM_FRONT_CENTER),
+ DEFINE_OUTPUT_BITS(BOTTOM_FRONT_RIGHT),
+ DEFINE_OUTPUT_BITS(LOW_FREQUENCY_2),
+ DEFINE_OUTPUT_BITS(FRONT_WIDE_LEFT),
+ DEFINE_OUTPUT_BITS(FRONT_WIDE_RIGHT),
+#undef DEFINE_OUTPUT_BITS
+ { AUDIO_CHANNEL_OUT_HAPTIC_A, AudioChannelLayout::CHANNEL_HAPTIC_A },
+ { AUDIO_CHANNEL_OUT_HAPTIC_B, AudioChannelLayout::CHANNEL_HAPTIC_B }
+ };
+ return pairs;
+}
+
+const detail::AudioChannelPairs& getOutAudioChannelPairs() {
+ static const detail::AudioChannelPairs pairs = {
+#define DEFINE_OUTPUT_LAYOUT(n) \
+ { \
+ AUDIO_CHANNEL_OUT_##n, \
+ AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
+ AudioChannelLayout::LAYOUT_##n) \
+ }
+
+ DEFINE_OUTPUT_LAYOUT(MONO),
+ DEFINE_OUTPUT_LAYOUT(STEREO),
+ DEFINE_OUTPUT_LAYOUT(2POINT1),
+ DEFINE_OUTPUT_LAYOUT(TRI),
+ DEFINE_OUTPUT_LAYOUT(TRI_BACK),
+ DEFINE_OUTPUT_LAYOUT(3POINT1),
+ DEFINE_OUTPUT_LAYOUT(2POINT0POINT2),
+ DEFINE_OUTPUT_LAYOUT(2POINT1POINT2),
+ DEFINE_OUTPUT_LAYOUT(3POINT0POINT2),
+ DEFINE_OUTPUT_LAYOUT(3POINT1POINT2),
+ DEFINE_OUTPUT_LAYOUT(QUAD),
+ DEFINE_OUTPUT_LAYOUT(QUAD_SIDE),
+ DEFINE_OUTPUT_LAYOUT(SURROUND),
+ DEFINE_OUTPUT_LAYOUT(PENTA),
+ DEFINE_OUTPUT_LAYOUT(5POINT1),
+ DEFINE_OUTPUT_LAYOUT(5POINT1_SIDE),
+ DEFINE_OUTPUT_LAYOUT(5POINT1POINT2),
+ DEFINE_OUTPUT_LAYOUT(5POINT1POINT4),
+ DEFINE_OUTPUT_LAYOUT(6POINT1),
+ DEFINE_OUTPUT_LAYOUT(7POINT1),
+ DEFINE_OUTPUT_LAYOUT(7POINT1POINT2),
+ DEFINE_OUTPUT_LAYOUT(7POINT1POINT4),
+ DEFINE_OUTPUT_LAYOUT(13POINT_360RA),
+ DEFINE_OUTPUT_LAYOUT(22POINT2),
+ DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_A),
+ DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_A),
+ DEFINE_OUTPUT_LAYOUT(HAPTIC_AB),
+ DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_AB),
+ DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_AB)
+#undef DEFINE_OUTPUT_LAYOUT
+ };
+ return pairs;
+}
+
+const detail::AudioChannelPairs& getVoiceAudioChannelPairs() {
+ static const detail::AudioChannelPairs pairs = {
+#define DEFINE_VOICE_LAYOUT(n) \
+ { \
+ AUDIO_CHANNEL_IN_VOICE_##n, \
+ AudioChannelLayout::make<AudioChannelLayout::Tag::voiceMask>( \
+ AudioChannelLayout::VOICE_##n) \
+ }
+ DEFINE_VOICE_LAYOUT(UPLINK_MONO),
+ DEFINE_VOICE_LAYOUT(DNLINK_MONO),
+ DEFINE_VOICE_LAYOUT(CALL_MONO)
+#undef DEFINE_VOICE_LAYOUT
+ };
+ return pairs;
+}
+
+AudioDeviceDescription make_AudioDeviceDescription(AudioDeviceType type,
+ const std::string& connection = "") {
+ AudioDeviceDescription result;
+ result.type = type;
+ result.connection = connection;
+ return result;
+}
+
+void append_AudioDeviceDescription(detail::AudioDevicePairs& pairs,
+ audio_devices_t inputType, audio_devices_t outputType,
+ AudioDeviceType inType, AudioDeviceType outType,
+ const std::string& connection = "") {
+ pairs.push_back(std::make_pair(inputType, make_AudioDeviceDescription(inType, connection)));
+ pairs.push_back(std::make_pair(outputType, make_AudioDeviceDescription(outType, connection)));
+}
+
+const detail::AudioDevicePairs& getAudioDevicePairs() {
+ static const detail::AudioDevicePairs pairs = []() {
+ detail::AudioDevicePairs pairs = {{
+ {
+ AUDIO_DEVICE_NONE, AudioDeviceDescription{}
+ },
+ {
+ AUDIO_DEVICE_OUT_EARPIECE, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_SPEAKER_EARPIECE)
+ },
+ {
+ AUDIO_DEVICE_OUT_SPEAKER, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_SPEAKER)
+ },
+ {
+ AUDIO_DEVICE_OUT_WIRED_HEADPHONE, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_HEADPHONE,
+ GET_DEVICE_DESC_CONNECTION(ANALOG))
+ },
+ {
+ AUDIO_DEVICE_OUT_BLUETOOTH_SCO, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(BT_SCO))
+ },
+ {
+ AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_CARKIT,
+ GET_DEVICE_DESC_CONNECTION(BT_SCO))
+ },
+ {
+ AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_HEADPHONE,
+ GET_DEVICE_DESC_CONNECTION(BT_A2DP))
+ },
+ {
+ AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_SPEAKER,
+ GET_DEVICE_DESC_CONNECTION(BT_A2DP))
+ },
+ {
+ AUDIO_DEVICE_OUT_TELEPHONY_TX, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_TELEPHONY_TX)
+ },
+ {
+ AUDIO_DEVICE_OUT_AUX_LINE, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_LINE_AUX)
+ },
+ {
+ AUDIO_DEVICE_OUT_SPEAKER_SAFE, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_SPEAKER_SAFE)
+ },
+ {
+ AUDIO_DEVICE_OUT_HEARING_AID, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_HEARING_AID,
+ GET_DEVICE_DESC_CONNECTION(WIRELESS))
+ },
+ {
+ AUDIO_DEVICE_OUT_ECHO_CANCELLER, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_ECHO_CANCELLER)
+ },
+ {
+ AUDIO_DEVICE_OUT_BLE_SPEAKER, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_SPEAKER,
+ GET_DEVICE_DESC_CONNECTION(BT_LE))
+ },
+ {
+ AUDIO_DEVICE_OUT_BLE_BROADCAST, make_AudioDeviceDescription(
+ AudioDeviceType::OUT_BROADCAST,
+ GET_DEVICE_DESC_CONNECTION(BT_LE))
+ },
+ // AUDIO_DEVICE_IN_AMBIENT and IN_COMMUNICATION are removed since they were deprecated.
+ {
+ AUDIO_DEVICE_IN_BUILTIN_MIC, make_AudioDeviceDescription(
+ AudioDeviceType::IN_MICROPHONE)
+ },
+ {
+ AUDIO_DEVICE_IN_BACK_MIC, make_AudioDeviceDescription(
+ AudioDeviceType::IN_MICROPHONE_BACK)
+ },
+ {
+ AUDIO_DEVICE_IN_TELEPHONY_RX, make_AudioDeviceDescription(
+ AudioDeviceType::IN_TELEPHONY_RX)
+ },
+ {
+ AUDIO_DEVICE_IN_TV_TUNER, make_AudioDeviceDescription(
+ AudioDeviceType::IN_TV_TUNER)
+ },
+ {
+ AUDIO_DEVICE_IN_LOOPBACK, make_AudioDeviceDescription(
+ AudioDeviceType::IN_LOOPBACK)
+ },
+ {
+ AUDIO_DEVICE_IN_BLUETOOTH_BLE, make_AudioDeviceDescription(
+ AudioDeviceType::IN_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(BT_LE))
+ },
+ {
+ AUDIO_DEVICE_IN_ECHO_REFERENCE, make_AudioDeviceDescription(
+ AudioDeviceType::IN_ECHO_REFERENCE)
+ }
+ }};
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT,
+ AudioDeviceType::IN_DEFAULT, AudioDeviceType::OUT_DEFAULT);
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET,
+ AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
+ GET_DEVICE_DESC_CONNECTION(ANALOG));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
+ AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
+ GET_DEVICE_DESC_CONNECTION(BT_SCO));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_HDMI, AUDIO_DEVICE_OUT_HDMI,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(HDMI));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
+ AudioDeviceType::IN_SUBMIX, AudioDeviceType::OUT_SUBMIX);
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,
+ AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
+ GET_DEVICE_DESC_CONNECTION(ANALOG));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,
+ AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
+ GET_DEVICE_DESC_CONNECTION(USB));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_USB_ACCESSORY, AUDIO_DEVICE_OUT_USB_ACCESSORY,
+ AudioDeviceType::IN_ACCESSORY, AudioDeviceType::OUT_ACCESSORY,
+ GET_DEVICE_DESC_CONNECTION(USB));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_OUT_USB_DEVICE,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(USB));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_FM_TUNER, AUDIO_DEVICE_OUT_FM,
+ AudioDeviceType::IN_FM_TUNER, AudioDeviceType::OUT_FM);
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_LINE, AUDIO_DEVICE_OUT_LINE,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(ANALOG));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_SPDIF, AUDIO_DEVICE_OUT_SPDIF,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(SPDIF));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(BT_A2DP));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_IP, AUDIO_DEVICE_OUT_IP,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(IP_V4));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_OUT_BUS,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(BUS));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_PROXY, AUDIO_DEVICE_OUT_PROXY,
+ AudioDeviceType::IN_AFE_PROXY, AudioDeviceType::OUT_AFE_PROXY);
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_OUT_USB_HEADSET,
+ AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
+ GET_DEVICE_DESC_CONNECTION(USB));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_ARC,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(HDMI_ARC));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_HDMI_EARC, AUDIO_DEVICE_OUT_HDMI_EARC,
+ AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
+ GET_DEVICE_DESC_CONNECTION(HDMI_EARC));
+ append_AudioDeviceDescription(pairs,
+ AUDIO_DEVICE_IN_BLE_HEADSET, AUDIO_DEVICE_OUT_BLE_HEADSET,
+ AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
+ GET_DEVICE_DESC_CONNECTION(BT_LE));
+ return pairs;
+ }();
+#undef GET_DEVICE_DESC_CONNECTION
+ return pairs;
+}
+
+AudioFormatDescription make_AudioFormatDescription(AudioFormatType type) {
+ AudioFormatDescription result;
+ result.type = type;
+ return result;
+}
+
+AudioFormatDescription make_AudioFormatDescription(PcmType pcm) {
+ auto result = make_AudioFormatDescription(AudioFormatType::PCM);
+ result.pcm = pcm;
+ return result;
+}
+
+AudioFormatDescription make_AudioFormatDescription(const std::string& encoding) {
+ AudioFormatDescription result;
+ result.encoding = encoding;
+ return result;
+}
+
+AudioFormatDescription make_AudioFormatDescription(PcmType transport,
+ const std::string& encoding) {
+ auto result = make_AudioFormatDescription(encoding);
+ result.pcm = transport;
+ return result;
+}
+
+const detail::AudioFormatPairs& getAudioFormatPairs() {
+ static const detail::AudioFormatPairs pairs = {{
+ {AUDIO_FORMAT_INVALID,
+ make_AudioFormatDescription(AudioFormatType::SYS_RESERVED_INVALID)},
+ {AUDIO_FORMAT_DEFAULT, AudioFormatDescription{}},
+ {AUDIO_FORMAT_PCM_16_BIT, make_AudioFormatDescription(PcmType::INT_16_BIT)},
+ {AUDIO_FORMAT_PCM_8_BIT, make_AudioFormatDescription(PcmType::UINT_8_BIT)},
+ {AUDIO_FORMAT_PCM_32_BIT, make_AudioFormatDescription(PcmType::INT_32_BIT)},
+ {AUDIO_FORMAT_PCM_8_24_BIT, make_AudioFormatDescription(PcmType::FIXED_Q_8_24)},
+ {AUDIO_FORMAT_PCM_FLOAT, make_AudioFormatDescription(PcmType::FLOAT_32_BIT)},
+ {AUDIO_FORMAT_PCM_24_BIT_PACKED, make_AudioFormatDescription(PcmType::INT_24_BIT)},
+ {AUDIO_FORMAT_MP3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEG)},
+ {AUDIO_FORMAT_AMR_NB,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_NB)},
+ {AUDIO_FORMAT_AMR_WB,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_WB)},
+ {AUDIO_FORMAT_AAC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_MP4)},
+ {AUDIO_FORMAT_AAC_MAIN,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_MAIN)},
+ {AUDIO_FORMAT_AAC_LC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LC)},
+ {AUDIO_FORMAT_AAC_SSR,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_SSR)},
+ {AUDIO_FORMAT_AAC_LTP,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LTP)},
+ {AUDIO_FORMAT_AAC_HE_V1,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_HE_V1)},
+ {AUDIO_FORMAT_AAC_SCALABLE,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_SCALABLE)},
+ {AUDIO_FORMAT_AAC_ERLC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ERLC)},
+ {AUDIO_FORMAT_AAC_LD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LD)},
+ {AUDIO_FORMAT_AAC_HE_V2,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_HE_V2)},
+ {AUDIO_FORMAT_AAC_ELD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ELD)},
+ {AUDIO_FORMAT_AAC_XHE,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_XHE)
+
+ },
+ // AUDIO_FORMAT_HE_AAC_V1 and HE_AAC_V2 are removed since they were deprecated long time
+ // ago.
+ {AUDIO_FORMAT_VORBIS,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_VORBIS)},
+ {AUDIO_FORMAT_OPUS, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_OPUS)},
+ {AUDIO_FORMAT_AC3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AC3)},
+ {AUDIO_FORMAT_E_AC3, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EAC3)},
+ {AUDIO_FORMAT_E_AC3_JOC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EAC3_JOC)},
+ {AUDIO_FORMAT_DTS, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS)},
+ {AUDIO_FORMAT_DTS_HD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_HD)},
+ {AUDIO_FORMAT_DTS_HD_MA,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_HD_MA)},
+ {AUDIO_FORMAT_DTS_UHD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_UHD_P1)},
+ {AUDIO_FORMAT_DTS_UHD_P2,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DTS_UHD_P2)},
+ // In the future, we would like to represent encapsulated bitstreams as
+ // nested AudioFormatDescriptions. The legacy 'AUDIO_FORMAT_IEC61937' type doesn't
+ // specify the format of the encapsulated bitstream.
+ {AUDIO_FORMAT_IEC61937,
+ make_AudioFormatDescription(PcmType::INT_16_BIT,
+ ::android::MEDIA_MIMETYPE_AUDIO_IEC61937)},
+ {AUDIO_FORMAT_DOLBY_TRUEHD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_TRUEHD)},
+ {AUDIO_FORMAT_EVRC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRC)},
+ {AUDIO_FORMAT_EVRCB,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCB)},
+ {AUDIO_FORMAT_EVRCWB,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCWB)},
+ {AUDIO_FORMAT_EVRCNW,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_EVRCNW)},
+ {AUDIO_FORMAT_AAC_ADIF,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADIF)},
+ {AUDIO_FORMAT_WMA, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_WMA)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_WMA_PRO, make_AudioFormatDescription("audio/x-ms-wma.pro")},
+ {AUDIO_FORMAT_AMR_WB_PLUS,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AMR_WB_PLUS)},
+ {AUDIO_FORMAT_MP2,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II)},
+ {AUDIO_FORMAT_QCELP,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_QCELP)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_DSD, make_AudioFormatDescription("audio/vnd.sony.dsd")},
+ {AUDIO_FORMAT_FLAC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_FLAC)},
+ {AUDIO_FORMAT_ALAC, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_ALAC)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APE, make_AudioFormatDescription("audio/x-ape")},
+ {AUDIO_FORMAT_AAC_ADTS,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS)},
+ {AUDIO_FORMAT_AAC_ADTS_MAIN,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_MAIN)},
+ {AUDIO_FORMAT_AAC_ADTS_LC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LC)},
+ {AUDIO_FORMAT_AAC_ADTS_SSR,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SSR)},
+ {AUDIO_FORMAT_AAC_ADTS_LTP,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LTP)},
+ {AUDIO_FORMAT_AAC_ADTS_HE_V1,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V1)},
+ {AUDIO_FORMAT_AAC_ADTS_SCALABLE,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SCALABLE)},
+ {AUDIO_FORMAT_AAC_ADTS_ERLC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ERLC)},
+ {AUDIO_FORMAT_AAC_ADTS_LD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LD)},
+ {AUDIO_FORMAT_AAC_ADTS_HE_V2,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V2)},
+ {AUDIO_FORMAT_AAC_ADTS_ELD,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ELD)},
+ {AUDIO_FORMAT_AAC_ADTS_XHE,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_ADTS_XHE)},
+ {// Note: not in the IANA registry. "vnd.octel.sbc" is not BT SBC.
+ AUDIO_FORMAT_SBC, make_AudioFormatDescription("audio/x-sbc")},
+ {AUDIO_FORMAT_APTX, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_APTX)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APTX_HD, make_AudioFormatDescription("audio/vnd.qcom.aptx.hd")},
+ {AUDIO_FORMAT_AC4, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AC4)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_LDAC, make_AudioFormatDescription("audio/vnd.sony.ldac")},
+ {AUDIO_FORMAT_MAT,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_MAT_1_0,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
+ std::string(".1.0"))},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_MAT_2_0,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
+ std::string(".2.0"))},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_MAT_2_1,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DOLBY_MAT +
+ std::string(".2.1"))},
+ {AUDIO_FORMAT_AAC_LATM,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC)},
+ {AUDIO_FORMAT_AAC_LATM_LC,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_LC)},
+ {AUDIO_FORMAT_AAC_LATM_HE_V1,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V1)},
+ {AUDIO_FORMAT_AAC_LATM_HE_V2,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V2)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_CELT, make_AudioFormatDescription("audio/x-celt")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APTX_ADAPTIVE,
+ make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_LHDC, make_AudioFormatDescription("audio/vnd.savitech.lhdc")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_LHDC_LL, make_AudioFormatDescription("audio/vnd.savitech.lhdc.ll")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APTX_TWSP, make_AudioFormatDescription("audio/vnd.qcom.aptx.twsp")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_LC3, make_AudioFormatDescription("audio/x-lc3")},
+ {AUDIO_FORMAT_MPEGH,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1)},
+ {AUDIO_FORMAT_MPEGH_BL_L3,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L3)},
+ {AUDIO_FORMAT_MPEGH_BL_L4,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L4)},
+ {AUDIO_FORMAT_MPEGH_LC_L3,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L3)},
+ {AUDIO_FORMAT_MPEGH_LC_L4,
+ make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L4)},
+ {AUDIO_FORMAT_IEC60958,
+ make_AudioFormatDescription(PcmType::INT_24_BIT,
+ ::android::MEDIA_MIMETYPE_AUDIO_IEC60958)},
+ {AUDIO_FORMAT_DRA, make_AudioFormatDescription(::android::MEDIA_MIMETYPE_AUDIO_DRA)},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APTX_ADAPTIVE_QLEA,
+ make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r3")},
+ {// Note: not in the IANA registry.
+ AUDIO_FORMAT_APTX_ADAPTIVE_R4,
+ make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r4")},
+ }};
+ return pairs;
+}
+
+template<typename S, typename T>
+std::map<S, T> make_DirectMap(const std::vector<std::pair<S, T>>& v) {
+ std::map<S, T> result(v.begin(), v.end());
+ LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
+ return result;
+}
+
+template<typename S, typename T>
+std::map<S, T> make_DirectMap(
+ const std::vector<std::pair<S, T>>& v1, const std::vector<std::pair<S, T>>& v2) {
+ std::map<S, T> result(v1.begin(), v1.end());
+ LOG_ALWAYS_FATAL_IF(result.size() != v1.size(), "Duplicate key elements detected in v1");
+ result.insert(v2.begin(), v2.end());
+ LOG_ALWAYS_FATAL_IF(result.size() != v1.size() + v2.size(),
+ "Duplicate key elements detected in v1+v2");
+ return result;
+}
+
+template<typename S, typename T>
+std::map<T, S> make_ReverseMap(const std::vector<std::pair<S, T>>& v) {
+ std::map<T, S> result;
+ std::transform(v.begin(), v.end(), std::inserter(result, result.begin()),
+ [](const std::pair<S, T>& p) {
+ return std::make_pair(p.second, p.first);
+ });
+ LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
+ return result;
+}
+
+} // namespace
+
+audio_channel_mask_t aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
+ int aidlLayout, bool isInput) {
+ auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
+ const int aidlLayoutInitial = aidlLayout; // for error message
+ audio_channel_mask_t legacy = AUDIO_CHANNEL_NONE;
+ for (const auto& bitPair : bitMapping) {
+ if ((aidlLayout & bitPair.second) == bitPair.second) {
+ legacy = static_cast<audio_channel_mask_t>(legacy | bitPair.first);
+ aidlLayout &= ~bitPair.second;
+ if (aidlLayout == 0) {
+ return legacy;
+ }
+ }
+ }
+ ALOGE("%s: aidl layout 0x%x contains bits 0x%x that have no match to legacy %s bits",
+ __func__, aidlLayoutInitial, aidlLayout, isInput ? "input" : "output");
+ return AUDIO_CHANNEL_NONE;
+}
+
+ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
+ const AudioChannelLayout& aidl, bool isInput) {
+ using ReverseMap = std::map<AudioChannelLayout, audio_channel_mask_t>;
+ using Tag = AudioChannelLayout::Tag;
+ static const ReverseMap mIn = make_ReverseMap(getInAudioChannelPairs());
+ static const ReverseMap mOut = make_ReverseMap(getOutAudioChannelPairs());
+ static const ReverseMap mVoice = make_ReverseMap(getVoiceAudioChannelPairs());
+
+ auto convert = [](const AudioChannelLayout& aidl, const ReverseMap& m,
+ const char* func, const char* type) -> ConversionResult<audio_channel_mask_t> {
+ if (auto it = m.find(aidl); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGW("%s: no legacy %s audio_channel_mask_t found for %s", func, type,
+ aidl.toString().c_str());
+ return unexpected(BAD_VALUE);
+ }
+ };
+
+ switch (aidl.getTag()) {
+ case Tag::none:
+ return AUDIO_CHANNEL_NONE;
+ case Tag::invalid:
+ return AUDIO_CHANNEL_INVALID;
+ case Tag::indexMask:
+ // Index masks do not have pre-defined values.
+ if (const int bits = aidl.get<Tag::indexMask>();
+ __builtin_popcount(bits) != 0 &&
+ __builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {
+ return audio_channel_mask_from_representation_and_bits(
+ AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
+ } else {
+ ALOGE("%s: invalid indexMask value 0x%x in %s",
+ __func__, bits, aidl.toString().c_str());
+ return unexpected(BAD_VALUE);
+ }
+ case Tag::layoutMask:
+ // The fast path is to find a direct match for some known layout mask.
+ if (const auto layoutMatch = convert(aidl, isInput ? mIn : mOut, __func__,
+ isInput ? "input" : "output");
+ layoutMatch.ok()) {
+ return layoutMatch;
+ }
+ // If a match for a predefined layout wasn't found, make a custom one from bits.
+ if (audio_channel_mask_t bitMask =
+ aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
+ aidl.get<Tag::layoutMask>(), isInput);
+ bitMask != AUDIO_CHANNEL_NONE) {
+ return bitMask;
+ }
+ return unexpected(BAD_VALUE);
+ case Tag::voiceMask:
+ return convert(aidl, mVoice, __func__, "voice");
+ }
+ ALOGE("%s: unexpected tag value %d", __func__, aidl.getTag());
+ return unexpected(BAD_VALUE);
+}
+
+int legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
+ audio_channel_mask_t legacy, bool isInput) {
+ auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
+ const int legacyInitial = legacy; // for error message
+ int aidlLayout = 0;
+ for (const auto& bitPair : bitMapping) {
+ if ((legacy & bitPair.first) == bitPair.first) {
+ aidlLayout |= bitPair.second;
+ legacy = static_cast<audio_channel_mask_t>(legacy & ~bitPair.first);
+ if (legacy == 0) {
+ return aidlLayout;
+ }
+ }
+ }
+ ALOGE("%s: legacy %s audio_channel_mask_t 0x%x contains unrecognized bits 0x%x",
+ __func__, isInput ? "input" : "output", legacyInitial, legacy);
+ return 0;
+}
+
+ConversionResult<AudioChannelLayout> legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
+ audio_channel_mask_t legacy, bool isInput) {
+ using DirectMap = std::map<audio_channel_mask_t, AudioChannelLayout>;
+ using Tag = AudioChannelLayout::Tag;
+ static const DirectMap mInAndVoice = make_DirectMap(
+ getInAudioChannelPairs(), getVoiceAudioChannelPairs());
+ static const DirectMap mOut = make_DirectMap(getOutAudioChannelPairs());
+
+ auto convert = [](const audio_channel_mask_t legacy, const DirectMap& m,
+ const char* func, const char* type) -> ConversionResult<AudioChannelLayout> {
+ if (auto it = m.find(legacy); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGW("%s: no AudioChannelLayout found for legacy %s audio_channel_mask_t value 0x%x",
+ func, type, legacy);
+ return unexpected(BAD_VALUE);
+ }
+ };
+
+ if (legacy == AUDIO_CHANNEL_NONE) {
+ return AudioChannelLayout{};
+ } else if (legacy == AUDIO_CHANNEL_INVALID) {
+ return AudioChannelLayout::make<Tag::invalid>(0);
+ }
+
+ const audio_channel_representation_t repr = audio_channel_mask_get_representation(legacy);
+ if (repr == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
+ if (audio_channel_mask_is_valid(legacy)) {
+ const int indexMask = VALUE_OR_RETURN(
+ convertIntegral<int>(audio_channel_mask_get_bits(legacy)));
+ return AudioChannelLayout::make<Tag::indexMask>(indexMask);
+ } else {
+ ALOGE("%s: legacy audio_channel_mask_t value 0x%x is invalid", __func__, legacy);
+ return unexpected(BAD_VALUE);
+ }
+ } else if (repr == AUDIO_CHANNEL_REPRESENTATION_POSITION) {
+ // The fast path is to find a direct match for some known layout mask.
+ if (const auto layoutMatch = convert(legacy, isInput ? mInAndVoice : mOut, __func__,
+ isInput ? "input / voice" : "output");
+ layoutMatch.ok()) {
+ return layoutMatch;
+ }
+ // If a match for a predefined layout wasn't found, make a custom one from bits,
+ // rejecting those with voice channel bits.
+ if (!isInput ||
+ (legacy & (AUDIO_CHANNEL_IN_VOICE_UPLINK | AUDIO_CHANNEL_IN_VOICE_DNLINK)) == 0) {
+ if (int bitMaskLayout =
+ legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
+ legacy, isInput);
+ bitMaskLayout != 0) {
+ return AudioChannelLayout::make<Tag::layoutMask>(bitMaskLayout);
+ }
+ } else {
+ ALOGE("%s: legacy audio_channel_mask_t value 0x%x contains voice bits",
+ __func__, legacy);
+ }
+ return unexpected(BAD_VALUE);
+ }
+
+ ALOGE("%s: unknown representation %d in audio_channel_mask_t value 0x%x",
+ __func__, repr, legacy);
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
+ const AudioDeviceDescription& aidl) {
+ static const std::map<AudioDeviceDescription, audio_devices_t> m =
+ make_ReverseMap(getAudioDevicePairs());
+ if (auto it = m.find(aidl); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGE("%s: no legacy audio_devices_t found for %s", __func__, aidl.toString().c_str());
+ return unexpected(BAD_VALUE);
+ }
+}
+
+ConversionResult<AudioDeviceDescription> legacy2aidl_audio_devices_t_AudioDeviceDescription(
+ audio_devices_t legacy) {
+ static const std::map<audio_devices_t, AudioDeviceDescription> m =
+ make_DirectMap(getAudioDevicePairs());
+ if (auto it = m.find(legacy); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGE("%s: no AudioDeviceDescription found for legacy audio_devices_t value 0x%x",
+ __func__, legacy);
+ return unexpected(BAD_VALUE);
+ }
+}
+
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const AudioDevice& aidl,
+ audio_devices_t* legacyType, char* legacyAddress) {
+ *legacyType = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
+ return aidl2legacy_string(
+ aidl.address.get<AudioDeviceAddress::id>(),
+ legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN);
+}
+
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const AudioDevice& aidl,
+ audio_devices_t* legacyType, String8* legacyAddress) {
+ *legacyType = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
+ *legacyAddress = VALUE_OR_RETURN_STATUS(aidl2legacy_string_view_String8(
+ aidl.address.get<AudioDeviceAddress::id>()));
+ return OK;
+}
+
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const AudioDevice& aidl,
+ audio_devices_t* legacyType, std::string* legacyAddress) {
+ *legacyType = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
+ *legacyAddress = aidl.address.get<AudioDeviceAddress::id>();
+ return OK;
+}
+
+ConversionResult<AudioDevice> legacy2aidl_audio_device_AudioDevice(
+ audio_devices_t legacyType, const char* legacyAddress) {
+ AudioDevice aidl;
+ aidl.type = VALUE_OR_RETURN(
+ legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
+ const std::string aidl_id = VALUE_OR_RETURN(
+ legacy2aidl_string(legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
+ aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
+ return aidl;
+}
+
+ConversionResult<AudioDevice>
+legacy2aidl_audio_device_AudioDevice(
+ audio_devices_t legacyType, const String8& legacyAddress) {
+ AudioDevice aidl;
+ aidl.type = VALUE_OR_RETURN(
+ legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
+ const std::string aidl_id = VALUE_OR_RETURN(
+ legacy2aidl_String8_string(legacyAddress));
+ aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
+ return aidl;
+}
+
+ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
+ const AudioFormatDescription& aidl) {
+ static const std::map<AudioFormatDescription, audio_format_t> m =
+ make_ReverseMap(getAudioFormatPairs());
+ if (auto it = m.find(aidl); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGE("%s: no legacy audio_format_t found for %s", __func__, aidl.toString().c_str());
+ return unexpected(BAD_VALUE);
+ }
+}
+
+ConversionResult<AudioFormatDescription> legacy2aidl_audio_format_t_AudioFormatDescription(
+ audio_format_t legacy) {
+ static const std::map<audio_format_t, AudioFormatDescription> m =
+ make_DirectMap(getAudioFormatPairs());
+ if (auto it = m.find(legacy); it != m.end()) {
+ return it->second;
+ } else {
+ ALOGE("%s: no AudioFormatDescription found for legacy audio_format_t value 0x%x",
+ __func__, legacy);
+ return unexpected(BAD_VALUE);
+ }
+}
+
+ConversionResult<audio_gain_mode_t> aidl2legacy_AudioGainMode_audio_gain_mode_t(
+ AudioGainMode aidl) {
+ switch (aidl) {
+ case AudioGainMode::JOINT:
+ return AUDIO_GAIN_MODE_JOINT;
+ case AudioGainMode::CHANNELS:
+ return AUDIO_GAIN_MODE_CHANNELS;
+ case AudioGainMode::RAMP:
+ return AUDIO_GAIN_MODE_RAMP;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioGainMode> legacy2aidl_audio_gain_mode_t_AudioGainMode(
+ audio_gain_mode_t legacy) {
+ switch (legacy) {
+ case AUDIO_GAIN_MODE_JOINT:
+ return AudioGainMode::JOINT;
+ case AUDIO_GAIN_MODE_CHANNELS:
+ return AudioGainMode::CHANNELS;
+ case AUDIO_GAIN_MODE_RAMP:
+ return AudioGainMode::RAMP;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl) {
+ return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, AudioGainMode>(
+ aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
+ // AudioGainMode is index-based.
+ indexToEnum_index<AudioGainMode>,
+ // AUDIO_GAIN_MODE_* constants are mask-based.
+ enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy) {
+ return convertBitmask<int32_t, audio_gain_mode_t, AudioGainMode, audio_gain_mode_t>(
+ legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
+ // AUDIO_GAIN_MODE_* constants are mask-based.
+ indexToEnum_bitmask<audio_gain_mode_t>,
+ // AudioGainMode is index-based.
+ enumToMask_index<int32_t, AudioGainMode>);
+}
+
+ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
+ const AudioGainConfig& aidl, bool isInput) {
+ audio_gain_config legacy;
+ legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
+ legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
+ legacy.channel_mask = VALUE_OR_RETURN(
+ aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
+ const bool isJoint = bitmaskIsSet(aidl.mode, AudioGainMode::JOINT);
+ size_t numValues = isJoint ? 1
+ : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
+ : audio_channel_count_from_out_mask(legacy.channel_mask);
+ if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
+ return unexpected(BAD_VALUE);
+ }
+ for (size_t i = 0; i < numValues; ++i) {
+ legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
+ }
+ legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
+ return legacy;
+}
+
+ConversionResult<AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
+ const audio_gain_config& legacy, bool isInput) {
+ AudioGainConfig aidl;
+ aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
+ aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
+ aidl.channelMask = VALUE_OR_RETURN(
+ legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
+ const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
+ size_t numValues = isJoint ? 1
+ : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
+ : audio_channel_count_from_out_mask(legacy.channel_mask);
+ aidl.values.resize(numValues);
+ for (size_t i = 0; i < numValues; ++i) {
+ aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
+ }
+ aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
+ return aidl;
+}
+
+ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
+ AudioInputFlags aidl) {
+ switch (aidl) {
+ case AudioInputFlags::FAST:
+ return AUDIO_INPUT_FLAG_FAST;
+ case AudioInputFlags::HW_HOTWORD:
+ return AUDIO_INPUT_FLAG_HW_HOTWORD;
+ case AudioInputFlags::RAW:
+ return AUDIO_INPUT_FLAG_RAW;
+ case AudioInputFlags::SYNC:
+ return AUDIO_INPUT_FLAG_SYNC;
+ case AudioInputFlags::MMAP_NOIRQ:
+ return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
+ case AudioInputFlags::VOIP_TX:
+ return AUDIO_INPUT_FLAG_VOIP_TX;
+ case AudioInputFlags::HW_AV_SYNC:
+ return AUDIO_INPUT_FLAG_HW_AV_SYNC;
+ case AudioInputFlags::DIRECT:
+ return AUDIO_INPUT_FLAG_DIRECT;
+ case AudioInputFlags::ULTRASOUND:
+ return AUDIO_INPUT_FLAG_ULTRASOUND;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
+ audio_input_flags_t legacy) {
+ switch (legacy) {
+ case AUDIO_INPUT_FLAG_NONE:
+ break; // shouldn't get here. must be listed -Werror,-Wswitch
+ case AUDIO_INPUT_FLAG_FAST:
+ return AudioInputFlags::FAST;
+ case AUDIO_INPUT_FLAG_HW_HOTWORD:
+ return AudioInputFlags::HW_HOTWORD;
+ case AUDIO_INPUT_FLAG_RAW:
+ return AudioInputFlags::RAW;
+ case AUDIO_INPUT_FLAG_SYNC:
+ return AudioInputFlags::SYNC;
+ case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
+ return AudioInputFlags::MMAP_NOIRQ;
+ case AUDIO_INPUT_FLAG_VOIP_TX:
+ return AudioInputFlags::VOIP_TX;
+ case AUDIO_INPUT_FLAG_HW_AV_SYNC:
+ return AudioInputFlags::HW_AV_SYNC;
+ case AUDIO_INPUT_FLAG_DIRECT:
+ return AudioInputFlags::DIRECT;
+ case AUDIO_INPUT_FLAG_ULTRASOUND:
+ return AudioInputFlags::ULTRASOUND;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
+ AudioOutputFlags aidl) {
+ switch (aidl) {
+ case AudioOutputFlags::DIRECT:
+ return AUDIO_OUTPUT_FLAG_DIRECT;
+ case AudioOutputFlags::PRIMARY:
+ return AUDIO_OUTPUT_FLAG_PRIMARY;
+ case AudioOutputFlags::FAST:
+ return AUDIO_OUTPUT_FLAG_FAST;
+ case AudioOutputFlags::DEEP_BUFFER:
+ return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
+ case AudioOutputFlags::COMPRESS_OFFLOAD:
+ return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
+ case AudioOutputFlags::NON_BLOCKING:
+ return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
+ case AudioOutputFlags::HW_AV_SYNC:
+ return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
+ case AudioOutputFlags::TTS:
+ return AUDIO_OUTPUT_FLAG_TTS;
+ case AudioOutputFlags::RAW:
+ return AUDIO_OUTPUT_FLAG_RAW;
+ case AudioOutputFlags::SYNC:
+ return AUDIO_OUTPUT_FLAG_SYNC;
+ case AudioOutputFlags::IEC958_NONAUDIO:
+ return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
+ case AudioOutputFlags::DIRECT_PCM:
+ return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
+ case AudioOutputFlags::MMAP_NOIRQ:
+ return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
+ case AudioOutputFlags::VOIP_RX:
+ return AUDIO_OUTPUT_FLAG_VOIP_RX;
+ case AudioOutputFlags::INCALL_MUSIC:
+ return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
+ case AudioOutputFlags::GAPLESS_OFFLOAD:
+ return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
+ case AudioOutputFlags::ULTRASOUND:
+ return AUDIO_OUTPUT_FLAG_ULTRASOUND;
+ case AudioOutputFlags::SPATIALIZER:
+ return AUDIO_OUTPUT_FLAG_SPATIALIZER;
+ case AudioOutputFlags::BIT_PERFECT:
+ return AUDIO_OUTPUT_FLAG_BIT_PERFECT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
+ audio_output_flags_t legacy) {
+ switch (legacy) {
+ case AUDIO_OUTPUT_FLAG_NONE:
+ break; // shouldn't get here. must be listed -Werror,-Wswitch
+ case AUDIO_OUTPUT_FLAG_DIRECT:
+ return AudioOutputFlags::DIRECT;
+ case AUDIO_OUTPUT_FLAG_PRIMARY:
+ return AudioOutputFlags::PRIMARY;
+ case AUDIO_OUTPUT_FLAG_FAST:
+ return AudioOutputFlags::FAST;
+ case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
+ return AudioOutputFlags::DEEP_BUFFER;
+ case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
+ return AudioOutputFlags::COMPRESS_OFFLOAD;
+ case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
+ return AudioOutputFlags::NON_BLOCKING;
+ case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
+ return AudioOutputFlags::HW_AV_SYNC;
+ case AUDIO_OUTPUT_FLAG_TTS:
+ return AudioOutputFlags::TTS;
+ case AUDIO_OUTPUT_FLAG_RAW:
+ return AudioOutputFlags::RAW;
+ case AUDIO_OUTPUT_FLAG_SYNC:
+ return AudioOutputFlags::SYNC;
+ case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
+ return AudioOutputFlags::IEC958_NONAUDIO;
+ case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
+ return AudioOutputFlags::DIRECT_PCM;
+ case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
+ return AudioOutputFlags::MMAP_NOIRQ;
+ case AUDIO_OUTPUT_FLAG_VOIP_RX:
+ return AudioOutputFlags::VOIP_RX;
+ case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
+ return AudioOutputFlags::INCALL_MUSIC;
+ case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
+ return AudioOutputFlags::GAPLESS_OFFLOAD;
+ case AUDIO_OUTPUT_FLAG_ULTRASOUND:
+ return AudioOutputFlags::ULTRASOUND;
+ case AUDIO_OUTPUT_FLAG_SPATIALIZER:
+ return AudioOutputFlags::SPATIALIZER;
+ case AUDIO_OUTPUT_FLAG_BIT_PERFECT:
+ return AudioOutputFlags::BIT_PERFECT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
+ int32_t aidl) {
+ using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
+
+ LegacyMask converted = VALUE_OR_RETURN(
+ (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
+ aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
+ indexToEnum_index<AudioInputFlags>,
+ enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
+ return static_cast<audio_input_flags_t>(converted);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
+ audio_input_flags_t legacy) {
+ using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
+
+ LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
+ return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
+ legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
+ indexToEnum_bitmask<audio_input_flags_t>,
+ enumToMask_index<int32_t, AudioInputFlags>);
+}
+
+ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
+ int32_t aidl) {
+ return convertBitmask<audio_output_flags_t,
+ int32_t,
+ audio_output_flags_t,
+ AudioOutputFlags>(
+ aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
+ indexToEnum_index<AudioOutputFlags>,
+ enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
+ audio_output_flags_t legacy) {
+ using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
+
+ LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
+ return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
+ legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
+ indexToEnum_bitmask<audio_output_flags_t>,
+ enumToMask_index<int32_t, AudioOutputFlags>);
+}
+
+ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
+ const AudioIoFlags& aidl, bool isInput) {
+ audio_io_flags legacy;
+ if (isInput) {
+ legacy.input = VALUE_OR_RETURN(
+ aidl2legacy_int32_t_audio_input_flags_t_mask(
+ VALUE_OR_RETURN(UNION_GET(aidl, input))));
+ } else {
+ legacy.output = VALUE_OR_RETURN(
+ aidl2legacy_int32_t_audio_output_flags_t_mask(
+ VALUE_OR_RETURN(UNION_GET(aidl, output))));
+ }
+ return legacy;
+}
+
+ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
+ const audio_io_flags& legacy, bool isInput) {
+ AudioIoFlags aidl;
+ if (isInput) {
+ UNION_SET(aidl, input,
+ VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
+ } else {
+ UNION_SET(aidl, output,
+ VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
+ }
+ return aidl;
+}
+
+ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
+ AudioStreamType aidl) {
+ switch (aidl) {
+ case AudioStreamType::INVALID:
+ break; // return error
+ case AudioStreamType::SYS_RESERVED_DEFAULT:
+ return AUDIO_STREAM_DEFAULT;
+ case AudioStreamType::VOICE_CALL:
+ return AUDIO_STREAM_VOICE_CALL;
+ case AudioStreamType::SYSTEM:
+ return AUDIO_STREAM_SYSTEM;
+ case AudioStreamType::RING:
+ return AUDIO_STREAM_RING;
+ case AudioStreamType::MUSIC:
+ return AUDIO_STREAM_MUSIC;
+ case AudioStreamType::ALARM:
+ return AUDIO_STREAM_ALARM;
+ case AudioStreamType::NOTIFICATION:
+ return AUDIO_STREAM_NOTIFICATION;
+ case AudioStreamType::BLUETOOTH_SCO:
+ return AUDIO_STREAM_BLUETOOTH_SCO;
+ case AudioStreamType::ENFORCED_AUDIBLE:
+ return AUDIO_STREAM_ENFORCED_AUDIBLE;
+ case AudioStreamType::DTMF:
+ return AUDIO_STREAM_DTMF;
+ case AudioStreamType::TTS:
+ return AUDIO_STREAM_TTS;
+ case AudioStreamType::ACCESSIBILITY:
+ return AUDIO_STREAM_ACCESSIBILITY;
+ case AudioStreamType::ASSISTANT:
+ return AUDIO_STREAM_ASSISTANT;
+ case AudioStreamType::SYS_RESERVED_REROUTING:
+ return AUDIO_STREAM_REROUTING;
+ case AudioStreamType::SYS_RESERVED_PATCH:
+ return AUDIO_STREAM_PATCH;
+ case AudioStreamType::CALL_ASSISTANT:
+ return AUDIO_STREAM_CALL_ASSISTANT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
+ audio_stream_type_t legacy) {
+ switch (legacy) {
+ case AUDIO_STREAM_DEFAULT:
+ return AudioStreamType::SYS_RESERVED_DEFAULT;
+ case AUDIO_STREAM_VOICE_CALL:
+ return AudioStreamType::VOICE_CALL;
+ case AUDIO_STREAM_SYSTEM:
+ return AudioStreamType::SYSTEM;
+ case AUDIO_STREAM_RING:
+ return AudioStreamType::RING;
+ case AUDIO_STREAM_MUSIC:
+ return AudioStreamType::MUSIC;
+ case AUDIO_STREAM_ALARM:
+ return AudioStreamType::ALARM;
+ case AUDIO_STREAM_NOTIFICATION:
+ return AudioStreamType::NOTIFICATION;
+ case AUDIO_STREAM_BLUETOOTH_SCO:
+ return AudioStreamType::BLUETOOTH_SCO;
+ case AUDIO_STREAM_ENFORCED_AUDIBLE:
+ return AudioStreamType::ENFORCED_AUDIBLE;
+ case AUDIO_STREAM_DTMF:
+ return AudioStreamType::DTMF;
+ case AUDIO_STREAM_TTS:
+ return AudioStreamType::TTS;
+ case AUDIO_STREAM_ACCESSIBILITY:
+ return AudioStreamType::ACCESSIBILITY;
+ case AUDIO_STREAM_ASSISTANT:
+ return AudioStreamType::ASSISTANT;
+ case AUDIO_STREAM_REROUTING:
+ return AudioStreamType::SYS_RESERVED_REROUTING;
+ case AUDIO_STREAM_PATCH:
+ return AudioStreamType::SYS_RESERVED_PATCH;
+ case AUDIO_STREAM_CALL_ASSISTANT:
+ return AudioStreamType::CALL_ASSISTANT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
+ AudioSource aidl) {
+ switch (aidl) {
+ case AudioSource::SYS_RESERVED_INVALID:
+ return AUDIO_SOURCE_INVALID;
+ case AudioSource::DEFAULT:
+ return AUDIO_SOURCE_DEFAULT;
+ case AudioSource::MIC:
+ return AUDIO_SOURCE_MIC;
+ case AudioSource::VOICE_UPLINK:
+ return AUDIO_SOURCE_VOICE_UPLINK;
+ case AudioSource::VOICE_DOWNLINK:
+ return AUDIO_SOURCE_VOICE_DOWNLINK;
+ case AudioSource::VOICE_CALL:
+ return AUDIO_SOURCE_VOICE_CALL;
+ case AudioSource::CAMCORDER:
+ return AUDIO_SOURCE_CAMCORDER;
+ case AudioSource::VOICE_RECOGNITION:
+ return AUDIO_SOURCE_VOICE_RECOGNITION;
+ case AudioSource::VOICE_COMMUNICATION:
+ return AUDIO_SOURCE_VOICE_COMMUNICATION;
+ case AudioSource::REMOTE_SUBMIX:
+ return AUDIO_SOURCE_REMOTE_SUBMIX;
+ case AudioSource::UNPROCESSED:
+ return AUDIO_SOURCE_UNPROCESSED;
+ case AudioSource::VOICE_PERFORMANCE:
+ return AUDIO_SOURCE_VOICE_PERFORMANCE;
+ case AudioSource::ULTRASOUND:
+ return AUDIO_SOURCE_ULTRASOUND;
+ case AudioSource::ECHO_REFERENCE:
+ return AUDIO_SOURCE_ECHO_REFERENCE;
+ case AudioSource::FM_TUNER:
+ return AUDIO_SOURCE_FM_TUNER;
+ case AudioSource::HOTWORD:
+ return AUDIO_SOURCE_HOTWORD;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
+ audio_source_t legacy) {
+ switch (legacy) {
+ case AUDIO_SOURCE_INVALID:
+ return AudioSource::SYS_RESERVED_INVALID;
+ case AUDIO_SOURCE_DEFAULT:
+ return AudioSource::DEFAULT;
+ case AUDIO_SOURCE_MIC:
+ return AudioSource::MIC;
+ case AUDIO_SOURCE_VOICE_UPLINK:
+ return AudioSource::VOICE_UPLINK;
+ case AUDIO_SOURCE_VOICE_DOWNLINK:
+ return AudioSource::VOICE_DOWNLINK;
+ case AUDIO_SOURCE_VOICE_CALL:
+ return AudioSource::VOICE_CALL;
+ case AUDIO_SOURCE_CAMCORDER:
+ return AudioSource::CAMCORDER;
+ case AUDIO_SOURCE_VOICE_RECOGNITION:
+ return AudioSource::VOICE_RECOGNITION;
+ case AUDIO_SOURCE_VOICE_COMMUNICATION:
+ return AudioSource::VOICE_COMMUNICATION;
+ case AUDIO_SOURCE_REMOTE_SUBMIX:
+ return AudioSource::REMOTE_SUBMIX;
+ case AUDIO_SOURCE_UNPROCESSED:
+ return AudioSource::UNPROCESSED;
+ case AUDIO_SOURCE_VOICE_PERFORMANCE:
+ return AudioSource::VOICE_PERFORMANCE;
+ case AUDIO_SOURCE_ULTRASOUND:
+ return AudioSource::ULTRASOUND;
+ case AUDIO_SOURCE_ECHO_REFERENCE:
+ return AudioSource::ECHO_REFERENCE;
+ case AUDIO_SOURCE_FM_TUNER:
+ return AudioSource::FM_TUNER;
+ case AUDIO_SOURCE_HOTWORD:
+ return AudioSource::HOTWORD;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
+ return convertReinterpret<audio_session_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_content_type_t>
+aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
+ switch (aidl) {
+ case AudioContentType::UNKNOWN:
+ return AUDIO_CONTENT_TYPE_UNKNOWN;
+ case AudioContentType::SPEECH:
+ return AUDIO_CONTENT_TYPE_SPEECH;
+ case AudioContentType::MUSIC:
+ return AUDIO_CONTENT_TYPE_MUSIC;
+ case AudioContentType::MOVIE:
+ return AUDIO_CONTENT_TYPE_MOVIE;
+ case AudioContentType::SONIFICATION:
+ return AUDIO_CONTENT_TYPE_SONIFICATION;
+ case AudioContentType::ULTRASOUND:
+ return AUDIO_CONTENT_TYPE_ULTRASOUND;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioContentType>
+legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
+ switch (legacy) {
+ case AUDIO_CONTENT_TYPE_UNKNOWN:
+ return AudioContentType::UNKNOWN;
+ case AUDIO_CONTENT_TYPE_SPEECH:
+ return AudioContentType::SPEECH;
+ case AUDIO_CONTENT_TYPE_MUSIC:
+ return AudioContentType::MUSIC;
+ case AUDIO_CONTENT_TYPE_MOVIE:
+ return AudioContentType::MOVIE;
+ case AUDIO_CONTENT_TYPE_SONIFICATION:
+ return AudioContentType::SONIFICATION;
+ case AUDIO_CONTENT_TYPE_ULTRASOUND:
+ return AudioContentType::ULTRASOUND;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_usage_t>
+aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
+ switch (aidl) {
+ case AudioUsage::INVALID:
+ break; // return error
+ case AudioUsage::UNKNOWN:
+ return AUDIO_USAGE_UNKNOWN;
+ case AudioUsage::MEDIA:
+ return AUDIO_USAGE_MEDIA;
+ case AudioUsage::VOICE_COMMUNICATION:
+ return AUDIO_USAGE_VOICE_COMMUNICATION;
+ case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
+ return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
+ case AudioUsage::ALARM:
+ return AUDIO_USAGE_ALARM;
+ case AudioUsage::NOTIFICATION:
+ return AUDIO_USAGE_NOTIFICATION;
+ case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
+ return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
+ case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
+ return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
+ case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
+ return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
+ case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
+ return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
+ case AudioUsage::NOTIFICATION_EVENT:
+ return AUDIO_USAGE_NOTIFICATION_EVENT;
+ case AudioUsage::ASSISTANCE_ACCESSIBILITY:
+ return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
+ case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
+ return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
+ case AudioUsage::ASSISTANCE_SONIFICATION:
+ return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
+ case AudioUsage::GAME:
+ return AUDIO_USAGE_GAME;
+ case AudioUsage::VIRTUAL_SOURCE:
+ return AUDIO_USAGE_VIRTUAL_SOURCE;
+ case AudioUsage::ASSISTANT:
+ return AUDIO_USAGE_ASSISTANT;
+ case AudioUsage::CALL_ASSISTANT:
+ return AUDIO_USAGE_CALL_ASSISTANT;
+ case AudioUsage::EMERGENCY:
+ return AUDIO_USAGE_EMERGENCY;
+ case AudioUsage::SAFETY:
+ return AUDIO_USAGE_SAFETY;
+ case AudioUsage::VEHICLE_STATUS:
+ return AUDIO_USAGE_VEHICLE_STATUS;
+ case AudioUsage::ANNOUNCEMENT:
+ return AUDIO_USAGE_ANNOUNCEMENT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioUsage>
+legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
+ switch (legacy) {
+ case AUDIO_USAGE_UNKNOWN:
+ return AudioUsage::UNKNOWN;
+ case AUDIO_USAGE_MEDIA:
+ return AudioUsage::MEDIA;
+ case AUDIO_USAGE_VOICE_COMMUNICATION:
+ return AudioUsage::VOICE_COMMUNICATION;
+ case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
+ return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
+ case AUDIO_USAGE_ALARM:
+ return AudioUsage::ALARM;
+ case AUDIO_USAGE_NOTIFICATION:
+ return AudioUsage::NOTIFICATION;
+ case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
+ return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
+ case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
+ return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
+ case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
+ return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
+ case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
+ return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
+ case AUDIO_USAGE_NOTIFICATION_EVENT:
+ return AudioUsage::NOTIFICATION_EVENT;
+ case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
+ return AudioUsage::ASSISTANCE_ACCESSIBILITY;
+ case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
+ return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
+ case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
+ return AudioUsage::ASSISTANCE_SONIFICATION;
+ case AUDIO_USAGE_GAME:
+ return AudioUsage::GAME;
+ case AUDIO_USAGE_VIRTUAL_SOURCE:
+ return AudioUsage::VIRTUAL_SOURCE;
+ case AUDIO_USAGE_ASSISTANT:
+ return AudioUsage::ASSISTANT;
+ case AUDIO_USAGE_CALL_ASSISTANT:
+ return AudioUsage::CALL_ASSISTANT;
+ case AUDIO_USAGE_EMERGENCY:
+ return AudioUsage::EMERGENCY;
+ case AUDIO_USAGE_SAFETY:
+ return AudioUsage::SAFETY;
+ case AUDIO_USAGE_VEHICLE_STATUS:
+ return AudioUsage::VEHICLE_STATUS;
+ case AUDIO_USAGE_ANNOUNCEMENT:
+ return AudioUsage::ANNOUNCEMENT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+
+ConversionResult<audio_encapsulation_mode_t>
+aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
+ switch (aidl) {
+ case AudioEncapsulationMode::INVALID:
+ break; // return error
+ case AudioEncapsulationMode::NONE:
+ return AUDIO_ENCAPSULATION_MODE_NONE;
+ case AudioEncapsulationMode::ELEMENTARY_STREAM:
+ return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
+ case AudioEncapsulationMode::HANDLE:
+ return AUDIO_ENCAPSULATION_MODE_HANDLE;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioEncapsulationMode>
+legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
+ switch (legacy) {
+ case AUDIO_ENCAPSULATION_MODE_NONE:
+ return AudioEncapsulationMode::NONE;
+ case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
+ return AudioEncapsulationMode::ELEMENTARY_STREAM;
+ case AUDIO_ENCAPSULATION_MODE_HANDLE:
+ return AudioEncapsulationMode::HANDLE;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_offload_info_t>
+aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
+ audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
+ audio_config_base_t base = VALUE_OR_RETURN(
+ aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
+ legacy.sample_rate = base.sample_rate;
+ legacy.channel_mask = base.channel_mask;
+ legacy.format = base.format;
+ legacy.stream_type = VALUE_OR_RETURN(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
+ legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));
+ legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
+ legacy.has_video = aidl.hasVideo;
+ legacy.is_streaming = aidl.isStreaming;
+ legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
+ legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
+ legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
+ legacy.encapsulation_mode = VALUE_OR_RETURN(
+ aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
+ legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
+ legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
+ return legacy;
+}
+
+ConversionResult<AudioOffloadInfo>
+legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
+ AudioOffloadInfo aidl;
+ // Version 0.1 fields.
+ if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
+ return unexpected(BAD_VALUE);
+ }
+ const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
+ .channel_mask = legacy.channel_mask, .format = legacy.format };
+ aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
+ base, false /*isInput*/));
+ aidl.streamType = VALUE_OR_RETURN(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
+ aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
+ aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
+ aidl.hasVideo = legacy.has_video;
+ aidl.isStreaming = legacy.is_streaming;
+ aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
+ aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
+ aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
+
+ // Version 0.2 fields.
+ if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
+ if (legacy.size <
+ offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
+ return unexpected(BAD_VALUE);
+ }
+ aidl.encapsulationMode = VALUE_OR_RETURN(
+ legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
+ legacy.encapsulation_mode));
+ aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
+ aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
+ }
+ return aidl;
+}
+
+ConversionResult<audio_config_t>
+aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
+ const audio_config_base_t legacyBase = VALUE_OR_RETURN(
+ aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
+ audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
+ legacy.sample_rate = legacyBase.sample_rate;
+ legacy.channel_mask = legacyBase.channel_mask;
+ legacy.format = legacyBase.format;
+ legacy.offload_info = VALUE_OR_RETURN(
+ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
+ legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
+ return legacy;
+}
+
+ConversionResult<AudioConfig>
+legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
+ const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
+ .channel_mask = legacy.channel_mask, .format = legacy.format };
+ AudioConfig aidl;
+ aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
+ aidl.offloadInfo = VALUE_OR_RETURN(
+ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
+ aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
+ return aidl;
+}
+
+ConversionResult<audio_config_base_t>
+aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
+ audio_config_base_t legacy;
+ legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
+ legacy.channel_mask = VALUE_OR_RETURN(
+ aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
+ legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
+ return legacy;
+}
+
+ConversionResult<AudioConfigBase>
+legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
+ AudioConfigBase aidl;
+ aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
+ aidl.channelMask = VALUE_OR_RETURN(
+ legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
+ aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
+ return aidl;
+}
+
+ConversionResult<audio_uuid_t>
+aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
+ audio_uuid_t legacy;
+ legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
+ legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
+ legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
+ legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
+ if (aidl.node.size() != std::size(legacy.node)) {
+ return unexpected(BAD_VALUE);
+ }
+ std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
+ return legacy;
+}
+
+ConversionResult<AudioUuid>
+legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
+ AudioUuid aidl;
+ aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
+ aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
+ aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
+ aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
+ std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
+ return aidl;
+}
+
+ConversionResult<audio_encapsulation_metadata_type_t>
+aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
+ AudioEncapsulationMetadataType aidl) {
+ switch (aidl) {
+ case AudioEncapsulationMetadataType::NONE:
+ return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
+ case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
+ return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
+ case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
+ return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioEncapsulationMetadataType>
+legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
+ audio_encapsulation_metadata_type_t legacy) {
+ switch (legacy) {
+ case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
+ return AudioEncapsulationMetadataType::NONE;
+ case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
+ return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
+ case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
+ return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
+ return convertBitmask<uint32_t,
+ int32_t,
+ audio_encapsulation_mode_t,
+ AudioEncapsulationMode>(
+ aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
+ indexToEnum_index<AudioEncapsulationMode>,
+ enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
+ return convertBitmask<int32_t,
+ uint32_t,
+ AudioEncapsulationMode,
+ audio_encapsulation_mode_t>(
+ legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
+ indexToEnum_index<audio_encapsulation_mode_t>,
+ enumToMask_index<int32_t, AudioEncapsulationMode>);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
+ return convertBitmask<uint32_t,
+ int32_t,
+ audio_encapsulation_metadata_type_t,
+ AudioEncapsulationMetadataType>(
+ aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
+ indexToEnum_index<AudioEncapsulationMetadataType>,
+ enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
+ return convertBitmask<int32_t,
+ uint32_t,
+ AudioEncapsulationMetadataType,
+ audio_encapsulation_metadata_type_t>(
+ legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
+ indexToEnum_index<audio_encapsulation_metadata_type_t>,
+ enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
+}
+
+ConversionResult<audio_profile>
+aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
+ audio_profile legacy;
+ legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
+
+ if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
+ return unexpected(BAD_VALUE);
+ }
+ RETURN_IF_ERROR(
+ convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
+ convertIntegral<int32_t, unsigned int>));
+ legacy.num_sample_rates = aidl.sampleRates.size();
+
+ if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
+ return unexpected(BAD_VALUE);
+ }
+ RETURN_IF_ERROR(
+ convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
+ [isInput](const AudioChannelLayout& l) {
+ return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
+ }));
+ legacy.num_channel_masks = aidl.channelMasks.size();
+
+ legacy.encapsulation_type = VALUE_OR_RETURN(
+ aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
+ return legacy;
+}
+
+ConversionResult<AudioProfile>
+legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
+ AudioProfile aidl;
+ aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
+
+ if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
+ return unexpected(BAD_VALUE);
+ }
+ RETURN_IF_ERROR(
+ convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
+ std::back_inserter(aidl.sampleRates),
+ convertIntegral<unsigned int, int32_t>));
+
+ if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
+ return unexpected(BAD_VALUE);
+ }
+ RETURN_IF_ERROR(
+ convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
+ std::back_inserter(aidl.channelMasks),
+ [isInput](audio_channel_mask_t m) {
+ return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
+ }));
+
+ aidl.encapsulationType = VALUE_OR_RETURN(
+ legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
+ legacy.encapsulation_type));
+ return aidl;
+}
+
+ConversionResult<audio_gain>
+aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
+ audio_gain legacy;
+ legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
+ legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
+ aidl.channelMask, isInput));
+ legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
+ legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
+ legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
+ legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
+ legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
+ legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
+ return legacy;
+}
+
+ConversionResult<AudioGain>
+legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
+ AudioGain aidl;
+ aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
+ aidl.channelMask = VALUE_OR_RETURN(
+ legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
+ aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
+ aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
+ aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
+ aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
+ aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
+ aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
+ return aidl;
+}
+
+ConversionResult<audio_mode_t>
+aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
+ switch (aidl) {
+ case AudioMode::SYS_RESERVED_INVALID:
+ return AUDIO_MODE_INVALID;
+ case AudioMode::SYS_RESERVED_CURRENT:
+ return AUDIO_MODE_CURRENT;
+ case AudioMode::NORMAL:
+ return AUDIO_MODE_NORMAL;
+ case AudioMode::RINGTONE:
+ return AUDIO_MODE_RINGTONE;
+ case AudioMode::IN_CALL:
+ return AUDIO_MODE_IN_CALL;
+ case AudioMode::IN_COMMUNICATION:
+ return AUDIO_MODE_IN_COMMUNICATION;
+ case AudioMode::CALL_SCREEN:
+ return AUDIO_MODE_CALL_SCREEN;
+ case AudioMode::SYS_RESERVED_CALL_REDIRECT:
+ return AUDIO_MODE_CALL_REDIRECT;
+ case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
+ return AUDIO_MODE_COMMUNICATION_REDIRECT;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioMode>
+legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
+ switch (legacy) {
+ case AUDIO_MODE_INVALID:
+ return AudioMode::SYS_RESERVED_INVALID;
+ case AUDIO_MODE_CURRENT:
+ return AudioMode::SYS_RESERVED_CURRENT;
+ case AUDIO_MODE_NORMAL:
+ return AudioMode::NORMAL;
+ case AUDIO_MODE_RINGTONE:
+ return AudioMode::RINGTONE;
+ case AUDIO_MODE_IN_CALL:
+ return AudioMode::IN_CALL;
+ case AUDIO_MODE_IN_COMMUNICATION:
+ return AudioMode::IN_COMMUNICATION;
+ case AUDIO_MODE_CALL_SCREEN:
+ return AudioMode::CALL_SCREEN;
+ case AUDIO_MODE_CALL_REDIRECT:
+ return AudioMode::SYS_RESERVED_CALL_REDIRECT;
+ case AUDIO_MODE_COMMUNICATION_REDIRECT:
+ return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
+ case AUDIO_MODE_CNT:
+ break;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_standard_t>
+aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
+ switch (aidl) {
+ case AudioStandard::NONE:
+ return AUDIO_STANDARD_NONE;
+ case AudioStandard::EDID:
+ return AUDIO_STANDARD_EDID;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioStandard>
+legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
+ switch (legacy) {
+ case AUDIO_STANDARD_NONE:
+ return AudioStandard::NONE;
+ case AUDIO_STANDARD_EDID:
+ return AudioStandard::EDID;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_extra_audio_descriptor>
+aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
+ const ExtraAudioDescriptor& aidl) {
+ audio_extra_audio_descriptor legacy;
+ legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
+ if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
+ return unexpected(BAD_VALUE);
+ }
+ legacy.descriptor_length = aidl.audioDescriptor.size();
+ std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
+ std::begin(legacy.descriptor));
+ legacy.encapsulation_type =
+ VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
+ aidl.encapsulationType));
+ return legacy;
+}
+
+ConversionResult<ExtraAudioDescriptor>
+legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
+ const audio_extra_audio_descriptor& legacy) {
+ ExtraAudioDescriptor aidl;
+ aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
+ if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
+ return unexpected(BAD_VALUE);
+ }
+ aidl.audioDescriptor.resize(legacy.descriptor_length);
+ std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
+ aidl.audioDescriptor.begin());
+ aidl.encapsulationType =
+ VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
+ legacy.encapsulation_type));
+ return aidl;
+}
+
+ConversionResult<audio_encapsulation_type_t>
+aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
+ const AudioEncapsulationType& aidl) {
+ switch (aidl) {
+ case AudioEncapsulationType::NONE:
+ return AUDIO_ENCAPSULATION_TYPE_NONE;
+ case AudioEncapsulationType::IEC61937:
+ return AUDIO_ENCAPSULATION_TYPE_IEC61937;
+ case AudioEncapsulationType::PCM:
+ return AUDIO_ENCAPSULATION_TYPE_PCM;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<AudioEncapsulationType>
+legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
+ const audio_encapsulation_type_t & legacy) {
+ switch (legacy) {
+ case AUDIO_ENCAPSULATION_TYPE_NONE:
+ return AudioEncapsulationType::NONE;
+ case AUDIO_ENCAPSULATION_TYPE_IEC61937:
+ return AudioEncapsulationType::IEC61937;
+ case AUDIO_ENCAPSULATION_TYPE_PCM:
+ return AudioEncapsulationType::PCM;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+} // namespace android
+
+#if defined(BACKEND_NDK)
+} // aidl
+#endif
\ No newline at end of file
diff --git a/media/audioaidlconversion/Android.bp b/media/audioaidlconversion/Android.bp
new file mode 100644
index 0000000..4a1df3a
--- /dev/null
+++ b/media/audioaidlconversion/Android.bp
@@ -0,0 +1,140 @@
+package {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "frameworks_av_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ default_applicable_licenses: ["frameworks_av_license"],
+}
+
+cc_defaults {
+ name: "audio_aidl_conversion_common_util_default",
+ host_supported: true,
+ vendor_available: true,
+ double_loadable: true,
+ min_sdk_version: "29",
+ export_include_dirs: [
+ "include",
+ ],
+ header_libs: [
+ "libbase_headers",
+ "liberror_headers",
+ ],
+ export_header_lib_headers: [
+ "libbase_headers",
+ "liberror_headers",
+ ],
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.btservices",
+ "com.android.media",
+ "com.android.media.swcodec",
+ ],
+ target: {
+ darwin: {
+ enabled: false,
+ },
+ },
+}
+
+// This is intended for clients needing to include AidlConversionUtil.h, without extra dependencies.
+cc_library_headers {
+ name: "libaudio_aidl_conversion_common_util_cpp",
+ defaults: [
+ "audio_aidl_conversion_common_util_default",
+ ],
+}
+
+cc_library_headers {
+ name: "libaudio_aidl_conversion_common_util_ndk",
+ defaults: [
+ "audio_aidl_conversion_common_util_default",
+ ],
+ cflags: [
+ "-DBACKEND_NDK",
+ ],
+}
+
+cc_defaults {
+ name: "audio_aidl_conversion_common_default",
+ export_include_dirs: ["include"],
+ host_supported: true,
+ vendor_available: true,
+ double_loadable: true,
+ min_sdk_version: "29",
+ header_libs: [
+ "libaudio_system_headers",
+ ],
+ shared_libs: [
+ "libbase",
+ "libbinder",
+ "liblog",
+ "libshmemcompat",
+ "libstagefright_foundation",
+ "libutils",
+ "shared-file-region-aidl-cpp",
+ "framework-permission-aidl-cpp",
+ ],
+ export_shared_lib_headers: [
+ "libbase",
+ "shared-file-region-aidl-cpp",
+ ],
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wno-error=deprecated-declarations",
+ ],
+ sanitize: {
+ misc_undefined: [
+ "unsigned-integer-overflow",
+ "signed-integer-overflow",
+ ],
+ },
+ target: {
+ darwin: {
+ enabled: false,
+ },
+ },
+}
+
+/**
+ * Only AIDL CPP backend conversion supported.
+ */
+cc_library {
+ name: "libaudio_aidl_conversion_common_cpp",
+ srcs: ["AidlConversionCppNdk.cpp"],
+ header_libs: [
+ "libaudio_aidl_conversion_common_util_cpp",
+ ],
+ export_header_lib_headers: [
+ "libaudio_aidl_conversion_common_util_cpp",
+ ],
+ defaults: [
+ "audio_aidl_conversion_common_default",
+ "latest_android_media_audio_common_types_cpp_export_shared",
+ ],
+}
+
+/**
+ * Only AIDL NDK backend conversion supported.
+ */
+cc_library {
+ name: "libaudio_aidl_conversion_common_ndk",
+ srcs: ["AidlConversionCppNdk.cpp"],
+ header_libs: [
+ "libaudio_aidl_conversion_common_util_ndk",
+ ],
+ export_header_lib_headers: [
+ "libaudio_aidl_conversion_common_util_ndk",
+ ],
+ defaults: [
+ "audio_aidl_conversion_common_default",
+ "latest_android_media_audio_common_types_ndk_shared",
+ ],
+ shared_libs: [
+ "libbinder_ndk",
+ ],
+ cflags: [
+ "-DBACKEND_NDK",
+ ],
+}
diff --git a/media/audioaidlconversion/include/media/AidlConversionCppNdk.h b/media/audioaidlconversion/include/media/AidlConversionCppNdk.h
new file mode 100644
index 0000000..e1efff9
--- /dev/null
+++ b/media/audioaidlconversion/include/media/AidlConversionCppNdk.h
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <limits>
+#include <type_traits>
+#include <system/audio.h>
+
+/**
+ * Can handle conversion between AIDL (both CPP and NDK backend) and legacy type.
+ * Controlled by the cflags preprocessor in Android.bp.
+ */
+#if defined(BACKEND_NDK)
+#define PREFIX(f) <aidl/f>
+#else
+#define PREFIX(f) <f>
+#endif
+
+#include PREFIX(android/media/audio/common/AudioChannelLayout.h)
+#include PREFIX(android/media/audio/common/AudioConfig.h)
+#include PREFIX(android/media/audio/common/AudioConfigBase.h)
+#include PREFIX(android/media/audio/common/AudioContentType.h)
+#include PREFIX(android/media/audio/common/AudioDeviceDescription.h)
+#include PREFIX(android/media/audio/common/AudioEncapsulationMetadataType.h)
+#include PREFIX(android/media/audio/common/AudioEncapsulationMode.h)
+#include PREFIX(android/media/audio/common/AudioEncapsulationType.h)
+#include PREFIX(android/media/audio/common/AudioFormatDescription.h)
+#include PREFIX(android/media/audio/common/AudioGain.h)
+#include PREFIX(android/media/audio/common/AudioGainConfig.h)
+#include PREFIX(android/media/audio/common/AudioGainMode.h)
+#include PREFIX(android/media/audio/common/AudioInputFlags.h)
+#include PREFIX(android/media/audio/common/AudioIoFlags.h)
+#include PREFIX(android/media/audio/common/AudioMode.h)
+#include PREFIX(android/media/audio/common/AudioOffloadInfo.h)
+#include PREFIX(android/media/audio/common/AudioOutputFlags.h)
+#include PREFIX(android/media/audio/common/AudioPortExt.h)
+#include PREFIX(android/media/audio/common/AudioPortMixExt.h)
+#include PREFIX(android/media/audio/common/AudioProfile.h)
+#include PREFIX(android/media/audio/common/AudioSource.h)
+#include PREFIX(android/media/audio/common/AudioStandard.h)
+#include PREFIX(android/media/audio/common/AudioUsage.h)
+#include PREFIX(android/media/audio/common/AudioUuid.h)
+#include PREFIX(android/media/audio/common/ExtraAudioDescriptor.h)
+#include PREFIX(android/media/audio/common/Int.h)
+#undef PREFIX
+
+#include <media/AidlConversionUtil.h>
+#include <system/audio.h>
+#include <system/audio_effect.h>
+
+using ::android::String16;
+using ::android::String8;
+
+#if defined(BACKEND_NDK)
+namespace aidl {
+#endif
+
+namespace android {
+
+// maxSize is the size of the C-string buffer (including the 0-terminator), NOT the max length of
+// the string.
+::android::status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize);
+ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize);
+
+ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy);
+
+ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy);
+
+ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy);
+
+ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy);
+
+ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy);
+
+ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy);
+
+ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy);
+
+ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy);
+
+ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy);
+
+ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl);
+ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy);
+
+ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl);
+ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy);
+
+ConversionResult<std::optional<String16>>
+aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl);
+ConversionResult<std::optional<std::string_view>>
+legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy);
+
+ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
+ const media::audio::common::AudioChannelLayout& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioChannelLayout>
+legacy2aidl_audio_channel_mask_t_AudioChannelLayout(audio_channel_mask_t legacy, bool isInput);
+
+ConversionResult<audio_config_t>
+aidl2legacy_AudioConfig_audio_config_t(const media::audio::common::AudioConfig& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioConfig>
+legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput);
+
+ConversionResult<audio_config_base_t>
+aidl2legacy_AudioConfigBase_audio_config_base_t(
+ const media::audio::common::AudioConfigBase& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioConfigBase>
+legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput);
+
+ConversionResult<audio_input_flags_t>
+aidl2legacy_AudioInputFlags_audio_input_flags_t(media::audio::common::AudioInputFlags aidl);
+ConversionResult<media::audio::common::AudioInputFlags>
+legacy2aidl_audio_input_flags_t_AudioInputFlags(audio_input_flags_t legacy);
+
+ConversionResult<audio_output_flags_t>
+aidl2legacy_AudioOutputFlags_audio_output_flags_t(media::audio::common::AudioOutputFlags aidl);
+ConversionResult<media::audio::common::AudioOutputFlags>
+legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_t legacy);
+
+ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
+ int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
+ audio_input_flags_t legacy);
+
+ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
+ int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
+ audio_output_flags_t legacy);
+
+ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
+ const media::audio::common::AudioIoFlags& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
+ const audio_io_flags& legacy, bool isInput);
+
+ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy);
+
+ConversionResult<audio_content_type_t>
+aidl2legacy_AudioContentType_audio_content_type_t(
+ media::audio::common::AudioContentType aidl);
+ConversionResult<media::audio::common::AudioContentType>
+legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy);
+
+ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
+ const media::audio::common::AudioDeviceDescription& aidl);
+ConversionResult<media::audio::common::AudioDeviceDescription>
+legacy2aidl_audio_devices_t_AudioDeviceDescription(audio_devices_t legacy);
+
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const media::audio::common::AudioDevice& aidl, audio_devices_t* legacyType,
+ char* legacyAddress);
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const media::audio::common::AudioDevice& aidl, audio_devices_t* legacyType,
+ String8* legacyAddress);
+::android::status_t aidl2legacy_AudioDevice_audio_device(
+ const media::audio::common::AudioDevice& aidl, audio_devices_t* legacyType,
+ std::string* legacyAddress);
+
+ConversionResult<media::audio::common::AudioDevice> legacy2aidl_audio_device_AudioDevice(
+ audio_devices_t legacyType, const char* legacyAddress);
+ConversionResult<media::audio::common::AudioDevice> legacy2aidl_audio_device_AudioDevice(
+ audio_devices_t legacyType, const String8& legacyAddress);
+
+ConversionResult<audio_extra_audio_descriptor>
+aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
+ const media::audio::common::ExtraAudioDescriptor& aidl);
+
+ConversionResult<media::audio::common::ExtraAudioDescriptor>
+legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
+ const audio_extra_audio_descriptor& legacy);
+
+ConversionResult<audio_encapsulation_metadata_type_t>
+aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
+ media::audio::common::AudioEncapsulationMetadataType aidl);
+ConversionResult<media::audio::common::AudioEncapsulationMetadataType>
+legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
+ audio_encapsulation_metadata_type_t legacy);
+
+ConversionResult<uint32_t> aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy);
+
+ConversionResult<audio_encapsulation_mode_t>
+aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(
+ media::audio::common::AudioEncapsulationMode aidl);
+ConversionResult<media::audio::common::AudioEncapsulationMode>
+legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy);
+
+ConversionResult<uint32_t> aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy);
+
+ConversionResult<audio_encapsulation_type_t>
+aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
+ const media::audio::common::AudioEncapsulationType& aidl);
+ConversionResult<media::audio::common::AudioEncapsulationType>
+legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
+ const audio_encapsulation_type_t& legacy);
+
+ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
+ const media::audio::common::AudioFormatDescription& aidl);
+ConversionResult<media::audio::common::AudioFormatDescription>
+legacy2aidl_audio_format_t_AudioFormatDescription(audio_format_t legacy);
+
+ConversionResult<audio_gain_mode_t>
+aidl2legacy_AudioGainMode_audio_gain_mode_t(media::audio::common::AudioGainMode aidl);
+ConversionResult<media::audio::common::AudioGainMode>
+legacy2aidl_audio_gain_mode_t_AudioGainMode(audio_gain_mode_t legacy);
+
+ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy);
+
+ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
+ const media::audio::common::AudioGainConfig& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioGainConfig>
+legacy2aidl_audio_gain_config_AudioGainConfig(const audio_gain_config& legacy, bool isInput);
+
+ConversionResult<audio_gain>
+aidl2legacy_AudioGain_audio_gain(const media::audio::common::AudioGain& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioGain>
+legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput);
+
+ConversionResult<audio_input_flags_t>
+aidl2legacy_AudioInputFlags_audio_input_flags_t(media::audio::common::AudioInputFlags aidl);
+ConversionResult<media::audio::common::AudioInputFlags>
+legacy2aidl_audio_input_flags_t_AudioInputFlags(audio_input_flags_t legacy);
+
+ConversionResult<audio_mode_t>
+aidl2legacy_AudioMode_audio_mode_t(media::audio::common::AudioMode aidl);
+ConversionResult<media::audio::common::AudioMode>
+legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy);
+
+ConversionResult<audio_offload_info_t>
+aidl2legacy_AudioOffloadInfo_audio_offload_info_t(
+ const media::audio::common::AudioOffloadInfo& aidl);
+ConversionResult<media::audio::common::AudioOffloadInfo>
+legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy);
+
+ConversionResult<audio_output_flags_t>
+aidl2legacy_AudioOutputFlags_audio_output_flags_t(media::audio::common::AudioOutputFlags aidl);
+ConversionResult<media::audio::common::AudioOutputFlags>
+legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_t legacy);
+
+ConversionResult<audio_profile> aidl2legacy_AudioProfile_audio_profile(
+ const media::audio::common::AudioProfile& aidl, bool isInput);
+ConversionResult<media::audio::common::AudioProfile> legacy2aidl_audio_profile_AudioProfile(
+ const audio_profile& legacy, bool isInput);
+
+ConversionResult<audio_standard_t> aidl2legacy_AudioStandard_audio_standard_t(
+ media::audio::common::AudioStandard aidl);
+ConversionResult<media::audio::common::AudioStandard> legacy2aidl_audio_standard_t_AudioStandard(
+ audio_standard_t legacy);
+
+ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
+ media::audio::common::AudioSource aidl);
+ConversionResult<media::audio::common::AudioSource> legacy2aidl_audio_source_t_AudioSource(
+ audio_source_t legacy);
+
+ConversionResult<audio_usage_t> aidl2legacy_AudioUsage_audio_usage_t(
+ media::audio::common::AudioUsage aidl);
+ConversionResult<media::audio::common::AudioUsage> legacy2aidl_audio_usage_t_AudioUsage(
+ audio_usage_t legacy);
+
+ConversionResult<audio_uuid_t> aidl2legacy_AudioUuid_audio_uuid_t(
+ const media::audio::common::AudioUuid &aidl);
+ConversionResult<media::audio::common::AudioUuid> legacy2aidl_audio_uuid_t_AudioUuid(
+ const audio_uuid_t& legacy);
+
+} // namespace android
+
+#if defined(BACKEND_NDK)
+} // aidl
+#endif
\ No newline at end of file
diff --git a/media/libaudioclient/include/media/AidlConversionUtil.h b/media/audioaidlconversion/include/media/AidlConversionUtil.h
similarity index 80%
rename from media/libaudioclient/include/media/AidlConversionUtil.h
rename to media/audioaidlconversion/include/media/AidlConversionUtil.h
index 8817c35..95daa4a 100644
--- a/media/libaudioclient/include/media/AidlConversionUtil.h
+++ b/media/audioaidlconversion/include/media/AidlConversionUtil.h
@@ -20,15 +20,21 @@
#include <type_traits>
#include <utility>
-#include <binder/Enums.h>
+#include <android-base/expected.h>
#include <binder/Status.h>
#include <error/Result.h>
-namespace android {
+#if defined(BACKEND_NDK)
+#include <android/binder_status.h>
+namespace aidl {
+#else
+#include <binder/Enums.h>
+#endif
template <typename T>
-using ConversionResult = error::Result<T>;
+using ConversionResult = ::android::error::Result<T>;
+namespace android {
/**
* A generic template to safely cast between integral types, respecting limits of the destination
* type.
@@ -39,15 +45,15 @@
// have the signed converted to unsigned and produce wrong results.
if (std::is_signed_v<From> && !std::is_signed_v<To>) {
if (from < 0 || from > std::numeric_limits<To>::max()) {
- return base::unexpected(BAD_VALUE);
+ return ::android::base::unexpected(::android::BAD_VALUE);
}
} else if (std::is_signed_v<To> && !std::is_signed_v<From>) {
if (from > std::numeric_limits<To>::max()) {
- return base::unexpected(BAD_VALUE);
+ return ::android::base::unexpected(::android::BAD_VALUE);
}
} else {
if (from < std::numeric_limits<To>::min() || from > std::numeric_limits<To>::max()) {
- return base::unexpected(BAD_VALUE);
+ return ::android::base::unexpected(::android::BAD_VALUE);
}
}
return static_cast<To>(from);
@@ -67,14 +73,14 @@
* A generic template that helps convert containers of convertible types, using iterators.
*/
template<typename InputIterator, typename OutputIterator, typename Func>
-status_t convertRange(InputIterator start,
+::android::status_t convertRange(InputIterator start,
InputIterator end,
OutputIterator out,
const Func& itemConversion) {
for (InputIterator iter = start; iter != end; ++iter, ++out) {
*out = VALUE_OR_RETURN_STATUS(itemConversion(*iter));
}
- return OK;
+ return ::android::OK;
}
/**
@@ -82,7 +88,7 @@
* Uses a limit as maximum conversion items.
*/
template<typename InputIterator, typename OutputIterator, typename Func>
-status_t convertRangeWithLimit(InputIterator start,
+::android::status_t convertRangeWithLimit(InputIterator start,
InputIterator end,
OutputIterator out,
const Func& itemConversion,
@@ -94,7 +100,7 @@
for (InputIterator iter = start; (iter != last); ++iter, ++out) {
*out = VALUE_OR_RETURN_STATUS(itemConversion(*iter));
}
- return OK;
+ return ::android::OK;
}
/**
@@ -140,7 +146,7 @@
OutputContainer output;
auto ins = std::inserter(output, output.begin());
for (const auto& item1 : input1) {
- RETURN_IF_ERROR(iter2 != input2.end() ? OK : BAD_VALUE);
+ RETURN_IF_ERROR(iter2 != input2.end() ? ::android::OK : ::android::BAD_VALUE);
*ins = VALUE_OR_RETURN(itemConversion(item1, *iter2++));
}
return output;
@@ -248,7 +254,8 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
// Utilities for working with AIDL unions.
// UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
-// value of the respective field, or BAD_VALUE if the union is not set to the requested field.
+// value of the respective field, or ::android::BAD_VALUE if the union is not set to the requested
+// field.
// UNION_SET(obj, fieldname, value) sets the requested field to the given value.
template<typename T, typename T::Tag tag>
@@ -257,7 +264,7 @@
template<typename T, typename T::Tag tag>
ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) {
if (u.getTag() != tag) {
- return base::unexpected(BAD_VALUE);
+ return ::android::base::unexpected(::android::BAD_VALUE);
}
return u.template get<tag>();
}
@@ -275,7 +282,11 @@
*/
template <typename T>
bool isValidEnum(T value) {
- constexpr android::enum_range<T> er{};
+#if defined(BACKEND_NDK)
+ constexpr ndk::enum_range<T> er{};
+#else
+ constexpr ::android::enum_range<T> er{};
+#endif
return std::find(er.begin(), er.end(), value) != er.end();
}
@@ -294,7 +305,7 @@
}
/**
- * Return the equivalent Android status_t from a binder exception code.
+ * Return the equivalent Android ::android::status_t from a binder exception code.
*
* Generally one should use statusTFromBinderStatus() instead.
*
@@ -304,33 +315,33 @@
* Note: for EX_TRANSACTION_FAILED and EX_SERVICE_SPECIFIC a more detailed error code
* can be found from transactionError() or serviceSpecificErrorCode().
*/
-static inline status_t statusTFromExceptionCode(int32_t exceptionCode) {
+static inline ::android::status_t statusTFromExceptionCode(int32_t exceptionCode) {
using namespace ::android::binder;
switch (exceptionCode) {
case Status::EX_NONE:
- return OK;
- case Status::EX_SECURITY: // Java SecurityException, rethrows locally in Java
- return PERMISSION_DENIED;
- case Status::EX_BAD_PARCELABLE: // Java BadParcelableException, rethrows in Java
- case Status::EX_ILLEGAL_ARGUMENT: // Java IllegalArgumentException, rethrows in Java
- case Status::EX_NULL_POINTER: // Java NullPointerException, rethrows in Java
- return BAD_VALUE;
- case Status::EX_ILLEGAL_STATE: // Java IllegalStateException, rethrows in Java
- case Status::EX_UNSUPPORTED_OPERATION: // Java UnsupportedOperationException, rethrows
- return INVALID_OPERATION;
+ return ::android::OK;
+ case Status::EX_SECURITY: // Java SecurityException, rethrows locally in Java
+ return ::android::PERMISSION_DENIED;
+ case Status::EX_BAD_PARCELABLE: // Java BadParcelableException, rethrows in Java
+ case Status::EX_ILLEGAL_ARGUMENT: // Java IllegalArgumentException, rethrows in Java
+ case Status::EX_NULL_POINTER: // Java NullPointerException, rethrows in Java
+ return ::android::BAD_VALUE;
+ case Status::EX_ILLEGAL_STATE: // Java IllegalStateException, rethrows in Java
+ case Status::EX_UNSUPPORTED_OPERATION: // Java UnsupportedOperationException, rethrows
+ return ::android::INVALID_OPERATION;
case Status::EX_HAS_REPLY_HEADER: // Native strictmode violation
- case Status::EX_PARCELABLE: // Java bootclass loader (not standard exception), rethrows
- case Status::EX_NETWORK_MAIN_THREAD: // Java NetworkOnMainThreadException, rethrows
+ case Status::EX_PARCELABLE: // Java bootclass loader (not standard exception), rethrows
+ case Status::EX_NETWORK_MAIN_THREAD: // Java NetworkOnMainThreadException, rethrows
case Status::EX_TRANSACTION_FAILED: // Native - see error code
- case Status::EX_SERVICE_SPECIFIC: // Java ServiceSpecificException,
- // rethrows in Java with integer error code
- return UNKNOWN_ERROR;
+ case Status::EX_SERVICE_SPECIFIC: // Java ServiceSpecificException,
+ // rethrows in Java with integer error code
+ return ::android::UNKNOWN_ERROR;
}
- return UNKNOWN_ERROR;
+ return ::android::UNKNOWN_ERROR;
}
/**
- * Return the equivalent Android status_t from a binder status.
+ * Return the equivalent Android ::android::status_t from a binder status.
*
* Used to handle errors from a AIDL method declaration
*
@@ -340,8 +351,8 @@
*
* return_type method(type0 param0, ...)
*/
-static inline status_t statusTFromBinderStatus(const ::android::binder::Status &status) {
- return status.isOk() ? OK // check OK,
+static inline ::android::status_t statusTFromBinderStatus(const ::android::binder::Status &status) {
+ return status.isOk() ? ::android::OK // check ::android::OK,
: status.serviceSpecificErrorCode() // service-side error, not standard Java exception
// (fromServiceSpecificError)
?: status.transactionError() // a native binder transaction error (fromStatusT)
@@ -356,23 +367,23 @@
* where Java callers expect an exception, not an integer return value.
*/
static inline ::android::binder::Status binderStatusFromStatusT(
- status_t status, const char *optionalMessage = nullptr) {
+ ::android::status_t status, const char *optionalMessage = nullptr) {
const char * const emptyIfNull = optionalMessage == nullptr ? "" : optionalMessage;
// From binder::Status instructions:
// Prefer a generic exception code when possible, then a service specific
- // code, and finally a status_t for low level failures or legacy support.
+ // code, and finally a ::android::status_t for low level failures or legacy support.
// Exception codes and service specific errors map to nicer exceptions for
// Java clients.
using namespace ::android::binder;
switch (status) {
- case OK:
+ case ::android::OK:
return Status::ok();
- case PERMISSION_DENIED: // throw SecurityException on Java side
+ case ::android::PERMISSION_DENIED: // throw SecurityException on Java side
return Status::fromExceptionCode(Status::EX_SECURITY, emptyIfNull);
- case BAD_VALUE: // throw IllegalArgumentException on Java side
+ case ::android::BAD_VALUE: // throw IllegalArgumentException on Java side
return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, emptyIfNull);
- case INVALID_OPERATION: // throw IllegalStateException on Java side
+ case ::android::INVALID_OPERATION: // throw IllegalStateException on Java side
return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE, emptyIfNull);
}
@@ -387,3 +398,7 @@
} // namespace aidl_utils
} // namespace android
+
+#if defined(BACKEND_NDK)
+} // namespace aidl
+#endif
\ No newline at end of file
diff --git a/media/libaudioclient/AidlConversion.cpp b/media/libaudioclient/AidlConversion.cpp
index 1a08eae..9fb0290 100644
--- a/media/libaudioclient/AidlConversion.cpp
+++ b/media/libaudioclient/AidlConversion.cpp
@@ -42,9 +42,6 @@
using media::audio::common::AudioDeviceAddress;
using media::audio::common::AudioDeviceDescription;
using media::audio::common::AudioDeviceType;
-using media::audio::common::AudioEncapsulationMetadataType;
-using media::audio::common::AudioEncapsulationMode;
-using media::audio::common::AudioEncapsulationType;
using media::audio::common::AudioFormatDescription;
using media::audio::common::AudioFormatType;
using media::audio::common::AudioGain;
@@ -138,127 +135,6 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
// Converters
-status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize) {
- if (aidl.size() > maxSize - 1) {
- return BAD_VALUE;
- }
- aidl.copy(dest, aidl.size());
- dest[aidl.size()] = '\0';
- return OK;
-}
-
-ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize) {
- if (legacy == nullptr) {
- return unexpected(BAD_VALUE);
- }
- if (strnlen(legacy, maxSize) == maxSize) {
- // No null-terminator.
- return unexpected(BAD_VALUE);
- }
- return std::string(legacy);
-}
-
-ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl) {
- return convertReinterpret<audio_module_handle_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl) {
- return convertReinterpret<audio_io_handle_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl) {
- return convertReinterpret<audio_port_handle_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl) {
- return convertReinterpret<audio_patch_handle_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl) {
- return convertReinterpret<audio_unique_id_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl) {
- return convertReinterpret<audio_hw_sync_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl) {
- return convertReinterpret<pid_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl) {
- return convertReinterpret<uid_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
-ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl) {
- return String16(aidl.data(), aidl.size());
-}
-
-ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy) {
- return std::string(String8(legacy).c_str());
-}
-
-// TODO b/182392769: create an optional -> optional util
-ConversionResult<std::optional<String16>>
-aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl) {
- if (!aidl.has_value()) {
- return std::nullopt;
- }
- ConversionResult<String16> conversion =
- VALUE_OR_RETURN(aidl2legacy_string_view_String16(aidl.value()));
- return conversion.value();
-}
-
-ConversionResult<std::optional<std::string_view>>
-legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy) {
- if (!legacy.has_value()) {
- return std::nullopt;
- }
- ConversionResult<std::string> conversion =
- VALUE_OR_RETURN(legacy2aidl_String16_string(legacy.value()));
- return conversion.value();
-}
-
-ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {
- return String8(aidl.data(), aidl.size());
-}
-
-ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {
- return std::string(legacy.c_str());
-}
-
ConversionResult<audio_io_config_event_t> aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(
media::AudioIoConfigEvent aidl) {
switch (aidl) {
@@ -365,1481 +241,6 @@
return unexpected(BAD_VALUE);
}
-namespace {
-
-namespace detail {
-using AudioChannelBitPair = std::pair<audio_channel_mask_t, int>;
-using AudioChannelBitPairs = std::vector<AudioChannelBitPair>;
-using AudioChannelPair = std::pair<audio_channel_mask_t, AudioChannelLayout>;
-using AudioChannelPairs = std::vector<AudioChannelPair>;
-using AudioDevicePair = std::pair<audio_devices_t, AudioDeviceDescription>;
-using AudioDevicePairs = std::vector<AudioDevicePair>;
-using AudioFormatPair = std::pair<audio_format_t, AudioFormatDescription>;
-using AudioFormatPairs = std::vector<AudioFormatPair>;
-}
-
-const detail::AudioChannelBitPairs& getInAudioChannelBits() {
- static const detail::AudioChannelBitPairs pairs = {
- { AUDIO_CHANNEL_IN_LEFT, AudioChannelLayout::CHANNEL_FRONT_LEFT },
- { AUDIO_CHANNEL_IN_RIGHT, AudioChannelLayout::CHANNEL_FRONT_RIGHT },
- // AUDIO_CHANNEL_IN_FRONT is at the end
- { AUDIO_CHANNEL_IN_BACK, AudioChannelLayout::CHANNEL_BACK_CENTER },
- // AUDIO_CHANNEL_IN_*_PROCESSED not supported
- // AUDIO_CHANNEL_IN_PRESSURE not supported
- // AUDIO_CHANNEL_IN_*_AXIS not supported
- // AUDIO_CHANNEL_IN_VOICE_* not supported
- { AUDIO_CHANNEL_IN_BACK_LEFT, AudioChannelLayout::CHANNEL_BACK_LEFT },
- { AUDIO_CHANNEL_IN_BACK_RIGHT, AudioChannelLayout::CHANNEL_BACK_RIGHT },
- { AUDIO_CHANNEL_IN_CENTER, AudioChannelLayout::CHANNEL_FRONT_CENTER },
- { AUDIO_CHANNEL_IN_LOW_FREQUENCY, AudioChannelLayout::CHANNEL_LOW_FREQUENCY },
- { AUDIO_CHANNEL_IN_TOP_LEFT, AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT },
- { AUDIO_CHANNEL_IN_TOP_RIGHT, AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT },
- // When going from aidl to legacy, IN_CENTER is used
- { AUDIO_CHANNEL_IN_FRONT, AudioChannelLayout::CHANNEL_FRONT_CENTER }
- };
- return pairs;
-}
-
-const detail::AudioChannelPairs& getInAudioChannelPairs() {
- static const detail::AudioChannelPairs pairs = {
-#define DEFINE_INPUT_LAYOUT(n) \
- { \
- AUDIO_CHANNEL_IN_##n, \
- AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
- AudioChannelLayout::LAYOUT_##n) \
- }
-
- DEFINE_INPUT_LAYOUT(MONO),
- DEFINE_INPUT_LAYOUT(STEREO),
- DEFINE_INPUT_LAYOUT(FRONT_BACK),
- // AUDIO_CHANNEL_IN_6 not supported
- DEFINE_INPUT_LAYOUT(2POINT0POINT2),
- DEFINE_INPUT_LAYOUT(2POINT1POINT2),
- DEFINE_INPUT_LAYOUT(3POINT0POINT2),
- DEFINE_INPUT_LAYOUT(3POINT1POINT2),
- DEFINE_INPUT_LAYOUT(5POINT1)
-#undef DEFINE_INPUT_LAYOUT
- };
- return pairs;
-}
-
-const detail::AudioChannelBitPairs& getOutAudioChannelBits() {
- static const detail::AudioChannelBitPairs pairs = {
-#define DEFINE_OUTPUT_BITS(n) \
- { AUDIO_CHANNEL_OUT_##n, AudioChannelLayout::CHANNEL_##n }
-
- DEFINE_OUTPUT_BITS(FRONT_LEFT),
- DEFINE_OUTPUT_BITS(FRONT_RIGHT),
- DEFINE_OUTPUT_BITS(FRONT_CENTER),
- DEFINE_OUTPUT_BITS(LOW_FREQUENCY),
- DEFINE_OUTPUT_BITS(BACK_LEFT),
- DEFINE_OUTPUT_BITS(BACK_RIGHT),
- DEFINE_OUTPUT_BITS(FRONT_LEFT_OF_CENTER),
- DEFINE_OUTPUT_BITS(FRONT_RIGHT_OF_CENTER),
- DEFINE_OUTPUT_BITS(BACK_CENTER),
- DEFINE_OUTPUT_BITS(SIDE_LEFT),
- DEFINE_OUTPUT_BITS(SIDE_RIGHT),
- DEFINE_OUTPUT_BITS(TOP_CENTER),
- DEFINE_OUTPUT_BITS(TOP_FRONT_LEFT),
- DEFINE_OUTPUT_BITS(TOP_FRONT_CENTER),
- DEFINE_OUTPUT_BITS(TOP_FRONT_RIGHT),
- DEFINE_OUTPUT_BITS(TOP_BACK_LEFT),
- DEFINE_OUTPUT_BITS(TOP_BACK_CENTER),
- DEFINE_OUTPUT_BITS(TOP_BACK_RIGHT),
- DEFINE_OUTPUT_BITS(TOP_SIDE_LEFT),
- DEFINE_OUTPUT_BITS(TOP_SIDE_RIGHT),
- DEFINE_OUTPUT_BITS(BOTTOM_FRONT_LEFT),
- DEFINE_OUTPUT_BITS(BOTTOM_FRONT_CENTER),
- DEFINE_OUTPUT_BITS(BOTTOM_FRONT_RIGHT),
- DEFINE_OUTPUT_BITS(LOW_FREQUENCY_2),
- DEFINE_OUTPUT_BITS(FRONT_WIDE_LEFT),
- DEFINE_OUTPUT_BITS(FRONT_WIDE_RIGHT),
-#undef DEFINE_OUTPUT_BITS
- { AUDIO_CHANNEL_OUT_HAPTIC_A, AudioChannelLayout::CHANNEL_HAPTIC_A },
- { AUDIO_CHANNEL_OUT_HAPTIC_B, AudioChannelLayout::CHANNEL_HAPTIC_B }
- };
- return pairs;
-}
-
-const detail::AudioChannelPairs& getOutAudioChannelPairs() {
- static const detail::AudioChannelPairs pairs = {
-#define DEFINE_OUTPUT_LAYOUT(n) \
- { \
- AUDIO_CHANNEL_OUT_##n, \
- AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>( \
- AudioChannelLayout::LAYOUT_##n) \
- }
-
- DEFINE_OUTPUT_LAYOUT(MONO),
- DEFINE_OUTPUT_LAYOUT(STEREO),
- DEFINE_OUTPUT_LAYOUT(2POINT1),
- DEFINE_OUTPUT_LAYOUT(TRI),
- DEFINE_OUTPUT_LAYOUT(TRI_BACK),
- DEFINE_OUTPUT_LAYOUT(3POINT1),
- DEFINE_OUTPUT_LAYOUT(2POINT0POINT2),
- DEFINE_OUTPUT_LAYOUT(2POINT1POINT2),
- DEFINE_OUTPUT_LAYOUT(3POINT0POINT2),
- DEFINE_OUTPUT_LAYOUT(3POINT1POINT2),
- DEFINE_OUTPUT_LAYOUT(QUAD),
- DEFINE_OUTPUT_LAYOUT(QUAD_SIDE),
- DEFINE_OUTPUT_LAYOUT(SURROUND),
- DEFINE_OUTPUT_LAYOUT(PENTA),
- DEFINE_OUTPUT_LAYOUT(5POINT1),
- DEFINE_OUTPUT_LAYOUT(5POINT1_SIDE),
- DEFINE_OUTPUT_LAYOUT(5POINT1POINT2),
- DEFINE_OUTPUT_LAYOUT(5POINT1POINT4),
- DEFINE_OUTPUT_LAYOUT(6POINT1),
- DEFINE_OUTPUT_LAYOUT(7POINT1),
- DEFINE_OUTPUT_LAYOUT(7POINT1POINT2),
- DEFINE_OUTPUT_LAYOUT(7POINT1POINT4),
- DEFINE_OUTPUT_LAYOUT(13POINT_360RA),
- DEFINE_OUTPUT_LAYOUT(22POINT2),
- DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_A),
- DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_A),
- DEFINE_OUTPUT_LAYOUT(HAPTIC_AB),
- DEFINE_OUTPUT_LAYOUT(MONO_HAPTIC_AB),
- DEFINE_OUTPUT_LAYOUT(STEREO_HAPTIC_AB)
-#undef DEFINE_OUTPUT_LAYOUT
- };
- return pairs;
-}
-
-const detail::AudioChannelPairs& getVoiceAudioChannelPairs() {
- static const detail::AudioChannelPairs pairs = {
-#define DEFINE_VOICE_LAYOUT(n) \
- { \
- AUDIO_CHANNEL_IN_VOICE_##n, \
- AudioChannelLayout::make<AudioChannelLayout::Tag::voiceMask>( \
- AudioChannelLayout::VOICE_##n) \
- }
- DEFINE_VOICE_LAYOUT(UPLINK_MONO),
- DEFINE_VOICE_LAYOUT(DNLINK_MONO),
- DEFINE_VOICE_LAYOUT(CALL_MONO)
-#undef DEFINE_VOICE_LAYOUT
- };
- return pairs;
-}
-
-AudioDeviceDescription make_AudioDeviceDescription(AudioDeviceType type,
- const std::string& connection = "") {
- AudioDeviceDescription result;
- result.type = type;
- result.connection = connection;
- return result;
-}
-
-void append_AudioDeviceDescription(detail::AudioDevicePairs& pairs,
- audio_devices_t inputType, audio_devices_t outputType,
- AudioDeviceType inType, AudioDeviceType outType,
- const std::string& connection = "") {
- pairs.push_back(std::make_pair(inputType, make_AudioDeviceDescription(inType, connection)));
- pairs.push_back(std::make_pair(outputType, make_AudioDeviceDescription(outType, connection)));
-}
-
-const detail::AudioDevicePairs& getAudioDevicePairs() {
- static const detail::AudioDevicePairs pairs = []() {
- detail::AudioDevicePairs pairs = {{
- {
- AUDIO_DEVICE_NONE, AudioDeviceDescription{}
- },
- {
- AUDIO_DEVICE_OUT_EARPIECE, make_AudioDeviceDescription(
- AudioDeviceType::OUT_SPEAKER_EARPIECE)
- },
- {
- AUDIO_DEVICE_OUT_SPEAKER, make_AudioDeviceDescription(
- AudioDeviceType::OUT_SPEAKER)
- },
- {
- AUDIO_DEVICE_OUT_WIRED_HEADPHONE, make_AudioDeviceDescription(
- AudioDeviceType::OUT_HEADPHONE,
- AudioDeviceDescription::CONNECTION_ANALOG())
- },
- {
- AUDIO_DEVICE_OUT_BLUETOOTH_SCO, make_AudioDeviceDescription(
- AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_BT_SCO())
- },
- {
- AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, make_AudioDeviceDescription(
- AudioDeviceType::OUT_CARKIT,
- AudioDeviceDescription::CONNECTION_BT_SCO())
- },
- {
- AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, make_AudioDeviceDescription(
- AudioDeviceType::OUT_HEADPHONE,
- AudioDeviceDescription::CONNECTION_BT_A2DP())
- },
- {
- AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, make_AudioDeviceDescription(
- AudioDeviceType::OUT_SPEAKER,
- AudioDeviceDescription::CONNECTION_BT_A2DP())
- },
- {
- AUDIO_DEVICE_OUT_TELEPHONY_TX, make_AudioDeviceDescription(
- AudioDeviceType::OUT_TELEPHONY_TX)
- },
- {
- AUDIO_DEVICE_OUT_AUX_LINE, make_AudioDeviceDescription(
- AudioDeviceType::OUT_LINE_AUX)
- },
- {
- AUDIO_DEVICE_OUT_SPEAKER_SAFE, make_AudioDeviceDescription(
- AudioDeviceType::OUT_SPEAKER_SAFE)
- },
- {
- AUDIO_DEVICE_OUT_HEARING_AID, make_AudioDeviceDescription(
- AudioDeviceType::OUT_HEARING_AID,
- AudioDeviceDescription::CONNECTION_WIRELESS())
- },
- {
- AUDIO_DEVICE_OUT_ECHO_CANCELLER, make_AudioDeviceDescription(
- AudioDeviceType::OUT_ECHO_CANCELLER)
- },
- {
- AUDIO_DEVICE_OUT_BLE_SPEAKER, make_AudioDeviceDescription(
- AudioDeviceType::OUT_SPEAKER,
- AudioDeviceDescription::CONNECTION_BT_LE())
- },
- {
- AUDIO_DEVICE_OUT_BLE_BROADCAST, make_AudioDeviceDescription(
- AudioDeviceType::OUT_BROADCAST,
- AudioDeviceDescription::CONNECTION_BT_LE())
- },
- // AUDIO_DEVICE_IN_AMBIENT and IN_COMMUNICATION are removed since they were deprecated.
- {
- AUDIO_DEVICE_IN_BUILTIN_MIC, make_AudioDeviceDescription(
- AudioDeviceType::IN_MICROPHONE)
- },
- {
- AUDIO_DEVICE_IN_BACK_MIC, make_AudioDeviceDescription(
- AudioDeviceType::IN_MICROPHONE_BACK)
- },
- {
- AUDIO_DEVICE_IN_TELEPHONY_RX, make_AudioDeviceDescription(
- AudioDeviceType::IN_TELEPHONY_RX)
- },
- {
- AUDIO_DEVICE_IN_TV_TUNER, make_AudioDeviceDescription(
- AudioDeviceType::IN_TV_TUNER)
- },
- {
- AUDIO_DEVICE_IN_LOOPBACK, make_AudioDeviceDescription(
- AudioDeviceType::IN_LOOPBACK)
- },
- {
- AUDIO_DEVICE_IN_BLUETOOTH_BLE, make_AudioDeviceDescription(
- AudioDeviceType::IN_DEVICE,
- AudioDeviceDescription::CONNECTION_BT_LE())
- },
- {
- AUDIO_DEVICE_IN_ECHO_REFERENCE, make_AudioDeviceDescription(
- AudioDeviceType::IN_ECHO_REFERENCE)
- }
- }};
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT,
- AudioDeviceType::IN_DEFAULT, AudioDeviceType::OUT_DEFAULT);
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET,
- AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
- AudioDeviceDescription::CONNECTION_ANALOG());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
- AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
- AudioDeviceDescription::CONNECTION_BT_SCO());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_HDMI, AUDIO_DEVICE_OUT_HDMI,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_HDMI());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
- AudioDeviceType::IN_SUBMIX, AudioDeviceType::OUT_SUBMIX);
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,
- AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
- AudioDeviceDescription::CONNECTION_ANALOG());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,
- AudioDeviceType::IN_DOCK, AudioDeviceType::OUT_DOCK,
- AudioDeviceDescription::CONNECTION_USB());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_USB_ACCESSORY, AUDIO_DEVICE_OUT_USB_ACCESSORY,
- AudioDeviceType::IN_ACCESSORY, AudioDeviceType::OUT_ACCESSORY,
- AudioDeviceDescription::CONNECTION_USB());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_OUT_USB_DEVICE,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_USB());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_FM_TUNER, AUDIO_DEVICE_OUT_FM,
- AudioDeviceType::IN_FM_TUNER, AudioDeviceType::OUT_FM);
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_LINE, AUDIO_DEVICE_OUT_LINE,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_ANALOG());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_SPDIF, AUDIO_DEVICE_OUT_SPDIF,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_SPDIF());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_BT_A2DP());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_IP, AUDIO_DEVICE_OUT_IP,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_IP_V4());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_OUT_BUS,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_BUS());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_PROXY, AUDIO_DEVICE_OUT_PROXY,
- AudioDeviceType::IN_AFE_PROXY, AudioDeviceType::OUT_AFE_PROXY);
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_OUT_USB_HEADSET,
- AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
- AudioDeviceDescription::CONNECTION_USB());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_ARC,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_HDMI_ARC());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_HDMI_EARC, AUDIO_DEVICE_OUT_HDMI_EARC,
- AudioDeviceType::IN_DEVICE, AudioDeviceType::OUT_DEVICE,
- AudioDeviceDescription::CONNECTION_HDMI_EARC());
- append_AudioDeviceDescription(pairs,
- AUDIO_DEVICE_IN_BLE_HEADSET, AUDIO_DEVICE_OUT_BLE_HEADSET,
- AudioDeviceType::IN_HEADSET, AudioDeviceType::OUT_HEADSET,
- AudioDeviceDescription::CONNECTION_BT_LE());
- return pairs;
- }();
- return pairs;
-}
-
-AudioFormatDescription make_AudioFormatDescription(AudioFormatType type) {
- AudioFormatDescription result;
- result.type = type;
- return result;
-}
-
-AudioFormatDescription make_AudioFormatDescription(PcmType pcm) {
- auto result = make_AudioFormatDescription(AudioFormatType::PCM);
- result.pcm = pcm;
- return result;
-}
-
-AudioFormatDescription make_AudioFormatDescription(const std::string& encoding) {
- AudioFormatDescription result;
- result.encoding = encoding;
- return result;
-}
-
-AudioFormatDescription make_AudioFormatDescription(PcmType transport,
- const std::string& encoding) {
- auto result = make_AudioFormatDescription(encoding);
- result.pcm = transport;
- return result;
-}
-
-const detail::AudioFormatPairs& getAudioFormatPairs() {
- static const detail::AudioFormatPairs pairs = {{
- {
- AUDIO_FORMAT_INVALID,
- make_AudioFormatDescription(AudioFormatType::SYS_RESERVED_INVALID)
- },
- {
- AUDIO_FORMAT_DEFAULT, AudioFormatDescription{}
- },
- {
- AUDIO_FORMAT_PCM_16_BIT, make_AudioFormatDescription(PcmType::INT_16_BIT)
- },
- {
- AUDIO_FORMAT_PCM_8_BIT, make_AudioFormatDescription(PcmType::UINT_8_BIT)
- },
- {
- AUDIO_FORMAT_PCM_32_BIT, make_AudioFormatDescription(PcmType::INT_32_BIT)
- },
- {
- AUDIO_FORMAT_PCM_8_24_BIT, make_AudioFormatDescription(PcmType::FIXED_Q_8_24)
- },
- {
- AUDIO_FORMAT_PCM_FLOAT, make_AudioFormatDescription(PcmType::FLOAT_32_BIT)
- },
- {
- AUDIO_FORMAT_PCM_24_BIT_PACKED, make_AudioFormatDescription(PcmType::INT_24_BIT)
- },
- {
- AUDIO_FORMAT_MP3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEG)
- },
- {
- AUDIO_FORMAT_AMR_NB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_NB)
- },
- {
- AUDIO_FORMAT_AMR_WB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_WB)
- },
- {
- AUDIO_FORMAT_AAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_MP4)
- },
- {
- AUDIO_FORMAT_AAC_MAIN, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_MAIN)
- },
- {
- AUDIO_FORMAT_AAC_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LC)
- },
- {
- AUDIO_FORMAT_AAC_SSR, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_SSR)
- },
- {
- AUDIO_FORMAT_AAC_LTP, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LTP)
- },
- {
- AUDIO_FORMAT_AAC_HE_V1, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_HE_V1)
- },
- {
- AUDIO_FORMAT_AAC_SCALABLE,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_SCALABLE)
- },
- {
- AUDIO_FORMAT_AAC_ERLC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ERLC)
- },
- {
- AUDIO_FORMAT_AAC_LD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LD)
- },
- {
- AUDIO_FORMAT_AAC_HE_V2, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_HE_V2)
- },
- {
- AUDIO_FORMAT_AAC_ELD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ELD)
- },
- {
- AUDIO_FORMAT_AAC_XHE, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_XHE)
- },
- // AUDIO_FORMAT_HE_AAC_V1 and HE_AAC_V2 are removed since they were deprecated long time
- // ago.
- {
- AUDIO_FORMAT_VORBIS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_VORBIS)
- },
- {
- AUDIO_FORMAT_OPUS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_OPUS)
- },
- {
- AUDIO_FORMAT_AC3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AC3)
- },
- {
- AUDIO_FORMAT_E_AC3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EAC3)
- },
- {
- AUDIO_FORMAT_E_AC3_JOC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EAC3_JOC)
- },
- {
- AUDIO_FORMAT_DTS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS)
- },
- {
- AUDIO_FORMAT_DTS_HD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_HD)
- },
- {
- AUDIO_FORMAT_DTS_HD_MA, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_HD_MA)
- },
- {
- AUDIO_FORMAT_DTS_UHD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_UHD_P1)
- },
- {
- AUDIO_FORMAT_DTS_UHD_P2, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DTS_UHD_P2)
- },
- // In the future, we would like to represent encapsulated bitstreams as
- // nested AudioFormatDescriptions. The legacy 'AUDIO_FORMAT_IEC61937' type doesn't
- // specify the format of the encapsulated bitstream.
- {
- AUDIO_FORMAT_IEC61937,
- make_AudioFormatDescription(PcmType::INT_16_BIT, MEDIA_MIMETYPE_AUDIO_IEC61937)
- },
- {
- AUDIO_FORMAT_DOLBY_TRUEHD,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_TRUEHD)
- },
- {
- AUDIO_FORMAT_EVRC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRC)
- },
- {
- AUDIO_FORMAT_EVRCB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCB)
- },
- {
- AUDIO_FORMAT_EVRCWB, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCWB)
- },
- {
- AUDIO_FORMAT_EVRCNW, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_EVRCNW)
- },
- {
- AUDIO_FORMAT_AAC_ADIF, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADIF)
- },
- {
- AUDIO_FORMAT_WMA, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_WMA)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_WMA_PRO, make_AudioFormatDescription("audio/x-ms-wma.pro")
- },
- {
- AUDIO_FORMAT_AMR_WB_PLUS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AMR_WB_PLUS)
- },
- {
- AUDIO_FORMAT_MP2, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II)
- },
- {
- AUDIO_FORMAT_QCELP, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_QCELP)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_DSD, make_AudioFormatDescription("audio/vnd.sony.dsd")
- },
- {
- AUDIO_FORMAT_FLAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_FLAC)
- },
- {
- AUDIO_FORMAT_ALAC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_ALAC)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APE, make_AudioFormatDescription("audio/x-ape")
- },
- {
- AUDIO_FORMAT_AAC_ADTS, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_MAIN,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_MAIN)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LC)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_SSR,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SSR)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_LTP,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LTP)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_HE_V1,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V1)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_SCALABLE,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_SCALABLE)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_ERLC,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ERLC)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_LD, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_LD)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_HE_V2,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_HE_V2)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_ELD,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_ELD)
- },
- {
- AUDIO_FORMAT_AAC_ADTS_XHE,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_ADTS_XHE)
- },
- {
- // Note: not in the IANA registry. "vnd.octel.sbc" is not BT SBC.
- AUDIO_FORMAT_SBC, make_AudioFormatDescription("audio/x-sbc")
- },
- {
- AUDIO_FORMAT_APTX, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_APTX)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APTX_HD, make_AudioFormatDescription("audio/vnd.qcom.aptx.hd")
- },
- {
- AUDIO_FORMAT_AC4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AC4)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_LDAC, make_AudioFormatDescription("audio/vnd.sony.ldac")
- },
- {
- AUDIO_FORMAT_MAT, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_MAT_1_0,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".1.0"))
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_MAT_2_0,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".2.0"))
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_MAT_2_1,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DOLBY_MAT + std::string(".2.1"))
- },
- {
- AUDIO_FORMAT_AAC_LATM, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC)
- },
- {
- AUDIO_FORMAT_AAC_LATM_LC, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_LC)
- },
- {
- AUDIO_FORMAT_AAC_LATM_HE_V1,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V1)
- },
- {
- AUDIO_FORMAT_AAC_LATM_HE_V2,
- make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_AAC_LATM_HE_V2)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_CELT, make_AudioFormatDescription("audio/x-celt")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APTX_ADAPTIVE, make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_LHDC, make_AudioFormatDescription("audio/vnd.savitech.lhdc")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_LHDC_LL, make_AudioFormatDescription("audio/vnd.savitech.lhdc.ll")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APTX_TWSP, make_AudioFormatDescription("audio/vnd.qcom.aptx.twsp")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_LC3, make_AudioFormatDescription("audio/x-lc3")
- },
- {
- AUDIO_FORMAT_MPEGH, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1)
- },
- {
- AUDIO_FORMAT_MPEGH_BL_L3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L3)
- },
- {
- AUDIO_FORMAT_MPEGH_BL_L4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_BL_L4)
- },
- {
- AUDIO_FORMAT_MPEGH_LC_L3, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L3)
- },
- {
- AUDIO_FORMAT_MPEGH_LC_L4, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_MPEGH_LC_L4)
- },
- {
- AUDIO_FORMAT_IEC60958,
- make_AudioFormatDescription(PcmType::INT_24_BIT, MEDIA_MIMETYPE_AUDIO_IEC60958)
- },
- {
- AUDIO_FORMAT_DRA, make_AudioFormatDescription(MEDIA_MIMETYPE_AUDIO_DRA)
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APTX_ADAPTIVE_QLEA,
- make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r3")
- },
- {
- // Note: not in the IANA registry.
- AUDIO_FORMAT_APTX_ADAPTIVE_R4,
- make_AudioFormatDescription("audio/vnd.qcom.aptx.adaptive.r4")
- },
- }};
- return pairs;
-}
-
-template<typename S, typename T>
-std::unordered_map<S, T> make_DirectMap(const std::vector<std::pair<S, T>>& v) {
- std::unordered_map<S, T> result(v.begin(), v.end());
- LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
- return result;
-}
-
-template<typename S, typename T>
-std::unordered_map<S, T> make_DirectMap(
- const std::vector<std::pair<S, T>>& v1, const std::vector<std::pair<S, T>>& v2) {
- std::unordered_map<S, T> result(v1.begin(), v1.end());
- LOG_ALWAYS_FATAL_IF(result.size() != v1.size(), "Duplicate key elements detected in v1");
- result.insert(v2.begin(), v2.end());
- LOG_ALWAYS_FATAL_IF(result.size() != v1.size() + v2.size(),
- "Duplicate key elements detected in v1+v2");
- return result;
-}
-
-template<typename S, typename T>
-std::unordered_map<T, S> make_ReverseMap(const std::vector<std::pair<S, T>>& v) {
- std::unordered_map<T, S> result;
- std::transform(v.begin(), v.end(), std::inserter(result, result.begin()),
- [](const std::pair<S, T>& p) {
- return std::make_pair(p.second, p.first);
- });
- LOG_ALWAYS_FATAL_IF(result.size() != v.size(), "Duplicate key elements detected");
- return result;
-}
-
-} // namespace
-
-audio_channel_mask_t aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
- int aidlLayout, bool isInput) {
- auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
- const int aidlLayoutInitial = aidlLayout; // for error message
- audio_channel_mask_t legacy = AUDIO_CHANNEL_NONE;
- for (const auto& bitPair : bitMapping) {
- if ((aidlLayout & bitPair.second) == bitPair.second) {
- legacy = static_cast<audio_channel_mask_t>(legacy | bitPair.first);
- aidlLayout &= ~bitPair.second;
- if (aidlLayout == 0) {
- return legacy;
- }
- }
- }
- ALOGE("%s: aidl layout 0x%x contains bits 0x%x that have no match to legacy %s bits",
- __func__, aidlLayoutInitial, aidlLayout, isInput ? "input" : "output");
- return AUDIO_CHANNEL_NONE;
-}
-
-ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
- const AudioChannelLayout& aidl, bool isInput) {
- using ReverseMap = std::unordered_map<AudioChannelLayout, audio_channel_mask_t>;
- using Tag = AudioChannelLayout::Tag;
- static const ReverseMap mIn = make_ReverseMap(getInAudioChannelPairs());
- static const ReverseMap mOut = make_ReverseMap(getOutAudioChannelPairs());
- static const ReverseMap mVoice = make_ReverseMap(getVoiceAudioChannelPairs());
-
- auto convert = [](const AudioChannelLayout& aidl, const ReverseMap& m,
- const char* func, const char* type) -> ConversionResult<audio_channel_mask_t> {
- if (auto it = m.find(aidl); it != m.end()) {
- return it->second;
- } else {
- ALOGW("%s: no legacy %s audio_channel_mask_t found for %s", func, type,
- aidl.toString().c_str());
- return unexpected(BAD_VALUE);
- }
- };
-
- switch (aidl.getTag()) {
- case Tag::none:
- return AUDIO_CHANNEL_NONE;
- case Tag::invalid:
- return AUDIO_CHANNEL_INVALID;
- case Tag::indexMask:
- // Index masks do not have pre-defined values.
- if (const int bits = aidl.get<Tag::indexMask>();
- __builtin_popcount(bits) != 0 &&
- __builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {
- return audio_channel_mask_from_representation_and_bits(
- AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
- } else {
- ALOGE("%s: invalid indexMask value 0x%x in %s",
- __func__, bits, aidl.toString().c_str());
- return unexpected(BAD_VALUE);
- }
- case Tag::layoutMask:
- // The fast path is to find a direct match for some known layout mask.
- if (const auto layoutMatch = convert(aidl, isInput ? mIn : mOut, __func__,
- isInput ? "input" : "output");
- layoutMatch.ok()) {
- return layoutMatch;
- }
- // If a match for a predefined layout wasn't found, make a custom one from bits.
- if (audio_channel_mask_t bitMask =
- aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
- aidl.get<Tag::layoutMask>(), isInput);
- bitMask != AUDIO_CHANNEL_NONE) {
- return bitMask;
- }
- return unexpected(BAD_VALUE);
- case Tag::voiceMask:
- return convert(aidl, mVoice, __func__, "voice");
- }
- ALOGE("%s: unexpected tag value %d", __func__, aidl.getTag());
- return unexpected(BAD_VALUE);
-}
-
-int legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
- audio_channel_mask_t legacy, bool isInput) {
- auto& bitMapping = isInput ? getInAudioChannelBits() : getOutAudioChannelBits();
- const int legacyInitial = legacy; // for error message
- int aidlLayout = 0;
- for (const auto& bitPair : bitMapping) {
- if ((legacy & bitPair.first) == bitPair.first) {
- aidlLayout |= bitPair.second;
- legacy = static_cast<audio_channel_mask_t>(legacy & ~bitPair.first);
- if (legacy == 0) {
- return aidlLayout;
- }
- }
- }
- ALOGE("%s: legacy %s audio_channel_mask_t 0x%x contains unrecognized bits 0x%x",
- __func__, isInput ? "input" : "output", legacyInitial, legacy);
- return 0;
-}
-
-ConversionResult<AudioChannelLayout> legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
- audio_channel_mask_t legacy, bool isInput) {
- using DirectMap = std::unordered_map<audio_channel_mask_t, AudioChannelLayout>;
- using Tag = AudioChannelLayout::Tag;
- static const DirectMap mInAndVoice = make_DirectMap(
- getInAudioChannelPairs(), getVoiceAudioChannelPairs());
- static const DirectMap mOut = make_DirectMap(getOutAudioChannelPairs());
-
- auto convert = [](const audio_channel_mask_t legacy, const DirectMap& m,
- const char* func, const char* type) -> ConversionResult<AudioChannelLayout> {
- if (auto it = m.find(legacy); it != m.end()) {
- return it->second;
- } else {
- ALOGW("%s: no AudioChannelLayout found for legacy %s audio_channel_mask_t value 0x%x",
- func, type, legacy);
- return unexpected(BAD_VALUE);
- }
- };
-
- if (legacy == AUDIO_CHANNEL_NONE) {
- return AudioChannelLayout{};
- } else if (legacy == AUDIO_CHANNEL_INVALID) {
- return AudioChannelLayout::make<Tag::invalid>(0);
- }
-
- const audio_channel_representation_t repr = audio_channel_mask_get_representation(legacy);
- if (repr == AUDIO_CHANNEL_REPRESENTATION_INDEX) {
- if (audio_channel_mask_is_valid(legacy)) {
- const int indexMask = VALUE_OR_RETURN(
- convertIntegral<int>(audio_channel_mask_get_bits(legacy)));
- return AudioChannelLayout::make<Tag::indexMask>(indexMask);
- } else {
- ALOGE("%s: legacy audio_channel_mask_t value 0x%x is invalid", __func__, legacy);
- return unexpected(BAD_VALUE);
- }
- } else if (repr == AUDIO_CHANNEL_REPRESENTATION_POSITION) {
- // The fast path is to find a direct match for some known layout mask.
- if (const auto layoutMatch = convert(legacy, isInput ? mInAndVoice : mOut, __func__,
- isInput ? "input / voice" : "output");
- layoutMatch.ok()) {
- return layoutMatch;
- }
- // If a match for a predefined layout wasn't found, make a custom one from bits,
- // rejecting those with voice channel bits.
- if (!isInput ||
- (legacy & (AUDIO_CHANNEL_IN_VOICE_UPLINK | AUDIO_CHANNEL_IN_VOICE_DNLINK)) == 0) {
- if (int bitMaskLayout =
- legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
- legacy, isInput);
- bitMaskLayout != 0) {
- return AudioChannelLayout::make<Tag::layoutMask>(bitMaskLayout);
- }
- } else {
- ALOGE("%s: legacy audio_channel_mask_t value 0x%x contains voice bits",
- __func__, legacy);
- }
- return unexpected(BAD_VALUE);
- }
-
- ALOGE("%s: unknown representation %d in audio_channel_mask_t value 0x%x",
- __func__, repr, legacy);
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
- const AudioDeviceDescription& aidl) {
- static const std::unordered_map<AudioDeviceDescription, audio_devices_t> m =
- make_ReverseMap(getAudioDevicePairs());
- if (auto it = m.find(aidl); it != m.end()) {
- return it->second;
- } else {
- ALOGE("%s: no legacy audio_devices_t found for %s", __func__, aidl.toString().c_str());
- return unexpected(BAD_VALUE);
- }
-}
-
-ConversionResult<AudioDeviceDescription> legacy2aidl_audio_devices_t_AudioDeviceDescription(
- audio_devices_t legacy) {
- static const std::unordered_map<audio_devices_t, AudioDeviceDescription> m =
- make_DirectMap(getAudioDevicePairs());
- if (auto it = m.find(legacy); it != m.end()) {
- return it->second;
- } else {
- ALOGE("%s: no AudioDeviceDescription found for legacy audio_devices_t value 0x%x",
- __func__, legacy);
- return unexpected(BAD_VALUE);
- }
-}
-
-status_t aidl2legacy_AudioDevice_audio_device(
- const AudioDevice& aidl,
- audio_devices_t* legacyType, char* legacyAddress) {
- *legacyType = VALUE_OR_RETURN_STATUS(
- aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
- return aidl2legacy_string(
- aidl.address.get<AudioDeviceAddress::id>(),
- legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN);
-}
-
-status_t aidl2legacy_AudioDevice_audio_device(
- const AudioDevice& aidl,
- audio_devices_t* legacyType, String8* legacyAddress) {
- *legacyType = VALUE_OR_RETURN_STATUS(
- aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
- *legacyAddress = VALUE_OR_RETURN_STATUS(aidl2legacy_string_view_String8(
- aidl.address.get<AudioDeviceAddress::id>()));
- return OK;
-}
-
-status_t aidl2legacy_AudioDevice_audio_device(
- const AudioDevice& aidl,
- audio_devices_t* legacyType, std::string* legacyAddress) {
- *legacyType = VALUE_OR_RETURN_STATUS(
- aidl2legacy_AudioDeviceDescription_audio_devices_t(aidl.type));
- *legacyAddress = aidl.address.get<AudioDeviceAddress::id>();
- return OK;
-}
-
-ConversionResult<AudioDevice> legacy2aidl_audio_device_AudioDevice(
- audio_devices_t legacyType, const char* legacyAddress) {
- AudioDevice aidl;
- aidl.type = VALUE_OR_RETURN(
- legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
- const std::string aidl_id = VALUE_OR_RETURN(
- legacy2aidl_string(legacyAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN));
- aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
- return aidl;
-}
-
-ConversionResult<AudioDevice>
-legacy2aidl_audio_device_AudioDevice(
- audio_devices_t legacyType, const String8& legacyAddress) {
- AudioDevice aidl;
- aidl.type = VALUE_OR_RETURN(
- legacy2aidl_audio_devices_t_AudioDeviceDescription(legacyType));
- const std::string aidl_id = VALUE_OR_RETURN(
- legacy2aidl_String8_string(legacyAddress));
- aidl.address = AudioDeviceAddress::make<AudioDeviceAddress::id>(aidl_id);
- return aidl;
-}
-
-ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
- const AudioFormatDescription& aidl) {
- static const std::unordered_map<AudioFormatDescription, audio_format_t> m =
- make_ReverseMap(getAudioFormatPairs());
- if (auto it = m.find(aidl); it != m.end()) {
- return it->second;
- } else {
- ALOGE("%s: no legacy audio_format_t found for %s", __func__, aidl.toString().c_str());
- return unexpected(BAD_VALUE);
- }
-}
-
-ConversionResult<AudioFormatDescription> legacy2aidl_audio_format_t_AudioFormatDescription(
- audio_format_t legacy) {
- static const std::unordered_map<audio_format_t, AudioFormatDescription> m =
- make_DirectMap(getAudioFormatPairs());
- if (auto it = m.find(legacy); it != m.end()) {
- return it->second;
- } else {
- ALOGE("%s: no AudioFormatDescription found for legacy audio_format_t value 0x%x",
- __func__, legacy);
- return unexpected(BAD_VALUE);
- }
-}
-
-ConversionResult<audio_gain_mode_t> aidl2legacy_AudioGainMode_audio_gain_mode_t(
- AudioGainMode aidl) {
- switch (aidl) {
- case AudioGainMode::JOINT:
- return AUDIO_GAIN_MODE_JOINT;
- case AudioGainMode::CHANNELS:
- return AUDIO_GAIN_MODE_CHANNELS;
- case AudioGainMode::RAMP:
- return AUDIO_GAIN_MODE_RAMP;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioGainMode> legacy2aidl_audio_gain_mode_t_AudioGainMode(
- audio_gain_mode_t legacy) {
- switch (legacy) {
- case AUDIO_GAIN_MODE_JOINT:
- return AudioGainMode::JOINT;
- case AUDIO_GAIN_MODE_CHANNELS:
- return AudioGainMode::CHANNELS;
- case AUDIO_GAIN_MODE_RAMP:
- return AudioGainMode::RAMP;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl) {
- return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, AudioGainMode>(
- aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
- // AudioGainMode is index-based.
- indexToEnum_index<AudioGainMode>,
- // AUDIO_GAIN_MODE_* constants are mask-based.
- enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy) {
- return convertBitmask<int32_t, audio_gain_mode_t, AudioGainMode, audio_gain_mode_t>(
- legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
- // AUDIO_GAIN_MODE_* constants are mask-based.
- indexToEnum_bitmask<audio_gain_mode_t>,
- // AudioGainMode is index-based.
- enumToMask_index<int32_t, AudioGainMode>);
-}
-
-ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
- const AudioGainConfig& aidl, bool isInput) {
- audio_gain_config legacy;
- legacy.index = VALUE_OR_RETURN(convertIntegral<int>(aidl.index));
- legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
- legacy.channel_mask = VALUE_OR_RETURN(
- aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
- const bool isJoint = bitmaskIsSet(aidl.mode, AudioGainMode::JOINT);
- size_t numValues = isJoint ? 1
- : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
- : audio_channel_count_from_out_mask(legacy.channel_mask);
- if (aidl.values.size() != numValues || aidl.values.size() > std::size(legacy.values)) {
- return unexpected(BAD_VALUE);
- }
- for (size_t i = 0; i < numValues; ++i) {
- legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
- }
- legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
- return legacy;
-}
-
-ConversionResult<AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig(
- const audio_gain_config& legacy, bool isInput) {
- AudioGainConfig aidl;
- aidl.index = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.index));
- aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
- aidl.channelMask = VALUE_OR_RETURN(
- legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
- const bool isJoint = (legacy.mode & AUDIO_GAIN_MODE_JOINT) != 0;
- size_t numValues = isJoint ? 1
- : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
- : audio_channel_count_from_out_mask(legacy.channel_mask);
- aidl.values.resize(numValues);
- for (size_t i = 0; i < numValues; ++i) {
- aidl.values[i] = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.values[i]));
- }
- aidl.rampDurationMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.ramp_duration_ms));
- return aidl;
-}
-
-ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(
- AudioInputFlags aidl) {
- switch (aidl) {
- case AudioInputFlags::FAST:
- return AUDIO_INPUT_FLAG_FAST;
- case AudioInputFlags::HW_HOTWORD:
- return AUDIO_INPUT_FLAG_HW_HOTWORD;
- case AudioInputFlags::RAW:
- return AUDIO_INPUT_FLAG_RAW;
- case AudioInputFlags::SYNC:
- return AUDIO_INPUT_FLAG_SYNC;
- case AudioInputFlags::MMAP_NOIRQ:
- return AUDIO_INPUT_FLAG_MMAP_NOIRQ;
- case AudioInputFlags::VOIP_TX:
- return AUDIO_INPUT_FLAG_VOIP_TX;
- case AudioInputFlags::HW_AV_SYNC:
- return AUDIO_INPUT_FLAG_HW_AV_SYNC;
- case AudioInputFlags::DIRECT:
- return AUDIO_INPUT_FLAG_DIRECT;
- case AudioInputFlags::ULTRASOUND:
- return AUDIO_INPUT_FLAG_ULTRASOUND;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(
- audio_input_flags_t legacy) {
- switch (legacy) {
- case AUDIO_INPUT_FLAG_NONE:
- break; // shouldn't get here. must be listed -Werror,-Wswitch
- case AUDIO_INPUT_FLAG_FAST:
- return AudioInputFlags::FAST;
- case AUDIO_INPUT_FLAG_HW_HOTWORD:
- return AudioInputFlags::HW_HOTWORD;
- case AUDIO_INPUT_FLAG_RAW:
- return AudioInputFlags::RAW;
- case AUDIO_INPUT_FLAG_SYNC:
- return AudioInputFlags::SYNC;
- case AUDIO_INPUT_FLAG_MMAP_NOIRQ:
- return AudioInputFlags::MMAP_NOIRQ;
- case AUDIO_INPUT_FLAG_VOIP_TX:
- return AudioInputFlags::VOIP_TX;
- case AUDIO_INPUT_FLAG_HW_AV_SYNC:
- return AudioInputFlags::HW_AV_SYNC;
- case AUDIO_INPUT_FLAG_DIRECT:
- return AudioInputFlags::DIRECT;
- case AUDIO_INPUT_FLAG_ULTRASOUND:
- return AudioInputFlags::ULTRASOUND;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(
- AudioOutputFlags aidl) {
- switch (aidl) {
- case AudioOutputFlags::DIRECT:
- return AUDIO_OUTPUT_FLAG_DIRECT;
- case AudioOutputFlags::PRIMARY:
- return AUDIO_OUTPUT_FLAG_PRIMARY;
- case AudioOutputFlags::FAST:
- return AUDIO_OUTPUT_FLAG_FAST;
- case AudioOutputFlags::DEEP_BUFFER:
- return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
- case AudioOutputFlags::COMPRESS_OFFLOAD:
- return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
- case AudioOutputFlags::NON_BLOCKING:
- return AUDIO_OUTPUT_FLAG_NON_BLOCKING;
- case AudioOutputFlags::HW_AV_SYNC:
- return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
- case AudioOutputFlags::TTS:
- return AUDIO_OUTPUT_FLAG_TTS;
- case AudioOutputFlags::RAW:
- return AUDIO_OUTPUT_FLAG_RAW;
- case AudioOutputFlags::SYNC:
- return AUDIO_OUTPUT_FLAG_SYNC;
- case AudioOutputFlags::IEC958_NONAUDIO:
- return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
- case AudioOutputFlags::DIRECT_PCM:
- return AUDIO_OUTPUT_FLAG_DIRECT_PCM;
- case AudioOutputFlags::MMAP_NOIRQ:
- return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;
- case AudioOutputFlags::VOIP_RX:
- return AUDIO_OUTPUT_FLAG_VOIP_RX;
- case AudioOutputFlags::INCALL_MUSIC:
- return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
- case AudioOutputFlags::GAPLESS_OFFLOAD:
- return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;
- case AudioOutputFlags::ULTRASOUND:
- return AUDIO_OUTPUT_FLAG_ULTRASOUND;
- case AudioOutputFlags::SPATIALIZER:
- return AUDIO_OUTPUT_FLAG_SPATIALIZER;
- case AudioOutputFlags::BIT_PERFECT:
- return AUDIO_OUTPUT_FLAG_BIT_PERFECT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(
- audio_output_flags_t legacy) {
- switch (legacy) {
- case AUDIO_OUTPUT_FLAG_NONE:
- break; // shouldn't get here. must be listed -Werror,-Wswitch
- case AUDIO_OUTPUT_FLAG_DIRECT:
- return AudioOutputFlags::DIRECT;
- case AUDIO_OUTPUT_FLAG_PRIMARY:
- return AudioOutputFlags::PRIMARY;
- case AUDIO_OUTPUT_FLAG_FAST:
- return AudioOutputFlags::FAST;
- case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:
- return AudioOutputFlags::DEEP_BUFFER;
- case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:
- return AudioOutputFlags::COMPRESS_OFFLOAD;
- case AUDIO_OUTPUT_FLAG_NON_BLOCKING:
- return AudioOutputFlags::NON_BLOCKING;
- case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:
- return AudioOutputFlags::HW_AV_SYNC;
- case AUDIO_OUTPUT_FLAG_TTS:
- return AudioOutputFlags::TTS;
- case AUDIO_OUTPUT_FLAG_RAW:
- return AudioOutputFlags::RAW;
- case AUDIO_OUTPUT_FLAG_SYNC:
- return AudioOutputFlags::SYNC;
- case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:
- return AudioOutputFlags::IEC958_NONAUDIO;
- case AUDIO_OUTPUT_FLAG_DIRECT_PCM:
- return AudioOutputFlags::DIRECT_PCM;
- case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:
- return AudioOutputFlags::MMAP_NOIRQ;
- case AUDIO_OUTPUT_FLAG_VOIP_RX:
- return AudioOutputFlags::VOIP_RX;
- case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:
- return AudioOutputFlags::INCALL_MUSIC;
- case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:
- return AudioOutputFlags::GAPLESS_OFFLOAD;
- case AUDIO_OUTPUT_FLAG_ULTRASOUND:
- return AudioOutputFlags::ULTRASOUND;
- case AUDIO_OUTPUT_FLAG_SPATIALIZER:
- return AudioOutputFlags::SPATIALIZER;
- case AUDIO_OUTPUT_FLAG_BIT_PERFECT:
- return AudioOutputFlags::BIT_PERFECT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
- int32_t aidl) {
- using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
-
- LegacyMask converted = VALUE_OR_RETURN(
- (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(
- aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
- indexToEnum_index<AudioInputFlags>,
- enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
- return static_cast<audio_input_flags_t>(converted);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
- audio_input_flags_t legacy) {
- using LegacyMask = std::underlying_type_t<audio_input_flags_t>;
-
- LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
- return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(
- legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
- indexToEnum_bitmask<audio_input_flags_t>,
- enumToMask_index<int32_t, AudioInputFlags>);
-}
-
-ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
- int32_t aidl) {
- return convertBitmask<audio_output_flags_t,
- int32_t,
- audio_output_flags_t,
- AudioOutputFlags>(
- aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
- indexToEnum_index<AudioOutputFlags>,
- enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
- audio_output_flags_t legacy) {
- using LegacyMask = std::underlying_type_t<audio_output_flags_t>;
-
- LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
- return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(
- legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
- indexToEnum_bitmask<audio_output_flags_t>,
- enumToMask_index<int32_t, AudioOutputFlags>);
-}
-
-ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
- const AudioIoFlags& aidl, bool isInput) {
- audio_io_flags legacy;
- if (isInput) {
- legacy.input = VALUE_OR_RETURN(
- aidl2legacy_int32_t_audio_input_flags_t_mask(
- VALUE_OR_RETURN(UNION_GET(aidl, input))));
- } else {
- legacy.output = VALUE_OR_RETURN(
- aidl2legacy_int32_t_audio_output_flags_t_mask(
- VALUE_OR_RETURN(UNION_GET(aidl, output))));
- }
- return legacy;
-}
-
-ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
- const audio_io_flags& legacy, bool isInput) {
- AudioIoFlags aidl;
- if (isInput) {
- UNION_SET(aidl, input,
- VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(legacy.input)));
- } else {
- UNION_SET(aidl, output,
- VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(legacy.output)));
- }
- return aidl;
-}
-
-ConversionResult<audio_port_config_device_ext>
-aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
- const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlDeviceExt) {
- audio_port_config_device_ext legacy;
- legacy.hw_module = VALUE_OR_RETURN(
- aidl2legacy_int32_t_audio_module_handle_t(aidlDeviceExt.hwModule));
- RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
- aidl.device, &legacy.type, legacy.address));
- return legacy;
-}
-
-status_t legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
- const audio_port_config_device_ext& legacy,
- AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {
- aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(
- legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
- aidl->device = VALUE_OR_RETURN_STATUS(
- legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
- return OK;
-}
-
-ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(
- AudioStreamType aidl) {
- switch (aidl) {
- case AudioStreamType::INVALID:
- break; // return error
- case AudioStreamType::SYS_RESERVED_DEFAULT:
- return AUDIO_STREAM_DEFAULT;
- case AudioStreamType::VOICE_CALL:
- return AUDIO_STREAM_VOICE_CALL;
- case AudioStreamType::SYSTEM:
- return AUDIO_STREAM_SYSTEM;
- case AudioStreamType::RING:
- return AUDIO_STREAM_RING;
- case AudioStreamType::MUSIC:
- return AUDIO_STREAM_MUSIC;
- case AudioStreamType::ALARM:
- return AUDIO_STREAM_ALARM;
- case AudioStreamType::NOTIFICATION:
- return AUDIO_STREAM_NOTIFICATION;
- case AudioStreamType::BLUETOOTH_SCO:
- return AUDIO_STREAM_BLUETOOTH_SCO;
- case AudioStreamType::ENFORCED_AUDIBLE:
- return AUDIO_STREAM_ENFORCED_AUDIBLE;
- case AudioStreamType::DTMF:
- return AUDIO_STREAM_DTMF;
- case AudioStreamType::TTS:
- return AUDIO_STREAM_TTS;
- case AudioStreamType::ACCESSIBILITY:
- return AUDIO_STREAM_ACCESSIBILITY;
- case AudioStreamType::ASSISTANT:
- return AUDIO_STREAM_ASSISTANT;
- case AudioStreamType::SYS_RESERVED_REROUTING:
- return AUDIO_STREAM_REROUTING;
- case AudioStreamType::SYS_RESERVED_PATCH:
- return AUDIO_STREAM_PATCH;
- case AudioStreamType::CALL_ASSISTANT:
- return AUDIO_STREAM_CALL_ASSISTANT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioStreamType> legacy2aidl_audio_stream_type_t_AudioStreamType(
- audio_stream_type_t legacy) {
- switch (legacy) {
- case AUDIO_STREAM_DEFAULT:
- return AudioStreamType::SYS_RESERVED_DEFAULT;
- case AUDIO_STREAM_VOICE_CALL:
- return AudioStreamType::VOICE_CALL;
- case AUDIO_STREAM_SYSTEM:
- return AudioStreamType::SYSTEM;
- case AUDIO_STREAM_RING:
- return AudioStreamType::RING;
- case AUDIO_STREAM_MUSIC:
- return AudioStreamType::MUSIC;
- case AUDIO_STREAM_ALARM:
- return AudioStreamType::ALARM;
- case AUDIO_STREAM_NOTIFICATION:
- return AudioStreamType::NOTIFICATION;
- case AUDIO_STREAM_BLUETOOTH_SCO:
- return AudioStreamType::BLUETOOTH_SCO;
- case AUDIO_STREAM_ENFORCED_AUDIBLE:
- return AudioStreamType::ENFORCED_AUDIBLE;
- case AUDIO_STREAM_DTMF:
- return AudioStreamType::DTMF;
- case AUDIO_STREAM_TTS:
- return AudioStreamType::TTS;
- case AUDIO_STREAM_ACCESSIBILITY:
- return AudioStreamType::ACCESSIBILITY;
- case AUDIO_STREAM_ASSISTANT:
- return AudioStreamType::ASSISTANT;
- case AUDIO_STREAM_REROUTING:
- return AudioStreamType::SYS_RESERVED_REROUTING;
- case AUDIO_STREAM_PATCH:
- return AudioStreamType::SYS_RESERVED_PATCH;
- case AUDIO_STREAM_CALL_ASSISTANT:
- return AudioStreamType::CALL_ASSISTANT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
- AudioSource aidl) {
- switch (aidl) {
- case AudioSource::SYS_RESERVED_INVALID:
- return AUDIO_SOURCE_INVALID;
- case AudioSource::DEFAULT:
- return AUDIO_SOURCE_DEFAULT;
- case AudioSource::MIC:
- return AUDIO_SOURCE_MIC;
- case AudioSource::VOICE_UPLINK:
- return AUDIO_SOURCE_VOICE_UPLINK;
- case AudioSource::VOICE_DOWNLINK:
- return AUDIO_SOURCE_VOICE_DOWNLINK;
- case AudioSource::VOICE_CALL:
- return AUDIO_SOURCE_VOICE_CALL;
- case AudioSource::CAMCORDER:
- return AUDIO_SOURCE_CAMCORDER;
- case AudioSource::VOICE_RECOGNITION:
- return AUDIO_SOURCE_VOICE_RECOGNITION;
- case AudioSource::VOICE_COMMUNICATION:
- return AUDIO_SOURCE_VOICE_COMMUNICATION;
- case AudioSource::REMOTE_SUBMIX:
- return AUDIO_SOURCE_REMOTE_SUBMIX;
- case AudioSource::UNPROCESSED:
- return AUDIO_SOURCE_UNPROCESSED;
- case AudioSource::VOICE_PERFORMANCE:
- return AUDIO_SOURCE_VOICE_PERFORMANCE;
- case AudioSource::ULTRASOUND:
- return AUDIO_SOURCE_ULTRASOUND;
- case AudioSource::ECHO_REFERENCE:
- return AUDIO_SOURCE_ECHO_REFERENCE;
- case AudioSource::FM_TUNER:
- return AUDIO_SOURCE_FM_TUNER;
- case AudioSource::HOTWORD:
- return AUDIO_SOURCE_HOTWORD;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioSource> legacy2aidl_audio_source_t_AudioSource(
- audio_source_t legacy) {
- switch (legacy) {
- case AUDIO_SOURCE_INVALID:
- return AudioSource::SYS_RESERVED_INVALID;
- case AUDIO_SOURCE_DEFAULT:
- return AudioSource::DEFAULT;
- case AUDIO_SOURCE_MIC:
- return AudioSource::MIC;
- case AUDIO_SOURCE_VOICE_UPLINK:
- return AudioSource::VOICE_UPLINK;
- case AUDIO_SOURCE_VOICE_DOWNLINK:
- return AudioSource::VOICE_DOWNLINK;
- case AUDIO_SOURCE_VOICE_CALL:
- return AudioSource::VOICE_CALL;
- case AUDIO_SOURCE_CAMCORDER:
- return AudioSource::CAMCORDER;
- case AUDIO_SOURCE_VOICE_RECOGNITION:
- return AudioSource::VOICE_RECOGNITION;
- case AUDIO_SOURCE_VOICE_COMMUNICATION:
- return AudioSource::VOICE_COMMUNICATION;
- case AUDIO_SOURCE_REMOTE_SUBMIX:
- return AudioSource::REMOTE_SUBMIX;
- case AUDIO_SOURCE_UNPROCESSED:
- return AudioSource::UNPROCESSED;
- case AUDIO_SOURCE_VOICE_PERFORMANCE:
- return AudioSource::VOICE_PERFORMANCE;
- case AUDIO_SOURCE_ULTRASOUND:
- return AudioSource::ULTRASOUND;
- case AUDIO_SOURCE_ECHO_REFERENCE:
- return AudioSource::ECHO_REFERENCE;
- case AUDIO_SOURCE_FM_TUNER:
- return AudioSource::FM_TUNER;
- case AUDIO_SOURCE_HOTWORD:
- return AudioSource::HOTWORD;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl) {
- return convertReinterpret<audio_session_t>(aidl);
-}
-
-ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy) {
- return convertReinterpret<int32_t>(legacy);
-}
-
// This type is unnamed in the original definition, thus we name it here.
using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);
@@ -1925,6 +326,27 @@
return legacy2aidl_audio_session_t_int32_t(legacy.session);
}
+ConversionResult<audio_port_config_device_ext>
+aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
+ const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlDeviceExt) {
+ audio_port_config_device_ext legacy;
+ legacy.hw_module = VALUE_OR_RETURN(
+ aidl2legacy_int32_t_audio_module_handle_t(aidlDeviceExt.hwModule));
+ RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
+ aidl.device, &legacy.type, legacy.address));
+ return legacy;
+}
+
+status_t legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(
+ const audio_port_config_device_ext& legacy,
+ AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {
+ aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
+ aidl->device = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));
+ return OK;
+}
+
// This type is unnamed in the original definition, thus we name it here.
using audio_port_config_ext = decltype(audio_port_config::ext);
@@ -2169,148 +591,6 @@
return aidl;
}
-ConversionResult<audio_content_type_t>
-aidl2legacy_AudioContentType_audio_content_type_t(AudioContentType aidl) {
- switch (aidl) {
- case AudioContentType::UNKNOWN:
- return AUDIO_CONTENT_TYPE_UNKNOWN;
- case AudioContentType::SPEECH:
- return AUDIO_CONTENT_TYPE_SPEECH;
- case AudioContentType::MUSIC:
- return AUDIO_CONTENT_TYPE_MUSIC;
- case AudioContentType::MOVIE:
- return AUDIO_CONTENT_TYPE_MOVIE;
- case AudioContentType::SONIFICATION:
- return AUDIO_CONTENT_TYPE_SONIFICATION;
- case AudioContentType::ULTRASOUND:
- return AUDIO_CONTENT_TYPE_ULTRASOUND;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioContentType>
-legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy) {
- switch (legacy) {
- case AUDIO_CONTENT_TYPE_UNKNOWN:
- return AudioContentType::UNKNOWN;
- case AUDIO_CONTENT_TYPE_SPEECH:
- return AudioContentType::SPEECH;
- case AUDIO_CONTENT_TYPE_MUSIC:
- return AudioContentType::MUSIC;
- case AUDIO_CONTENT_TYPE_MOVIE:
- return AudioContentType::MOVIE;
- case AUDIO_CONTENT_TYPE_SONIFICATION:
- return AudioContentType::SONIFICATION;
- case AUDIO_CONTENT_TYPE_ULTRASOUND:
- return AudioContentType::ULTRASOUND;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_usage_t>
-aidl2legacy_AudioUsage_audio_usage_t(AudioUsage aidl) {
- switch (aidl) {
- case AudioUsage::INVALID:
- break; // return error
- case AudioUsage::UNKNOWN:
- return AUDIO_USAGE_UNKNOWN;
- case AudioUsage::MEDIA:
- return AUDIO_USAGE_MEDIA;
- case AudioUsage::VOICE_COMMUNICATION:
- return AUDIO_USAGE_VOICE_COMMUNICATION;
- case AudioUsage::VOICE_COMMUNICATION_SIGNALLING:
- return AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
- case AudioUsage::ALARM:
- return AUDIO_USAGE_ALARM;
- case AudioUsage::NOTIFICATION:
- return AUDIO_USAGE_NOTIFICATION;
- case AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE:
- return AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
- case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST:
- return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST;
- case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT:
- return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT;
- case AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED:
- return AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED;
- case AudioUsage::NOTIFICATION_EVENT:
- return AUDIO_USAGE_NOTIFICATION_EVENT;
- case AudioUsage::ASSISTANCE_ACCESSIBILITY:
- return AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
- case AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE:
- return AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
- case AudioUsage::ASSISTANCE_SONIFICATION:
- return AUDIO_USAGE_ASSISTANCE_SONIFICATION;
- case AudioUsage::GAME:
- return AUDIO_USAGE_GAME;
- case AudioUsage::VIRTUAL_SOURCE:
- return AUDIO_USAGE_VIRTUAL_SOURCE;
- case AudioUsage::ASSISTANT:
- return AUDIO_USAGE_ASSISTANT;
- case AudioUsage::CALL_ASSISTANT:
- return AUDIO_USAGE_CALL_ASSISTANT;
- case AudioUsage::EMERGENCY:
- return AUDIO_USAGE_EMERGENCY;
- case AudioUsage::SAFETY:
- return AUDIO_USAGE_SAFETY;
- case AudioUsage::VEHICLE_STATUS:
- return AUDIO_USAGE_VEHICLE_STATUS;
- case AudioUsage::ANNOUNCEMENT:
- return AUDIO_USAGE_ANNOUNCEMENT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioUsage>
-legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy) {
- switch (legacy) {
- case AUDIO_USAGE_UNKNOWN:
- return AudioUsage::UNKNOWN;
- case AUDIO_USAGE_MEDIA:
- return AudioUsage::MEDIA;
- case AUDIO_USAGE_VOICE_COMMUNICATION:
- return AudioUsage::VOICE_COMMUNICATION;
- case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
- return AudioUsage::VOICE_COMMUNICATION_SIGNALLING;
- case AUDIO_USAGE_ALARM:
- return AudioUsage::ALARM;
- case AUDIO_USAGE_NOTIFICATION:
- return AudioUsage::NOTIFICATION;
- case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
- return AudioUsage::NOTIFICATION_TELEPHONY_RINGTONE;
- case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
- return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_REQUEST;
- case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
- return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_INSTANT;
- case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
- return AudioUsage::SYS_RESERVED_NOTIFICATION_COMMUNICATION_DELAYED;
- case AUDIO_USAGE_NOTIFICATION_EVENT:
- return AudioUsage::NOTIFICATION_EVENT;
- case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
- return AudioUsage::ASSISTANCE_ACCESSIBILITY;
- case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
- return AudioUsage::ASSISTANCE_NAVIGATION_GUIDANCE;
- case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
- return AudioUsage::ASSISTANCE_SONIFICATION;
- case AUDIO_USAGE_GAME:
- return AudioUsage::GAME;
- case AUDIO_USAGE_VIRTUAL_SOURCE:
- return AudioUsage::VIRTUAL_SOURCE;
- case AUDIO_USAGE_ASSISTANT:
- return AudioUsage::ASSISTANT;
- case AUDIO_USAGE_CALL_ASSISTANT:
- return AudioUsage::CALL_ASSISTANT;
- case AUDIO_USAGE_EMERGENCY:
- return AudioUsage::EMERGENCY;
- case AUDIO_USAGE_SAFETY:
- return AudioUsage::SAFETY;
- case AUDIO_USAGE_VEHICLE_STATUS:
- return AudioUsage::VEHICLE_STATUS;
- case AUDIO_USAGE_ANNOUNCEMENT:
- return AudioUsage::ANNOUNCEMENT;
- }
- return unexpected(BAD_VALUE);
-}
-
ConversionResult<audio_flags_mask_t>
aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl) {
switch (aidl) {
@@ -2434,140 +714,6 @@
return aidl;
}
-ConversionResult<audio_encapsulation_mode_t>
-aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(AudioEncapsulationMode aidl) {
- switch (aidl) {
- case AudioEncapsulationMode::INVALID:
- break; // return error
- case AudioEncapsulationMode::NONE:
- return AUDIO_ENCAPSULATION_MODE_NONE;
- case AudioEncapsulationMode::ELEMENTARY_STREAM:
- return AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM;
- case AudioEncapsulationMode::HANDLE:
- return AUDIO_ENCAPSULATION_MODE_HANDLE;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioEncapsulationMode>
-legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {
- switch (legacy) {
- case AUDIO_ENCAPSULATION_MODE_NONE:
- return AudioEncapsulationMode::NONE;
- case AUDIO_ENCAPSULATION_MODE_ELEMENTARY_STREAM:
- return AudioEncapsulationMode::ELEMENTARY_STREAM;
- case AUDIO_ENCAPSULATION_MODE_HANDLE:
- return AudioEncapsulationMode::HANDLE;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_offload_info_t>
-aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) {
- audio_offload_info_t legacy = AUDIO_INFO_INITIALIZER;
- audio_config_base_t base = VALUE_OR_RETURN(
- aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, false /*isInput*/));
- legacy.sample_rate = base.sample_rate;
- legacy.channel_mask = base.channel_mask;
- legacy.format = base.format;
- legacy.stream_type = VALUE_OR_RETURN(
- aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
- legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));
- legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
- legacy.has_video = aidl.hasVideo;
- legacy.is_streaming = aidl.isStreaming;
- legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
- legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
- legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
- legacy.encapsulation_mode = VALUE_OR_RETURN(
- aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
- legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));
- legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));
- return legacy;
-}
-
-ConversionResult<AudioOffloadInfo>
-legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy) {
- AudioOffloadInfo aidl;
- // Version 0.1 fields.
- if (legacy.size < offsetof(audio_offload_info_t, usage) + sizeof(audio_offload_info_t::usage)) {
- return unexpected(BAD_VALUE);
- }
- const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
- .channel_mask = legacy.channel_mask, .format = legacy.format };
- aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(
- base, false /*isInput*/));
- aidl.streamType = VALUE_OR_RETURN(
- legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream_type));
- aidl.bitRatePerSecond = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_rate));
- aidl.durationUs = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.duration_us));
- aidl.hasVideo = legacy.has_video;
- aidl.isStreaming = legacy.is_streaming;
- aidl.bitWidth = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.bit_width));
- aidl.offloadBufferSize = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.offload_buffer_size));
- aidl.usage = VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.usage));
-
- // Version 0.2 fields.
- if (legacy.version >= AUDIO_OFFLOAD_INFO_VERSION_0_2) {
- if (legacy.size <
- offsetof(audio_offload_info_t, sync_id) + sizeof(audio_offload_info_t::sync_id)) {
- return unexpected(BAD_VALUE);
- }
- aidl.encapsulationMode = VALUE_OR_RETURN(
- legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(
- legacy.encapsulation_mode));
- aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));
- aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
- }
- return aidl;
-}
-
-ConversionResult<audio_config_t>
-aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {
- const audio_config_base_t legacyBase = VALUE_OR_RETURN(
- aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.base, isInput));
- audio_config_t legacy = AUDIO_CONFIG_INITIALIZER;
- legacy.sample_rate = legacyBase.sample_rate;
- legacy.channel_mask = legacyBase.channel_mask;
- legacy.format = legacyBase.format;
- legacy.offload_info = VALUE_OR_RETURN(
- aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
- legacy.frame_count = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.frameCount));
- return legacy;
-}
-
-ConversionResult<AudioConfig>
-legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {
- const audio_config_base_t base = { .sample_rate = legacy.sample_rate,
- .channel_mask = legacy.channel_mask, .format = legacy.format };
- AudioConfig aidl;
- aidl.base = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(base, isInput));
- aidl.offloadInfo = VALUE_OR_RETURN(
- legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
- aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.frame_count));
- return aidl;
-}
-
-ConversionResult<audio_config_base_t>
-aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
- audio_config_base_t legacy;
- legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
- legacy.channel_mask = VALUE_OR_RETURN(
- aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
- legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
- return legacy;
-}
-
-ConversionResult<AudioConfigBase>
-legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {
- AudioConfigBase aidl;
- aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));
- aidl.channelMask = VALUE_OR_RETURN(
- legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
- aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
- return aidl;
-}
-
ConversionResult<sp<IMemory>>
aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion& aidl) {
sp<IMemory> legacy;
@@ -2586,8 +732,8 @@
return aidl;
}
-ConversionResult<sp<IMemory>>
-aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion>& aidl) {
+ConversionResult<sp<IMemory>> aidl2legacy_NullableSharedFileRegion_IMemory(
+ const std::optional<media::SharedFileRegion>& aidl) {
sp<IMemory> legacy;
if (!convertNullableSharedFileRegionToIMemory(aidl, &legacy)) {
return unexpected(BAD_VALUE);
@@ -2622,31 +768,6 @@
return aidl;
}
-ConversionResult<audio_uuid_t>
-aidl2legacy_AudioUuid_audio_uuid_t(const AudioUuid& aidl) {
- audio_uuid_t legacy;
- legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));
- legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));
- legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));
- legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));
- if (aidl.node.size() != std::size(legacy.node)) {
- return unexpected(BAD_VALUE);
- }
- std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);
- return legacy;
-}
-
-ConversionResult<AudioUuid>
-legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {
- AudioUuid aidl;
- aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));
- aidl.timeMid = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeMid));
- aidl.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.timeHiAndVersion));
- aidl.clockSeq = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.clockSeq));
- std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));
- return aidl;
-}
-
ConversionResult<effect_descriptor_t>
aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor& aidl) {
effect_descriptor_t legacy;
@@ -2677,76 +798,34 @@
return aidl;
}
-ConversionResult<audio_encapsulation_metadata_type_t>
-aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
- AudioEncapsulationMetadataType aidl) {
- switch (aidl) {
- case AudioEncapsulationMetadataType::NONE:
- return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;
- case AudioEncapsulationMetadataType::FRAMEWORK_TUNER:
- return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;
- case AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:
- return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;
- }
- return unexpected(BAD_VALUE);
+ConversionResult<audio_port_mix_ext>
+aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
+ const AudioPortMixExt& aidl, const media::AudioPortMixExtSys& aidlSys) {
+ audio_port_mix_ext legacy{};
+ legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidlSys.hwModule));
+ legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
+ return legacy;
}
-ConversionResult<AudioEncapsulationMetadataType>
-legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
- audio_encapsulation_metadata_type_t legacy) {
- switch (legacy) {
- case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:
- return AudioEncapsulationMetadataType::NONE;
- case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:
- return AudioEncapsulationMetadataType::FRAMEWORK_TUNER;
- case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:
- return AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;
- }
- return unexpected(BAD_VALUE);
+status_t
+legacy2aidl_audio_port_mix_ext_AudioPortMixExt(const audio_port_mix_ext& legacy,
+ AudioPortMixExt* aidl, media::AudioPortMixExtSys* aidlMixExt) {
+ aidlMixExt->hwModule = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
+ aidl->handle = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
+ return OK;
}
-ConversionResult<uint32_t>
-aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
- return convertBitmask<uint32_t,
- int32_t,
- audio_encapsulation_mode_t,
- AudioEncapsulationMode>(
- aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
- indexToEnum_index<AudioEncapsulationMode>,
- enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
+ConversionResult<audio_port_session_ext>
+aidl2legacy_int32_t_audio_port_session_ext(int32_t aidl) {
+ audio_port_session_ext legacy;
+ legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl));
+ return legacy;
}
ConversionResult<int32_t>
-legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
- return convertBitmask<int32_t,
- uint32_t,
- AudioEncapsulationMode,
- audio_encapsulation_mode_t>(
- legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
- indexToEnum_index<audio_encapsulation_mode_t>,
- enumToMask_index<int32_t, AudioEncapsulationMode>);
-}
-
-ConversionResult<uint32_t>
-aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
- return convertBitmask<uint32_t,
- int32_t,
- audio_encapsulation_metadata_type_t,
- AudioEncapsulationMetadataType>(
- aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
- indexToEnum_index<AudioEncapsulationMetadataType>,
- enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
-}
-
-ConversionResult<int32_t>
-legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
- return convertBitmask<int32_t,
- uint32_t,
- AudioEncapsulationMetadataType,
- audio_encapsulation_metadata_type_t>(
- legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
- indexToEnum_index<audio_encapsulation_metadata_type_t>,
- enumToMask_index<int32_t, AudioEncapsulationMetadataType>);
+legacy2aidl_audio_port_session_ext_int32_t(const audio_port_session_ext& legacy) {
+ return legacy2aidl_audio_session_t_int32_t(legacy.session);
}
ConversionResult<audio_port_device_ext>
@@ -2779,36 +858,6 @@
return OK;
}
-ConversionResult<audio_port_mix_ext>
-aidl2legacy_AudioPortMixExt_audio_port_mix_ext(
- const AudioPortMixExt& aidl, const media::AudioPortMixExtSys& aidlSys) {
- audio_port_mix_ext legacy{};
- legacy.hw_module = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_module_handle_t(aidlSys.hwModule));
- legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));
- return legacy;
-}
-
-status_t
-legacy2aidl_audio_port_mix_ext_AudioPortMixExt(const audio_port_mix_ext& legacy,
- AudioPortMixExt* aidl, media::AudioPortMixExtSys* aidlMixExt) {
- aidlMixExt->hwModule = VALUE_OR_RETURN_STATUS(
- legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));
- aidl->handle = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));
- return OK;
-}
-
-ConversionResult<audio_port_session_ext>
-aidl2legacy_int32_t_audio_port_session_ext(int32_t aidl) {
- audio_port_session_ext legacy;
- legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl));
- return legacy;
-}
-
-ConversionResult<int32_t>
-legacy2aidl_audio_port_session_ext_int32_t(const audio_port_session_ext& legacy) {
- return legacy2aidl_audio_session_t_int32_t(legacy.session);
-}
-
// This type is unnamed in the original definition, thus we name it here.
using audio_port_v7_ext = decltype(audio_port_v7::ext);
@@ -2880,93 +929,6 @@
LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail
}
-ConversionResult<audio_profile>
-aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {
- audio_profile legacy;
- legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
-
- if (aidl.sampleRates.size() > std::size(legacy.sample_rates)) {
- return unexpected(BAD_VALUE);
- }
- RETURN_IF_ERROR(
- convertRange(aidl.sampleRates.begin(), aidl.sampleRates.end(), legacy.sample_rates,
- convertIntegral<int32_t, unsigned int>));
- legacy.num_sample_rates = aidl.sampleRates.size();
-
- if (aidl.channelMasks.size() > std::size(legacy.channel_masks)) {
- return unexpected(BAD_VALUE);
- }
- RETURN_IF_ERROR(
- convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,
- [isInput](const AudioChannelLayout& l) {
- return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);
- }));
- legacy.num_channel_masks = aidl.channelMasks.size();
-
- legacy.encapsulation_type = VALUE_OR_RETURN(
- aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(aidl.encapsulationType));
- return legacy;
-}
-
-ConversionResult<AudioProfile>
-legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {
- AudioProfile aidl;
- aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
-
- if (legacy.num_sample_rates > std::size(legacy.sample_rates)) {
- return unexpected(BAD_VALUE);
- }
- RETURN_IF_ERROR(
- convertRange(legacy.sample_rates, legacy.sample_rates + legacy.num_sample_rates,
- std::back_inserter(aidl.sampleRates),
- convertIntegral<unsigned int, int32_t>));
-
- if (legacy.num_channel_masks > std::size(legacy.channel_masks)) {
- return unexpected(BAD_VALUE);
- }
- RETURN_IF_ERROR(
- convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,
- std::back_inserter(aidl.channelMasks),
- [isInput](audio_channel_mask_t m) {
- return legacy2aidl_audio_channel_mask_t_AudioChannelLayout(m, isInput);
- }));
-
- aidl.encapsulationType = VALUE_OR_RETURN(
- legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
- legacy.encapsulation_type));
- return aidl;
-}
-
-ConversionResult<audio_gain>
-aidl2legacy_AudioGain_audio_gain(const AudioGain& aidl, bool isInput) {
- audio_gain legacy;
- legacy.mode = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_gain_mode_t_mask(aidl.mode));
- legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
- aidl.channelMask, isInput));
- legacy.min_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.minValue));
- legacy.max_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.maxValue));
- legacy.default_value = VALUE_OR_RETURN(convertIntegral<int>(aidl.defaultValue));
- legacy.step_value = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.stepValue));
- legacy.min_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.minRampMs));
- legacy.max_ramp_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.maxRampMs));
- return legacy;
-}
-
-ConversionResult<AudioGain>
-legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {
- AudioGain aidl;
- aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));
- aidl.channelMask = VALUE_OR_RETURN(
- legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));
- aidl.minValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_value));
- aidl.maxValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_value));
- aidl.defaultValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.default_value));
- aidl.stepValue = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.step_value));
- aidl.minRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.min_ramp_ms));
- aidl.maxRampMs = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.max_ramp_ms));
- return aidl;
-}
-
ConversionResult<audio_port_v7>
aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) {
audio_port_v7 legacy;
@@ -3061,58 +1023,6 @@
return aidl;
}
-ConversionResult<audio_mode_t>
-aidl2legacy_AudioMode_audio_mode_t(AudioMode aidl) {
- switch (aidl) {
- case AudioMode::SYS_RESERVED_INVALID:
- return AUDIO_MODE_INVALID;
- case AudioMode::SYS_RESERVED_CURRENT:
- return AUDIO_MODE_CURRENT;
- case AudioMode::NORMAL:
- return AUDIO_MODE_NORMAL;
- case AudioMode::RINGTONE:
- return AUDIO_MODE_RINGTONE;
- case AudioMode::IN_CALL:
- return AUDIO_MODE_IN_CALL;
- case AudioMode::IN_COMMUNICATION:
- return AUDIO_MODE_IN_COMMUNICATION;
- case AudioMode::CALL_SCREEN:
- return AUDIO_MODE_CALL_SCREEN;
- case AudioMode::SYS_RESERVED_CALL_REDIRECT:
- return AUDIO_MODE_CALL_REDIRECT;
- case AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT:
- return AUDIO_MODE_COMMUNICATION_REDIRECT;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioMode>
-legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy) {
- switch (legacy) {
- case AUDIO_MODE_INVALID:
- return AudioMode::SYS_RESERVED_INVALID;
- case AUDIO_MODE_CURRENT:
- return AudioMode::SYS_RESERVED_CURRENT;
- case AUDIO_MODE_NORMAL:
- return AudioMode::NORMAL;
- case AUDIO_MODE_RINGTONE:
- return AudioMode::RINGTONE;
- case AUDIO_MODE_IN_CALL:
- return AudioMode::IN_CALL;
- case AUDIO_MODE_IN_COMMUNICATION:
- return AudioMode::IN_COMMUNICATION;
- case AUDIO_MODE_CALL_SCREEN:
- return AudioMode::CALL_SCREEN;
- case AUDIO_MODE_CALL_REDIRECT:
- return AudioMode::SYS_RESERVED_CALL_REDIRECT;
- case AUDIO_MODE_COMMUNICATION_REDIRECT:
- return AudioMode::SYS_RESERVED_COMMUNICATION_REDIRECT;
- case AUDIO_MODE_CNT:
- break;
- }
- return unexpected(BAD_VALUE);
-}
-
ConversionResult<audio_unique_id_use_t>
aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(media::AudioUniqueIdUse aidl) {
switch (aidl) {
@@ -3255,90 +1165,6 @@
return aidl;
}
-ConversionResult<audio_standard_t>
-aidl2legacy_AudioStandard_audio_standard_t(AudioStandard aidl) {
- switch (aidl) {
- case AudioStandard::NONE:
- return AUDIO_STANDARD_NONE;
- case AudioStandard::EDID:
- return AUDIO_STANDARD_EDID;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioStandard>
-legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy) {
- switch (legacy) {
- case AUDIO_STANDARD_NONE:
- return AudioStandard::NONE;
- case AUDIO_STANDARD_EDID:
- return AudioStandard::EDID;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<audio_extra_audio_descriptor>
-aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
- const ExtraAudioDescriptor& aidl) {
- audio_extra_audio_descriptor legacy;
- legacy.standard = VALUE_OR_RETURN(aidl2legacy_AudioStandard_audio_standard_t(aidl.standard));
- if (aidl.audioDescriptor.size() > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
- return unexpected(BAD_VALUE);
- }
- legacy.descriptor_length = aidl.audioDescriptor.size();
- std::copy(aidl.audioDescriptor.begin(), aidl.audioDescriptor.end(),
- std::begin(legacy.descriptor));
- legacy.encapsulation_type =
- VALUE_OR_RETURN(aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
- aidl.encapsulationType));
- return legacy;
-}
-
-ConversionResult<ExtraAudioDescriptor>
-legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
- const audio_extra_audio_descriptor& legacy) {
- ExtraAudioDescriptor aidl;
- aidl.standard = VALUE_OR_RETURN(legacy2aidl_audio_standard_t_AudioStandard(legacy.standard));
- if (legacy.descriptor_length > EXTRA_AUDIO_DESCRIPTOR_SIZE) {
- return unexpected(BAD_VALUE);
- }
- aidl.audioDescriptor.resize(legacy.descriptor_length);
- std::copy(legacy.descriptor, legacy.descriptor + legacy.descriptor_length,
- aidl.audioDescriptor.begin());
- aidl.encapsulationType =
- VALUE_OR_RETURN(legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
- legacy.encapsulation_type));
- return aidl;
-}
-
-ConversionResult<audio_encapsulation_type_t>
-aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
- const AudioEncapsulationType& aidl) {
- switch (aidl) {
- case AudioEncapsulationType::NONE:
- return AUDIO_ENCAPSULATION_TYPE_NONE;
- case AudioEncapsulationType::IEC61937:
- return AUDIO_ENCAPSULATION_TYPE_IEC61937;
- case AudioEncapsulationType::PCM:
- return AUDIO_ENCAPSULATION_TYPE_PCM;
- }
- return unexpected(BAD_VALUE);
-}
-
-ConversionResult<AudioEncapsulationType>
-legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
- const audio_encapsulation_type_t & legacy) {
- switch (legacy) {
- case AUDIO_ENCAPSULATION_TYPE_NONE:
- return AudioEncapsulationType::NONE;
- case AUDIO_ENCAPSULATION_TYPE_IEC61937:
- return AudioEncapsulationType::IEC61937;
- case AUDIO_ENCAPSULATION_TYPE_PCM:
- return AudioEncapsulationType::PCM;
- }
- return unexpected(BAD_VALUE);
-}
-
ConversionResult<TrackSecondaryOutputInfoPair>
aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair(
const media::TrackSecondaryOutputInfo& aidl) {
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index e0a8571..c0abb70 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -193,88 +193,29 @@
},
}
-// This is intended for clients needing to include AidlConversionUtil.h, without dragging in a lot of extra
-// dependencies.
-cc_library_headers {
- name: "libaudioclient_aidl_conversion_util",
- host_supported: true,
- vendor_available: true,
- double_loadable: true,
- min_sdk_version: "29",
- export_include_dirs: [
- "include",
- ],
- header_libs: [
- "libbase_headers",
- "liberror_headers",
- ],
- export_header_lib_headers: [
- "libbase_headers",
- "liberror_headers",
- ],
- apex_available: [
- "//apex_available:platform",
- "com.android.btservices",
- "com.android.media",
- "com.android.media.swcodec",
- ],
- target: {
- darwin: {
- enabled: false,
- },
- },
-}
-
cc_library {
name: "libaudioclient_aidl_conversion",
srcs: ["AidlConversion.cpp"],
- export_include_dirs: ["include"],
- host_supported: true,
- vendor_available: true,
- double_loadable: true,
- min_sdk_version: "29",
- header_libs: [
- "libaudioclient_aidl_conversion_util",
- "libaudio_system_headers",
- ],
- export_header_lib_headers: [
- "libaudioclient_aidl_conversion_util",
- ],
- defaults: [
- "latest_android_media_audio_common_types_cpp_export_shared",
- ],
shared_libs: [
"audioclient-types-aidl-cpp",
- "libbase",
- "libbinder",
- "liblog",
- "libshmemcompat",
- "libstagefright_foundation",
- "libutils",
- "shared-file-region-aidl-cpp",
- "framework-permission-aidl-cpp",
+ ],
+ static_libs: [
+ "libaudio_aidl_conversion_common_cpp",
+ ],
+ export_include_dirs: ["include"],
+ header_libs: [
+ "libaudio_aidl_conversion_common_util_cpp",
+ ],
+ export_header_lib_headers: [
+ "libaudio_aidl_conversion_common_util_cpp",
],
export_shared_lib_headers: [
"audioclient-types-aidl-cpp",
- "libbase",
- "shared-file-region-aidl-cpp",
],
- cflags: [
- "-Wall",
- "-Werror",
- "-Wno-error=deprecated-declarations",
+ defaults: [
+ "audio_aidl_conversion_common_default",
+ "latest_android_media_audio_common_types_cpp_export_shared",
],
- sanitize: {
- misc_undefined: [
- "unsigned-integer-overflow",
- "signed-integer-overflow",
- ],
- },
- target: {
- darwin: {
- enabled: false,
- },
- },
}
// AIDL interface between libaudioclient and framework.jar
diff --git a/media/libaudioclient/include/media/AidlConversion.h b/media/libaudioclient/include/media/AidlConversion.h
index 1e66164..afcb61a 100644
--- a/media/libaudioclient/include/media/AidlConversion.h
+++ b/media/libaudioclient/include/media/AidlConversion.h
@@ -37,33 +37,10 @@
#include <android/media/EffectDescriptor.h>
#include <android/media/LatencyMode.h>
#include <android/media/TrackSecondaryOutputInfo.h>
-#include <android/media/audio/common/AudioChannelLayout.h>
-#include <android/media/audio/common/AudioConfig.h>
-#include <android/media/audio/common/AudioConfigBase.h>
-#include <android/media/audio/common/AudioContentType.h>
-#include <android/media/audio/common/AudioDeviceDescription.h>
-#include <android/media/audio/common/AudioEncapsulationMetadataType.h>
-#include <android/media/audio/common/AudioEncapsulationMode.h>
-#include <android/media/audio/common/AudioEncapsulationType.h>
-#include <android/media/audio/common/AudioFormatDescription.h>
-#include <android/media/audio/common/AudioGain.h>
-#include <android/media/audio/common/AudioGainConfig.h>
-#include <android/media/audio/common/AudioGainMode.h>
-#include <android/media/audio/common/AudioInputFlags.h>
-#include <android/media/audio/common/AudioMode.h>
-#include <android/media/audio/common/AudioOffloadInfo.h>
-#include <android/media/audio/common/AudioOutputFlags.h>
-#include <android/media/audio/common/AudioPortExt.h>
-#include <android/media/audio/common/AudioPortMixExt.h>
-#include <android/media/audio/common/AudioProfile.h>
-#include <android/media/audio/common/AudioSource.h>
-#include <android/media/audio/common/AudioStandard.h>
-#include <android/media/audio/common/AudioUsage.h>
-#include <android/media/audio/common/AudioUuid.h>
-#include <android/media/audio/common/ExtraAudioDescriptor.h>
#include <android/media/SharedFileRegion.h>
#include <binder/IMemory.h>
+#include <media/AidlConversionCppNdk.h>
#include <media/AidlConversionUtil.h>
#include <media/AudioClient.h>
#include <media/AudioCommonTypes.h>
@@ -73,49 +50,6 @@
namespace android {
-// maxSize is the size of the C-string buffer (including the 0-terminator), NOT the max length of
-// the string.
-status_t aidl2legacy_string(std::string_view aidl, char* dest, size_t maxSize);
-ConversionResult<std::string> legacy2aidl_string(const char* legacy, size_t maxSize);
-
-ConversionResult<audio_module_handle_t> aidl2legacy_int32_t_audio_module_handle_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_module_handle_t_int32_t(audio_module_handle_t legacy);
-
-ConversionResult<audio_io_handle_t> aidl2legacy_int32_t_audio_io_handle_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_io_handle_t_int32_t(audio_io_handle_t legacy);
-
-ConversionResult<audio_port_handle_t> aidl2legacy_int32_t_audio_port_handle_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_port_handle_t_int32_t(audio_port_handle_t legacy);
-
-ConversionResult<audio_patch_handle_t> aidl2legacy_int32_t_audio_patch_handle_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_patch_handle_t_int32_t(audio_patch_handle_t legacy);
-
-ConversionResult<audio_unique_id_t> aidl2legacy_int32_t_audio_unique_id_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_unique_id_t_int32_t(audio_unique_id_t legacy);
-
-ConversionResult<audio_hw_sync_t> aidl2legacy_int32_t_audio_hw_sync_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_hw_sync_t_int32_t(audio_hw_sync_t legacy);
-
-ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy);
-
-ConversionResult<pid_t> aidl2legacy_int32_t_pid_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_pid_t_int32_t(pid_t legacy);
-
-ConversionResult<uid_t> aidl2legacy_int32_t_uid_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_uid_t_int32_t(uid_t legacy);
-
-ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl);
-ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy);
-
-ConversionResult<String16> aidl2legacy_string_view_String16(std::string_view aidl);
-ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy);
-
-ConversionResult<std::optional<String16>>
-aidl2legacy_optional_string_view_optional_String16(std::optional<std::string_view> aidl);
-ConversionResult<std::optional<std::string_view>>
-legacy2aidl_optional_String16_optional_string(std::optional<String16> legacy);
-
ConversionResult<audio_io_config_event_t> aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(
media::AudioIoConfigEvent aidl);
ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(
@@ -131,75 +65,6 @@
ConversionResult<media::AudioPortType> legacy2aidl_audio_port_type_t_AudioPortType(
audio_port_type_t legacy);
-ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
- const media::audio::common::AudioChannelLayout& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioChannelLayout>
-legacy2aidl_audio_channel_mask_t_AudioChannelLayout(audio_channel_mask_t legacy, bool isInput);
-
-ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devices_t(
- const media::audio::common::AudioDeviceDescription& aidl);
-ConversionResult<media::audio::common::AudioDeviceDescription>
-legacy2aidl_audio_devices_t_AudioDeviceDescription(audio_devices_t legacy);
-
-status_t aidl2legacy_AudioDevice_audio_device(
- const media::audio::common::AudioDevice& aidl,
- audio_devices_t* legacyType, char* legacyAddress);
-status_t aidl2legacy_AudioDevice_audio_device(
- const media::audio::common::AudioDevice& aidl,
- audio_devices_t* legacyType, String8* legacyAddress);
-status_t aidl2legacy_AudioDevice_audio_device(
- const media::audio::common::AudioDevice& aidl,
- audio_devices_t* legacyType, std::string* legacyAddress);
-ConversionResult<media::audio::common::AudioDevice>
-legacy2aidl_audio_device_AudioDevice(
- audio_devices_t legacyType, const char* legacyAddress);
-ConversionResult<media::audio::common::AudioDevice>
-legacy2aidl_audio_device_AudioDevice(
- audio_devices_t legacyType, const String8& legacyAddress);
-
-ConversionResult<audio_format_t> aidl2legacy_AudioFormatDescription_audio_format_t(
- const media::audio::common::AudioFormatDescription& aidl);
-ConversionResult<media::audio::common::AudioFormatDescription>
-legacy2aidl_audio_format_t_AudioFormatDescription(audio_format_t legacy);
-
-ConversionResult<audio_gain_mode_t>
-aidl2legacy_AudioGainMode_audio_gain_mode_t(media::audio::common::AudioGainMode aidl);
-ConversionResult<media::audio::common::AudioGainMode>
-legacy2aidl_audio_gain_mode_t_AudioGainMode(audio_gain_mode_t legacy);
-
-ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_mode_t legacy);
-
-ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_config(
- const media::audio::common::AudioGainConfig& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioGainConfig>
-legacy2aidl_audio_gain_config_AudioGainConfig(const audio_gain_config& legacy, bool isInput);
-
-ConversionResult<audio_input_flags_t>
-aidl2legacy_AudioInputFlags_audio_input_flags_t(media::audio::common::AudioInputFlags aidl);
-ConversionResult<media::audio::common::AudioInputFlags>
-legacy2aidl_audio_input_flags_t_AudioInputFlags(audio_input_flags_t legacy);
-
-ConversionResult<audio_output_flags_t>
-aidl2legacy_AudioOutputFlags_audio_output_flags_t(media::audio::common::AudioOutputFlags aidl);
-ConversionResult<media::audio::common::AudioOutputFlags>
-legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_t legacy);
-
-ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_mask(
- int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask(
- audio_input_flags_t legacy);
-
-ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
- int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask(
- audio_output_flags_t legacy);
-
-ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(
- const media::audio::common::AudioIoFlags& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(
- const audio_io_flags& legacy, bool isInput);
-
ConversionResult<audio_port_config_device_ext>
aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(
const media::audio::common::AudioPortDeviceExt& aidl,
@@ -214,15 +79,6 @@
ConversionResult<media::audio::common::AudioStreamType>
legacy2aidl_audio_stream_type_t_AudioStreamType(audio_stream_type_t legacy);
-ConversionResult<audio_source_t> aidl2legacy_AudioSource_audio_source_t(
- media::audio::common::AudioSource aidl);
-ConversionResult<media::audio::common::AudioSource>
- legacy2aidl_audio_source_t_AudioSource(
- audio_source_t legacy);
-
-ConversionResult<audio_session_t> aidl2legacy_int32_t_audio_session_t(int32_t aidl);
-ConversionResult<int32_t> legacy2aidl_audio_session_t_int32_t(audio_session_t legacy);
-
ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt(
const media::audio::common::AudioPortMixExt& aidl, media::AudioPortRole role,
const media::AudioPortMixExtSys& aidlMixExt);
@@ -255,17 +111,6 @@
ConversionResult<media::AudioClient> legacy2aidl_AudioClient_AudioClient(
const AudioClient& legacy);
-ConversionResult<audio_content_type_t>
-aidl2legacy_AudioContentType_audio_content_type_t(
- media::audio::common::AudioContentType aidl);
-ConversionResult<media::audio::common::AudioContentType>
-legacy2aidl_audio_content_type_t_AudioContentType(audio_content_type_t legacy);
-
-ConversionResult<audio_usage_t>
-aidl2legacy_AudioUsage_audio_usage_t(media::audio::common::AudioUsage aidl);
-ConversionResult<media::audio::common::AudioUsage>
-legacy2aidl_audio_usage_t_AudioUsage(audio_usage_t legacy);
-
ConversionResult<audio_flags_mask_t>
aidl2legacy_AudioFlag_audio_flags_mask_t(media::AudioFlag aidl);
ConversionResult<media::AudioFlag>
@@ -281,36 +126,13 @@
ConversionResult<media::AudioAttributesInternal>
legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t& legacy);
-ConversionResult<audio_encapsulation_mode_t>
-aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(
- media::audio::common::AudioEncapsulationMode aidl);
-ConversionResult<media::audio::common::AudioEncapsulationMode>
-legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy);
-
-ConversionResult<audio_offload_info_t>
-aidl2legacy_AudioOffloadInfo_audio_offload_info_t(
- const media::audio::common::AudioOffloadInfo& aidl);
-ConversionResult<media::audio::common::AudioOffloadInfo>
-legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& legacy);
-
-ConversionResult<audio_config_t>
-aidl2legacy_AudioConfig_audio_config_t(const media::audio::common::AudioConfig& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioConfig>
-legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput);
-
-ConversionResult<audio_config_base_t>
-aidl2legacy_AudioConfigBase_audio_config_base_t(
- const media::audio::common::AudioConfigBase& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioConfigBase>
-legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput);
-
ConversionResult<sp<IMemory>>
aidl2legacy_SharedFileRegion_IMemory(const media::SharedFileRegion& aidl);
ConversionResult<media::SharedFileRegion>
legacy2aidl_IMemory_SharedFileRegion(const sp<IMemory>& legacy);
-ConversionResult<sp<IMemory>>
-aidl2legacy_NullableSharedFileRegion_IMemory(const std::optional<media::SharedFileRegion>& aidl);
+ConversionResult<sp<::android::IMemory>> aidl2legacy_NullableSharedFileRegion_IMemory(
+ const std::optional<media::SharedFileRegion>& aidl);
ConversionResult<std::optional<media::SharedFileRegion>>
legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy);
@@ -319,32 +141,10 @@
ConversionResult<media::AudioTimestampInternal>
legacy2aidl_AudioTimestamp_AudioTimestampInternal(const AudioTimestamp& legacy);
-ConversionResult<audio_uuid_t>
-aidl2legacy_AudioUuid_audio_uuid_t(const media::audio::common::AudioUuid& aidl);
-ConversionResult<media::audio::common::AudioUuid>
-legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy);
-
ConversionResult<effect_descriptor_t>
aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor& aidl);
-ConversionResult<media::EffectDescriptor>
-legacy2aidl_effect_descriptor_t_EffectDescriptor(const effect_descriptor_t& legacy);
-
-ConversionResult<audio_encapsulation_metadata_type_t>
-aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(
- media::audio::common::AudioEncapsulationMetadataType aidl);
-ConversionResult<media::audio::common::AudioEncapsulationMetadataType>
-legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(
- audio_encapsulation_metadata_type_t legacy);
-
-ConversionResult<uint32_t>
-aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl);
-ConversionResult<int32_t>
-legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy);
-
-ConversionResult<uint32_t>
-aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl);
-ConversionResult<int32_t>
-legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy);
+ConversionResult<media::EffectDescriptor> legacy2aidl_effect_descriptor_t_EffectDescriptor(
+ const effect_descriptor_t& legacy);
ConversionResult<audio_port_device_ext>
aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(
@@ -369,27 +169,11 @@
ConversionResult<int32_t>
legacy2aidl_audio_port_session_ext_int32_t(const audio_port_session_ext& legacy);
-ConversionResult<audio_profile>
-aidl2legacy_AudioProfile_audio_profile(
- const media::audio::common::AudioProfile& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioProfile>
-legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput);
-
-ConversionResult<audio_gain>
-aidl2legacy_AudioGain_audio_gain(const media::audio::common::AudioGain& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioGain>
-legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput);
-
ConversionResult<audio_port_v7>
aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl);
ConversionResult<media::AudioPort>
legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy);
-ConversionResult<audio_mode_t>
-aidl2legacy_AudioMode_audio_mode_t(media::audio::common::AudioMode aidl);
-ConversionResult<media::audio::common::AudioMode>
-legacy2aidl_audio_mode_t_AudioMode(audio_mode_t legacy);
-
ConversionResult<audio_unique_id_use_t>
aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(media::AudioUniqueIdUse aidl);
ConversionResult<media::AudioUniqueIdUse>
@@ -420,25 +204,6 @@
ConversionResult<media::AudioPlaybackRate>
legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(const audio_playback_rate_t& legacy);
-ConversionResult<audio_standard_t>
-aidl2legacy_AudioStandard_audio_standard_t(media::audio::common::AudioStandard aidl);
-ConversionResult<media::audio::common::AudioStandard>
-legacy2aidl_audio_standard_t_AudioStandard(audio_standard_t legacy);
-
-ConversionResult<audio_extra_audio_descriptor>
-aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor(
- const media::audio::common::ExtraAudioDescriptor& aidl);
-ConversionResult<media::audio::common::ExtraAudioDescriptor>
-legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor(
- const audio_extra_audio_descriptor& legacy);
-
-ConversionResult<audio_encapsulation_type_t>
-aidl2legacy_AudioEncapsulationType_audio_encapsulation_type_t(
- const media::audio::common::AudioEncapsulationType& aidl);
-ConversionResult<media::audio::common::AudioEncapsulationType>
-legacy2aidl_audio_encapsulation_type_t_AudioEncapsulationType(
- const audio_encapsulation_type_t & legacy);
-
using TrackSecondaryOutputInfoPair = std::pair<audio_port_handle_t, std::vector<audio_io_handle_t>>;
ConversionResult<TrackSecondaryOutputInfoPair>
aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair(
diff --git a/media/libaudioclient/tests/Android.bp b/media/libaudioclient/tests/Android.bp
index df1506a..cbcef12 100644
--- a/media/libaudioclient/tests/Android.bp
+++ b/media/libaudioclient/tests/Android.bp
@@ -36,8 +36,9 @@
"libutils",
],
static_libs: [
- "audioclient-types-aidl-cpp",
"libaudioclient_aidl_conversion",
+ "libaudio_aidl_conversion_common_cpp",
+ "audioclient-types-aidl-cpp",
"libstagefright_foundation",
],
}
@@ -108,6 +109,7 @@
shared_libs: [
"capture_state_listener-aidl-cpp",
"framework-permission-aidl-cpp",
+ "libaudioclient_aidl_conversion",
"libbase",
"libbinder",
"libcgrouprc",
@@ -137,7 +139,6 @@
"av-types-aidl-cpp",
"effect-aidl-cpp",
"libaudioclient",
- "libaudioclient_aidl_conversion",
"libaudiofoundation",
"libaudiomanager",
"libaudiopolicy",
diff --git a/media/libaudiofoundation/Android.bp b/media/libaudiofoundation/Android.bp
index a456a2a..c758fcd 100644
--- a/media/libaudiofoundation/Android.bp
+++ b/media/libaudiofoundation/Android.bp
@@ -18,12 +18,12 @@
export_include_dirs: ["include"],
header_libs: [
- "libaudioclient_aidl_conversion_util",
+ "libaudio_aidl_conversion_common_util_cpp",
"libaudio_system_headers",
"libmedia_helper_headers",
],
export_header_lib_headers: [
- "libaudioclient_aidl_conversion_util",
+ "libaudio_aidl_conversion_common_util_cpp",
"libaudio_system_headers",
"libmedia_helper_headers",
],
diff --git a/media/libaudiofoundation/tests/Android.bp b/media/libaudiofoundation/tests/Android.bp
index 0e733d3..2f4aee0 100644
--- a/media/libaudiofoundation/tests/Android.bp
+++ b/media/libaudiofoundation/tests/Android.bp
@@ -23,6 +23,7 @@
static_libs: [
"audioclient-types-aidl-cpp",
"libaudioclient_aidl_conversion",
+ "libaudio_aidl_conversion_common_cpp",
"libaudiofoundation",
"libstagefright_foundation",
],