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

Commit 2a75d645 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Share AudioPort/Config conversion with HAL types" am: 66764eb6

parents 573e9490 66764eb6
Loading
Loading
Loading
Loading
+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;
+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(
+101 −274

File changed.

Preview size limit exceeded, changes collapsed.

+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);
+164 −1

File changed.

Preview size limit exceeded, changes collapsed.