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

Commit 72cd068f authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

Share AudioPort/Config conversion with HAL types 

At the framework level, AudioPort and AudioPortConfig are
split into HAL and System parts. Move the conversion of
the HAL part to AidlConversionCppNdk for use by libaudiohal.
Reuse code from AidlConversionCppNdk in AidlConversion
where possible.

Added tests for round-trip conversion.

Bug: 205884982
Test: atest audio_aidl_conversion_tests
Change-Id: I8adac946e30bfbe1d3ec5461e740c259b880b59a
parent 43cb03b9

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(

media/libaudioclient/AidlConversion.cpp

+101 −274

File changed.

Preview size limit exceeded, changes collapsed.

media/libaudioclient/include/media/AidlConversion.h

+3 −2
Original line number Diff line number Diff line
@@ -88,10 +88,11 @@ aidl2legacy_int32_t_audio_port_config_session_ext(int32_t aidl); 
ConversionResult<int32_t> legacy2aidl_audio_port_config_session_ext_AudioPortConfigSessionExt(

        const audio_port_config_session_ext& legacy);



// portId needs to be set when dealing with the HAL.

ConversionResult<audio_port_config> aidl2legacy_AudioPortConfigFw_audio_port_config(

        const media::AudioPortConfigFw& aidl);

        const media::AudioPortConfigFw& aidl, int32_t* aidlPortId = nullptr);

ConversionResult<media::AudioPortConfigFw> legacy2aidl_audio_port_config_AudioPortConfigFw(

        const audio_port_config& legacy);

        const audio_port_config& legacy, int32_t portId = 0);



ConversionResult<struct audio_patch> aidl2legacy_AudioPatchFw_audio_patch(

        const media::AudioPatchFw& aidl);

media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp

+164 −1

File changed.

Preview size limit exceeded, changes collapsed.