Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 66764eb6 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Share AudioPort/Config conversion with HAL types"

parents aca826f7 72cd068f

media/audioaidlconversion/AidlConversionCppNdk.cpp

+447 −1
Original line number Diff line number Diff line
@@ -69,6 +69,8 @@ using media::audio::common::AudioMode; 
using media::audio::common::AudioOffloadInfo;

using media::audio::common::AudioOutputFlags;

using media::audio::common::AudioPlaybackRate;

using media::audio::common::AudioPort;

using media::audio::common::AudioPortConfig;

using media::audio::common::AudioPortDeviceExt;

using media::audio::common::AudioPortExt;

using media::audio::common::AudioPortMixExt;
@@ -1766,6 +1768,60 @@ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& le 
    return aidl;

}



ConversionResult<AudioPortDirection> portDirection(audio_port_role_t role, audio_port_type_t type) {

    switch (type) {

        case AUDIO_PORT_TYPE_NONE:

        case AUDIO_PORT_TYPE_SESSION:

            break;  // must be listed  -Werror,-Wswitch

        case AUDIO_PORT_TYPE_DEVICE:

            switch (role) {

                case AUDIO_PORT_ROLE_NONE:

                     break;  // must be listed  -Werror,-Wswitch

                case AUDIO_PORT_ROLE_SOURCE:

                    return AudioPortDirection::INPUT;

                case AUDIO_PORT_ROLE_SINK:

                    return AudioPortDirection::OUTPUT;

            }

            break;

        case AUDIO_PORT_TYPE_MIX:

            switch (role) {

                case AUDIO_PORT_ROLE_NONE:

                     break;  // must be listed  -Werror,-Wswitch

                case AUDIO_PORT_ROLE_SOURCE:

                    return AudioPortDirection::OUTPUT;

                case AUDIO_PORT_ROLE_SINK:

                    return AudioPortDirection::INPUT;

            }

            break;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_port_role_t> portRole(AudioPortDirection direction, audio_port_type_t type) {

    switch (type) {

        case AUDIO_PORT_TYPE_NONE:

        case AUDIO_PORT_TYPE_SESSION:

            break;  // must be listed  -Werror,-Wswitch

        case AUDIO_PORT_TYPE_DEVICE:

            switch (direction) {

                case AudioPortDirection::INPUT:

                    return AUDIO_PORT_ROLE_SOURCE;

                case AudioPortDirection::OUTPUT:

                    return AUDIO_PORT_ROLE_SINK;

            }

            break;

        case AUDIO_PORT_TYPE_MIX:

            switch (direction) {

                case AudioPortDirection::OUTPUT:

                    return AUDIO_PORT_ROLE_SOURCE;

                case AudioPortDirection::INPUT:

                    return AUDIO_PORT_ROLE_SINK;

            }

            break;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_config_t>

aidl2legacy_AudioConfig_audio_config_t(const AudioConfig& aidl, bool isInput) {

    const audio_config_base_t legacyBase = VALUE_OR_RETURN(
@@ -1909,6 +1965,396 @@ legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) { 
            enumToMask_index<int32_t, AudioEncapsulationMetadataType>);

}



ConversionResult<audio_port_config_mix_ext_usecase>

aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(

        const AudioPortMixExtUseCase& aidl, bool isInput) {

    audio_port_config_mix_ext_usecase legacy{};

    if (aidl.getTag() != AudioPortMixExtUseCase::Tag::unspecified) {

        if (!isInput) {

            legacy.stream = VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(

                            VALUE_OR_RETURN(UNION_GET(aidl, stream))));

        } else {

            legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(

                            VALUE_OR_RETURN(UNION_GET(aidl, source))));

        }

    }

    return legacy;

}



ConversionResult<AudioPortMixExtUseCase>

legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(

        const audio_port_config_mix_ext_usecase& legacy, bool isInput) {

    AudioPortMixExtUseCase aidl;

    if (!isInput) {

        UNION_SET(aidl, stream, VALUE_OR_RETURN(

                        legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.stream)));

    } else {

        UNION_SET(aidl, source, VALUE_OR_RETURN(

                        legacy2aidl_audio_source_t_AudioSource(legacy.source)));

    }

    return aidl;

}



ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(

        const AudioPortMixExt& aidl, bool isInput) {

    audio_port_config_mix_ext legacy{};

    legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));

    legacy.usecase = VALUE_OR_RETURN(

            aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(

                    aidl.usecase, isInput));

    return legacy;

}



ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(

        const audio_port_config_mix_ext& legacy, bool isInput) {

    AudioPortMixExt aidl;

    aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));

    aidl.usecase = VALUE_OR_RETURN(

            legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(

                    legacy.usecase, isInput));

    return aidl;

}



ConversionResult<audio_port_config_device_ext>

aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(const AudioPortDeviceExt& aidl) {

    audio_port_config_device_ext legacy{};

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(

                    aidl.device, &legacy.type, legacy.address));

    return legacy;

}



ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(

        const audio_port_config_device_ext& legacy) {

    AudioPortDeviceExt aidl;

    aidl.device = VALUE_OR_RETURN(

            legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));

    return aidl;

}



// This type is unnamed in the original definition, thus we name it here.

using audio_port_config_ext = decltype(audio_port_config::ext);



status_t aidl2legacy_AudioPortExt_audio_port_config_ext(

        const AudioPortExt& aidl, bool isInput,

        audio_port_config_ext* legacy, audio_port_type_t* type) {

    switch (aidl.getTag()) {

        case AudioPortExt::Tag::unspecified:

            // Just verify that the union is empty.

            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));

            *legacy = {};

            *type = AUDIO_PORT_TYPE_NONE;

            return OK;

        case AudioPortExt::Tag::device:

            legacy->device = VALUE_OR_RETURN_STATUS(

                    aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(

                            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));

            *type = AUDIO_PORT_TYPE_DEVICE;

            return OK;

        case AudioPortExt::Tag::mix:

            legacy->mix = VALUE_OR_RETURN_STATUS(

                    aidl2legacy_AudioPortMixExt_audio_port_config_mix_ext(

                            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix)), isInput));

            *type = AUDIO_PORT_TYPE_MIX;

            return OK;

        case AudioPortExt::Tag::session:

            // This variant is not used in the HAL scenario.

            legacy->session.session = AUDIO_SESSION_NONE;

            *type = AUDIO_PORT_TYPE_SESSION;

            return OK;



    }

    LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail

}



ConversionResult<AudioPortExt> legacy2aidl_audio_port_config_ext_AudioPortExt(

        const audio_port_config_ext& legacy, audio_port_type_t type, bool isInput) {

    AudioPortExt aidl;

    switch (type) {

        case AUDIO_PORT_TYPE_NONE:

            UNION_SET(aidl, unspecified, false);

            return aidl;

        case AUDIO_PORT_TYPE_DEVICE: {

            AudioPortDeviceExt device = VALUE_OR_RETURN(

                    legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(legacy.device));

            UNION_SET(aidl, device, device);

            return aidl;

        }

        case AUDIO_PORT_TYPE_MIX: {

            AudioPortMixExt mix = VALUE_OR_RETURN(

                    legacy2aidl_audio_port_config_mix_ext_AudioPortMixExt(legacy.mix, isInput));

            UNION_SET(aidl, mix, mix);

            return aidl;

        }

        case AUDIO_PORT_TYPE_SESSION:

            // This variant is not used in the HAL scenario.

            UNION_SET(aidl, unspecified, false);

            return aidl;

    }

    LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail

}



status_t aidl2legacy_AudioPortConfig_audio_port_config(

        const AudioPortConfig& aidl, bool isInput, audio_port_config* legacy, int32_t* portId) {

    legacy->id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));

    *portId = aidl.portId;

    if (aidl.sampleRate.has_value()) {

        legacy->sample_rate = VALUE_OR_RETURN_STATUS(

                convertIntegral<unsigned int>(aidl.sampleRate.value().value));

        legacy->config_mask |= AUDIO_PORT_CONFIG_SAMPLE_RATE;

    }

    if (aidl.channelMask.has_value()) {

        legacy->channel_mask =

                VALUE_OR_RETURN_STATUS(

                        aidl2legacy_AudioChannelLayout_audio_channel_mask_t(

                                aidl.channelMask.value(), isInput));

        legacy->config_mask |= AUDIO_PORT_CONFIG_CHANNEL_MASK;

    }

    if (aidl.format.has_value()) {

        legacy->format = VALUE_OR_RETURN_STATUS(

                aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format.value()));

        legacy->config_mask |= AUDIO_PORT_CONFIG_FORMAT;

    }

    if (aidl.gain.has_value()) {

        legacy->gain = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioGainConfig_audio_gain_config(

                        aidl.gain.value(), isInput));

        legacy->config_mask |= AUDIO_PORT_CONFIG_GAIN;

    }

    if (aidl.flags.has_value()) {

        legacy->flags = VALUE_OR_RETURN_STATUS(

                aidl2legacy_AudioIoFlags_audio_io_flags(aidl.flags.value(), isInput));

        legacy->config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    }

    RETURN_STATUS_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_config_ext(

                    aidl.ext, isInput, &legacy->ext, &legacy->type));

    legacy->role = VALUE_OR_RETURN_STATUS(portRole(isInput ?

                    AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy->type));

    return OK;

}



ConversionResult<AudioPortConfig>

legacy2aidl_audio_port_config_AudioPortConfig(

        const audio_port_config& legacy, bool isInput, int32_t portId) {

    AudioPortConfig aidl;

    aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));

    aidl.portId = portId;

    if (legacy.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {

        Int aidl_sampleRate;

        aidl_sampleRate.value = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));

        aidl.sampleRate = aidl_sampleRate;

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {

        aidl.channelMask = VALUE_OR_RETURN(

                legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_FORMAT) {

        aidl.format = VALUE_OR_RETURN(

                legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_GAIN) {

        aidl.gain = VALUE_OR_RETURN(

                legacy2aidl_audio_gain_config_AudioGainConfig(legacy.gain, isInput));

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {

        aidl.flags = VALUE_OR_RETURN(

                legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, isInput));

    }

    aidl.ext = VALUE_OR_RETURN(

            legacy2aidl_audio_port_config_ext_AudioPortExt(legacy.ext, legacy.type, isInput));

    return aidl;

}



ConversionResult<audio_port_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_mix_ext(

        const AudioPortMixExt& aidl) {

    audio_port_mix_ext legacy{};

    legacy.handle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.handle));

    return legacy;

}



ConversionResult<AudioPortMixExt> legacy2aidl_audio_port_mix_ext_AudioPortMixExt(

        const audio_port_mix_ext& legacy) {

    AudioPortMixExt aidl;

    aidl.handle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy.handle));

    return aidl;

}



ConversionResult<audio_port_device_ext>

aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(const AudioPortDeviceExt& aidl) {

    audio_port_device_ext legacy{};

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(

                    aidl.device, &legacy.type, legacy.address));

    return legacy;

}



ConversionResult<AudioPortDeviceExt> legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(

        const audio_port_device_ext& legacy) {

    AudioPortDeviceExt aidl;

    aidl.device = VALUE_OR_RETURN(

            legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));

    return aidl;

}



// This type is unnamed in the original definition, thus we name it here.

using audio_port_v7_ext = decltype(audio_port_v7::ext);



status_t aidl2legacy_AudioPortExt_audio_port_v7_ext(

        const AudioPortExt& aidl, audio_port_v7_ext* legacy, audio_port_type_t* type) {

    switch (aidl.getTag()) {

        case AudioPortExt::Tag::unspecified:

            // Just verify that the union is empty.

            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, unspecified));

            *legacy = {};

            *type = AUDIO_PORT_TYPE_NONE;

            return OK;

        case AudioPortExt::Tag::device:

            legacy->device = VALUE_OR_RETURN_STATUS(

                    aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(

                            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, device))));

            *type = AUDIO_PORT_TYPE_DEVICE;

            return OK;

        case AudioPortExt::Tag::mix:

            legacy->mix = VALUE_OR_RETURN_STATUS(

                    aidl2legacy_AudioPortMixExt_audio_port_mix_ext(

                            VALUE_OR_RETURN_STATUS(UNION_GET(aidl, mix))));

            *type = AUDIO_PORT_TYPE_MIX;

            return OK;

        case AudioPortExt::Tag::session:

            // This variant is not used in the HAL scenario.

            legacy->session.session = AUDIO_SESSION_NONE;

            *type = AUDIO_PORT_TYPE_SESSION;

            return OK;



    }

    LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail

}



ConversionResult<AudioPortExt> legacy2aidl_audio_port_v7_ext_AudioPortExt(

        const audio_port_v7_ext& legacy, audio_port_type_t type) {

    AudioPortExt aidl;

    switch (type) {

        case AUDIO_PORT_TYPE_NONE:

            UNION_SET(aidl, unspecified, false);

            return aidl;

        case AUDIO_PORT_TYPE_DEVICE: {

            AudioPortDeviceExt device = VALUE_OR_RETURN(

                    legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(legacy.device));

            UNION_SET(aidl, device, device);

            return aidl;

        }

        case AUDIO_PORT_TYPE_MIX: {

            AudioPortMixExt mix = VALUE_OR_RETURN(

                    legacy2aidl_audio_port_mix_ext_AudioPortMixExt(legacy.mix));

            UNION_SET(aidl, mix, mix);

            return aidl;

        }

        case AUDIO_PORT_TYPE_SESSION:

            // This variant is not used in the HAL scenario.

            UNION_SET(aidl, unspecified, false);

            return aidl;

    }

    LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail

}



ConversionResult<audio_port_v7>

aidl2legacy_AudioPort_audio_port_v7(const AudioPort& aidl, bool isInput) {

    audio_port_v7 legacy;

    legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.id));

    RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));



    if (aidl.profiles.size() > std::size(legacy.audio_profiles)) {

        return unexpected(BAD_VALUE);

    }

    RETURN_IF_ERROR(convertRange(

                    aidl.profiles.begin(), aidl.profiles.end(), legacy.audio_profiles,

                    [isInput](const AudioProfile& p) {

                        return aidl2legacy_AudioProfile_audio_profile(p, isInput);

                    }));

    legacy.num_audio_profiles = aidl.profiles.size();



    if (aidl.extraAudioDescriptors.size() > std::size(legacy.extra_audio_descriptors)) {

        return unexpected(BAD_VALUE);

    }

    RETURN_IF_ERROR(

            convertRange(

                    aidl.extraAudioDescriptors.begin(), aidl.extraAudioDescriptors.end(),

                    legacy.extra_audio_descriptors,

                    aidl2legacy_ExtraAudioDescriptor_audio_extra_audio_descriptor));

    legacy.num_extra_audio_descriptors = aidl.extraAudioDescriptors.size();



    if (aidl.gains.size() > std::size(legacy.gains)) {

        return unexpected(BAD_VALUE);

    }

    RETURN_IF_ERROR(convertRange(aidl.gains.begin(), aidl.gains.end(), legacy.gains,

                                 [isInput](const AudioGain& g) {

                                     return aidl2legacy_AudioGain_audio_gain(g, isInput);

                                 }));

    legacy.num_gains = aidl.gains.size();



    RETURN_IF_ERROR(aidl2legacy_AudioPortExt_audio_port_v7_ext(

                    aidl.ext, &legacy.ext, &legacy.type));

    legacy.role = VALUE_OR_RETURN(portRole(

                    isInput ? AudioPortDirection::INPUT : AudioPortDirection::OUTPUT, legacy.type));



    AudioPortConfig aidlPortConfig;

    int32_t portId;

    aidlPortConfig.flags = aidl.flags;

    aidlPortConfig.ext = aidl.ext;

    RETURN_IF_ERROR(aidl2legacy_AudioPortConfig_audio_port_config(

                    aidlPortConfig, isInput, &legacy.active_config, &portId));

    return legacy;

}



ConversionResult<AudioPort>

legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy, bool isInput) {

    AudioPort aidl;

    aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));

    aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));



    if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {

        return unexpected(BAD_VALUE);

    }

    RETURN_IF_ERROR(

            convertRange(legacy.audio_profiles, legacy.audio_profiles + legacy.num_audio_profiles,

                         std::back_inserter(aidl.profiles),

                         [isInput](const audio_profile& p) {

                             return legacy2aidl_audio_profile_AudioProfile(p, isInput);

                         }));



    if (legacy.num_extra_audio_descriptors > std::size(legacy.extra_audio_descriptors)) {

        return unexpected(BAD_VALUE);

    }

    aidl.profiles.resize(legacy.num_audio_profiles);

    RETURN_IF_ERROR(

            convertRange(legacy.extra_audio_descriptors,

                    legacy.extra_audio_descriptors + legacy.num_extra_audio_descriptors,

                    std::back_inserter(aidl.extraAudioDescriptors),

                    legacy2aidl_audio_extra_audio_descriptor_ExtraAudioDescriptor));



    if (legacy.num_gains > std::size(legacy.gains)) {

        return unexpected(BAD_VALUE);

    }

    RETURN_IF_ERROR(

            convertRange(legacy.gains, legacy.gains + legacy.num_gains,

                         std::back_inserter(aidl.gains),

                         [isInput](const audio_gain& g) {

                             return legacy2aidl_audio_gain_AudioGain(g, isInput);

                         }));

    aidl.gains.resize(legacy.num_gains);



    aidl.ext = VALUE_OR_RETURN(

            legacy2aidl_audio_port_v7_ext_AudioPortExt(legacy.ext, legacy.type));



    AudioPortConfig aidlPortConfig = VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(

                    legacy.active_config, isInput, aidl.id));

    if (aidlPortConfig.flags.has_value()) {

        aidl.flags = aidlPortConfig.flags.value();

    } else {

        aidl.flags = isInput ?

                AudioIoFlags::make<AudioIoFlags::Tag::input>(0) :

                AudioIoFlags::make<AudioIoFlags::Tag::output>(0);

    }

    return aidl;

}



ConversionResult<audio_profile>

aidl2legacy_AudioProfile_audio_profile(const AudioProfile& aidl, bool isInput) {

    audio_profile legacy;

media/audioaidlconversion/include/media/AidlConversionCppNdk.h

+55 −4
Original line number Diff line number Diff line
@@ -49,6 +49,8 @@ 
#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/AudioPort.h)

#include PREFIX(android/media/audio/common/AudioPortConfig.h)

#include PREFIX(android/media/audio/common/AudioPortExt.h)

#include PREFIX(android/media/audio/common/AudioPortMixExt.h)

#include PREFIX(android/media/audio/common/AudioPlaybackRate.h)
@@ -67,6 +69,7 @@ 


using ::android::String16;

using ::android::String8;

using ::android::status_t;



#if defined(BACKEND_NDK)

namespace aidl {
@@ -76,7 +79,7 @@ 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);

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);
@@ -122,6 +125,12 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan 
ConversionResult<media::audio::common::AudioChannelLayout>

legacy2aidl_audio_channel_mask_t_AudioChannelLayout(audio_channel_mask_t legacy, bool isInput);



enum class AudioPortDirection {

    INPUT, OUTPUT

};

ConversionResult<AudioPortDirection> portDirection(audio_port_role_t role, audio_port_type_t type);

ConversionResult<audio_port_role_t> portRole(AudioPortDirection direction, audio_port_type_t type);



ConversionResult<audio_config_t>

aidl2legacy_AudioConfig_audio_config_t(const media::audio::common::AudioConfig& aidl, bool isInput);

ConversionResult<media::audio::common::AudioConfig>
@@ -172,13 +181,13 @@ ConversionResult<audio_devices_t> aidl2legacy_AudioDeviceDescription_audio_devic 
ConversionResult<media::audio::common::AudioDeviceDescription>

legacy2aidl_audio_devices_t_AudioDeviceDescription(audio_devices_t legacy);



::android::status_t aidl2legacy_AudioDevice_audio_device(

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(

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(

status_t aidl2legacy_AudioDevice_audio_device(

        const media::audio::common::AudioDevice& aidl, audio_devices_t* legacyType,

        std::string* legacyAddress);
@@ -265,6 +274,48 @@ aidl2legacy_AudioOutputFlags_audio_output_flags_t(media::audio::common::AudioOut 
ConversionResult<media::audio::common::AudioOutputFlags>

legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_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);

ConversionResult<audio_port_config_mix_ext_usecase>

aidl2legacy_AudioPortMixExtUseCase_audio_port_config_mix_ext_usecase(

        const media::audio::common::AudioPortMixExtUseCase& aidl, bool isInput);

ConversionResult<media::audio::common::AudioPortMixExtUseCase>

legacy2aidl_audio_port_config_mix_ext_usecase_AudioPortMixExtUseCase(

        const audio_port_config_mix_ext_usecase& legacy, bool isInput);



ConversionResult<audio_port_config_device_ext>

aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(

        const media::audio::common::AudioPortDeviceExt& aidl);

ConversionResult<media::audio::common::AudioPortDeviceExt>

        legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(

        const audio_port_config_device_ext& legacy);



status_t aidl2legacy_AudioPortConfig_audio_port_config(

        const media::audio::common::AudioPortConfig& aidl, bool isInput,

        audio_port_config* legacy, int32_t* portId);

ConversionResult<media::audio::common::AudioPortConfig>

legacy2aidl_audio_port_config_AudioPortConfig(

        const audio_port_config& legacy, bool isInput, int32_t portId);



ConversionResult<audio_port_mix_ext> aidl2legacy_AudioPortMixExt_audio_port_mix_ext(

        const media::audio::common::AudioPortMixExt& aidl);

ConversionResult<media::audio::common::AudioPortMixExt>

legacy2aidl_audio_port_mix_ext_AudioPortMixExt(

        const audio_port_mix_ext& legacy);



ConversionResult<audio_port_device_ext>

aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(

        const media::audio::common::AudioPortDeviceExt& aidl);

ConversionResult<media::audio::common::AudioPortDeviceExt>

legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(

        const audio_port_device_ext& legacy);



ConversionResult<audio_port_v7>

aidl2legacy_AudioPort_audio_port_v7(

        const media::audio::common::AudioPort& aidl, bool isInput);

ConversionResult<media::audio::common::AudioPort>

legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy, bool isInput);



ConversionResult<audio_profile> aidl2legacy_AudioProfile_audio_profile(

        const media::audio::common::AudioProfile& aidl, bool isInput);

ConversionResult<media::audio::common::AudioProfile> legacy2aidl_audio_profile_AudioProfile(