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

Commit 9dec7011 authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

Switch the framework AIDL to use AudioChannelLayout 

'AudioChannelLayout' is a new type that will be used both by HAL
and framework interfaces. This CL changes the framework interfaces
to use it instead of 'AudioChannelMask' type which was used to
pass legacy 'audio_channel_mask_t' transparently via the AIDL
layer.

Remove the implementation of 'Parcelable' from AudioProfile and
AudioPortConfig in libaudiofoundation because the implementation
not used after converting audio fwk interfaces to AIDL, and
Parcelable's interface methods do not allow passing in any
context. In our case the context is the direction of the I/O
('isInput' flag) which is usually available externally, but absent
from the encapsulated data of these classes.

Update the audiofoundation_parcelable_test, switch to use of static
libs for the framework code so they can run on a device with
default system libraries.

Bug: 188932434
Test: check audio on device
Test: atest audiofoundation_parcelable_test
Change-Id: Ie59cdd64f001330ad4b5094264957198809a10a1
parent 88536dfa

media/libaudioclient/AidlConversion.cpp

+54 −48
Original line number Diff line number Diff line
@@ -279,16 +279,6 @@ ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) { 
            enumToMask_index<int32_t, media::AudioPortConfigType>);

}



ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelMask_audio_channel_mask_t(

        media::AudioChannelMask aidl) {

    return convertReinterpret<audio_channel_mask_t>(aidl);

}



ConversionResult<media::AudioChannelMask> legacy2aidl_audio_channel_mask_t_AudioChannelMask(

        audio_channel_mask_t legacy) {

    return convertReinterpret<media::AudioChannelMask>(legacy);

}



ConversionResult<audio_io_config_event_t> aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(

        media::AudioIoConfigEvent aidl) {

    switch (aidl) {
@@ -1103,7 +1093,7 @@ std::unordered_map<T, S> make_ReverseMap(const std::vector<std::pair<S, T>>& v) 
}  // namespace



ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_channel_mask_t(

        const media::AudioChannelLayout& aidl, bool isOutput) {

        const media::AudioChannelLayout& aidl, bool isInput) {

    using ReverseMap = std::unordered_map<media::AudioChannelLayout, audio_channel_mask_t>;

    using Tag = media::AudioChannelLayout::Tag;

    static const ReverseMap mIdx = make_ReverseMap(getIndexAudioChannelPairs());
@@ -1130,7 +1120,7 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan 
        case Tag::indexMask:

            return convert(aidl, mIdx, __func__, "index");

        case Tag::layoutMask:

            return convert(aidl, isOutput ? mOut : mIn, __func__, isOutput ? "output" : "input");

            return convert(aidl, isInput ? mIn : mOut, __func__, isInput ? "input" : "output");

        case Tag::voiceMask:

            return convert(aidl, mVoice, __func__, "voice");

    }
@@ -1139,7 +1129,7 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan 
}



ConversionResult<media::AudioChannelLayout> legacy2aidl_audio_channel_mask_t_AudioChannelLayout(

        audio_channel_mask_t legacy, bool isOutput) {

        audio_channel_mask_t legacy, bool isInput) {

    using DirectMap = std::unordered_map<audio_channel_mask_t, media::AudioChannelLayout>;

    using Tag = media::AudioChannelLayout::Tag;

    static const DirectMap mIdx = make_DirectMap(getIndexAudioChannelPairs());
@@ -1168,8 +1158,8 @@ ConversionResult<media::AudioChannelLayout> legacy2aidl_audio_channel_mask_t_Aud 
    if (repr == AUDIO_CHANNEL_REPRESENTATION_INDEX) {

        return convert(legacy, mIdx, __func__, "index");

    } else if (repr == AUDIO_CHANNEL_REPRESENTATION_POSITION) {

        return convert(legacy, isOutput ? mOut : mInAndVoice, __func__,

                isOutput ? "output" : "input / voice");

        return convert(legacy, isInput ? mInAndVoice : mOut, __func__,

                isInput ? "input / voice" : "output");

    }



    ALOGE("%s: unknown representation %d in audio_channel_mask_t value 0x%x",
@@ -1274,9 +1264,9 @@ ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_confi 
    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_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

    const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;

    legacy.channel_mask = VALUE_OR_RETURN(

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

    const bool isJoint = bitmaskIsSet(aidl.mode, media::AudioGainMode::JOINT);

    size_t numValues = isJoint ? 1

                               : isInput ? audio_channel_count_from_in_mask(legacy.channel_mask)
@@ -1296,9 +1286,9 @@ ConversionResult<media::AudioGainConfig> legacy2aidl_audio_gain_config_AudioGain 
    media::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_AudioChannelMask(legacy.channel_mask));

    const bool isInput = VALUE_OR_RETURN(direction(role, type)) == Direction::INPUT;

    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)
@@ -1863,9 +1853,11 @@ ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_confi 
        legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sampleRate));

    }

    if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::CHANNEL_MASK)) {

        const bool isInput = VALUE_OR_RETURN(direction(aidl.role, aidl.type)) == Direction::INPUT;

        legacy.channel_mask =

                VALUE_OR_RETURN(

                        aidl2legacy_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

                        aidl2legacy_AudioChannelLayout_audio_channel_mask_t(

                                aidl.channelMask, isInput));

    }

    if (bitmaskIsSet(aidl.configMask, media::AudioPortConfigType::FORMAT)) {

        legacy.format = VALUE_OR_RETURN(
@@ -1894,9 +1886,10 @@ ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPort 
        aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {

        aidl.channelMask =

                VALUE_OR_RETURN(

                        legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy.channel_mask));

        const bool isInput = VALUE_OR_RETURN(

                direction(legacy.role, legacy.type)) == Direction::INPUT;

        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(
@@ -1971,7 +1964,7 @@ ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDes 
    const audio_format_t format = VALUE_OR_RETURN(

            aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));

    const audio_channel_mask_t channel_mask = VALUE_OR_RETURN(

            aidl2legacy_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

    const size_t frame_count = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));

    const size_t frame_count_hal = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));

    const uint32_t latency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));
@@ -1990,8 +1983,8 @@ ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIo 
    aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getSamplingRate()));

    aidl.format = VALUE_OR_RETURN(

            legacy2aidl_audio_format_t_AudioFormatDescription(legacy->getFormat()));

    aidl.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy->getChannelMask()));

    aidl.channelMask = VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(

                    legacy->getChannelMask(), legacy->getIsInput()));

    aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->getFrameCount()));

    aidl.frameCountHAL = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy->getFrameCountHAL()));

    aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getLatency()));
@@ -2294,7 +2287,7 @@ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const media::AudioOffloadInfo& 
    legacy.version = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.version));

    legacy.size = sizeof(audio_offload_info_t);

    audio_config_base_t config = VALUE_OR_RETURN(

            aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config));

            aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config, false /*isInput*/));

    legacy.sample_rate = config.sample_rate;

    legacy.channel_mask = config.channel_mask;

    legacy.format = config.format;
@@ -2323,8 +2316,8 @@ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& le 
    }

    aidl.version = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.version));

    aidl.config.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));

    aidl.config.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy.channel_mask));

    aidl.config.channelMask = VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(

                    legacy.channel_mask, false /*isInput*/));

    aidl.config.format = VALUE_OR_RETURN(

            legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));

    aidl.streamType = VALUE_OR_RETURN(
@@ -2353,11 +2346,11 @@ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& le 
}



ConversionResult<audio_config_t>

aidl2legacy_AudioConfig_audio_config_t(const media::AudioConfig& aidl) {

aidl2legacy_AudioConfig_audio_config_t(const media::AudioConfig& aidl, bool isInput) {

    audio_config_t legacy;

    legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));

    legacy.channel_mask = VALUE_OR_RETURN(

            aidl2legacy_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

    legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));

    legacy.offload_info = VALUE_OR_RETURN(

            aidl2legacy_AudioOffloadInfo_audio_offload_info_t(aidl.offloadInfo));
@@ -2366,11 +2359,11 @@ aidl2legacy_AudioConfig_audio_config_t(const media::AudioConfig& aidl) { 
}



ConversionResult<media::AudioConfig>

legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy) {

legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInput) {

    media::AudioConfig aidl;

    aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));

    aidl.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy.channel_mask));

            legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));

    aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));

    aidl.offloadInfo = VALUE_OR_RETURN(

            legacy2aidl_audio_offload_info_t_AudioOffloadInfo(legacy.offload_info));
@@ -2379,21 +2372,21 @@ legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy) { 
}



ConversionResult<audio_config_base_t>

aidl2legacy_AudioConfigBase_audio_config_base_t(const media::AudioConfigBase& aidl) {

aidl2legacy_AudioConfigBase_audio_config_base_t(const media::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_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

    legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));

    return legacy;

}



ConversionResult<media::AudioConfigBase>

legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy) {

legacy2aidl_audio_config_base_t_AudioConfigBase(const audio_config_base_t& legacy, bool isInput) {

    media::AudioConfigBase aidl;

    aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.sample_rate));

    aidl.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy.channel_mask));

            legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy.channel_mask, isInput));

    aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));

    return aidl;

}
@@ -2723,7 +2716,7 @@ ConversionResult<media::AudioPortExt> legacy2aidl_AudioPortExt( 
}



ConversionResult<audio_profile>

aidl2legacy_AudioProfile_audio_profile(const media::AudioProfile& aidl) {

aidl2legacy_AudioProfile_audio_profile(const media::AudioProfile& aidl, bool isInput) {

    audio_profile legacy;

    legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
@@ -2740,7 +2733,9 @@ aidl2legacy_AudioProfile_audio_profile(const media::AudioProfile& aidl) { 
    }

    RETURN_IF_ERROR(

            convertRange(aidl.channelMasks.begin(), aidl.channelMasks.end(), legacy.channel_masks,

                         aidl2legacy_AudioChannelMask_audio_channel_mask_t));

                    [isInput](const media::AudioChannelLayout& l) {

                        return aidl2legacy_AudioChannelLayout_audio_channel_mask_t(l, isInput);

                    }));

    legacy.num_channel_masks = aidl.channelMasks.size();



    legacy.encapsulation_type = VALUE_OR_RETURN(
@@ -2749,7 +2744,7 @@ aidl2legacy_AudioProfile_audio_profile(const media::AudioProfile& aidl) { 
}



ConversionResult<media::AudioProfile>

legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy) {

legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy, bool isInput) {

    media::AudioProfile aidl;

    aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(legacy.format));
@@ -2767,7 +2762,9 @@ legacy2aidl_audio_profile_AudioProfile(const audio_profile& legacy) { 
    RETURN_IF_ERROR(

            convertRange(legacy.channel_masks, legacy.channel_masks + legacy.num_channel_masks,

                         std::back_inserter(aidl.channelMasks),

                         legacy2aidl_audio_channel_mask_t_AudioChannelMask));

                    [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(
@@ -2779,8 +2776,8 @@ ConversionResult<audio_gain> 
aidl2legacy_AudioGain_audio_gain(const media::AudioGain& aidl) {

    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_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

    legacy.channel_mask = VALUE_OR_RETURN(aidl2legacy_AudioChannelLayout_audio_channel_mask_t(

                    aidl.channelMask, aidl.useInChannelMask));

    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));
@@ -2791,11 +2788,12 @@ aidl2legacy_AudioGain_audio_gain(const media::AudioGain& aidl) { 
}



ConversionResult<media::AudioGain>

legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy) {

legacy2aidl_audio_gain_AudioGain(const audio_gain& legacy, bool isInput) {

    media::AudioGain aidl;

    aidl.mode = VALUE_OR_RETURN(legacy2aidl_audio_gain_mode_t_int32_t_mask(legacy.mode));

    aidl.useInChannelMask = isInput;

    aidl.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy.channel_mask));

            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));
@@ -2816,8 +2814,11 @@ aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) { 
    if (aidl.profiles.size() > std::size(legacy.audio_profiles)) {

        return unexpected(BAD_VALUE);

    }

    const bool isInput = VALUE_OR_RETURN(direction(aidl.role, aidl.type)) == Direction::INPUT;

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

                                 aidl2legacy_AudioProfile_audio_profile));

                                 [isInput](const media::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)) {
@@ -2853,10 +2854,13 @@ legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) { 
    if (legacy.num_audio_profiles > std::size(legacy.audio_profiles)) {

        return unexpected(BAD_VALUE);

    }

    const bool isInput = VALUE_OR_RETURN(direction(legacy.role, legacy.type)) == Direction::INPUT;

    RETURN_IF_ERROR(

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

                         std::back_inserter(aidl.profiles),

                         legacy2aidl_audio_profile_AudioProfile));

                         [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);
@@ -2873,7 +2877,9 @@ legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) { 
    RETURN_IF_ERROR(

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

                         std::back_inserter(aidl.gains),

                         legacy2aidl_audio_gain_AudioGain));

                         [isInput](const audio_gain& g) {

                             return legacy2aidl_audio_gain_AudioGain(g, isInput);

                         }));



    aidl.activeConfig = VALUE_OR_RETURN(

            legacy2aidl_audio_port_config_AudioPortConfig(legacy.active_config));

media/libaudioclient/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -304,7 +304,6 @@ aidl_interface { 
    srcs: [

        "aidl/android/media/AudioAttributesInternal.aidl",

        "aidl/android/media/AudioChannelLayout.aidl",

        "aidl/android/media/AudioChannelMask.aidl",

        "aidl/android/media/AudioClient.aidl",

        "aidl/android/media/AudioConfig.aidl",

        "aidl/android/media/AudioConfigBase.aidl",

media/libaudioclient/AudioSystem.cpp

+4 −4
Original line number Diff line number Diff line
@@ -1003,7 +1003,7 @@ status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr, 
            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));

    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));

    media::AudioConfig configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_config_t_AudioConfig(*config));

            legacy2aidl_audio_config_t_AudioConfig(*config, false /*isInput*/));

    int32_t flagsAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_output_flags_t_int32_t_mask(flags));

    int32_t selectedDeviceIdAidl = VALUE_OR_RETURN_STATUS(
@@ -1097,7 +1097,7 @@ status_t AudioSystem::getInputForAttr(const audio_attributes_t* attr, 
    int32_t riidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(riid));

    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));

    media::AudioConfigBase configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_config_base_t_AudioConfigBase(*config));

            legacy2aidl_audio_config_base_t_AudioConfigBase(*config, true /*isInput*/));

    int32_t flagsAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));

    int32_t selectedDeviceIdAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_handle_t_int32_t(*selectedDeviceId));
@@ -2431,13 +2431,13 @@ Status AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate( 
        record_client_info_t clientInfoLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_RecordClientInfo_record_client_info_t(clientInfo));

        audio_config_base_t clientConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_AudioConfigBase_audio_config_base_t(clientConfig));

                aidl2legacy_AudioConfigBase_audio_config_base_t(clientConfig, true /*isInput*/));

        std::vector<effect_descriptor_t> clientEffectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                convertContainer<std::vector<effect_descriptor_t>>(

                        clientEffects,

                        aidl2legacy_EffectDescriptor_effect_descriptor_t));

        audio_config_base_t deviceConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_AudioConfigBase_audio_config_base_t(deviceConfig));

                aidl2legacy_AudioConfigBase_audio_config_base_t(deviceConfig, true /*isInput*/));

        std::vector<effect_descriptor_t> effectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                convertContainer<std::vector<effect_descriptor_t>>(

                        effects,

media/libaudioclient/AudioTrack.cpp

+1 −1
Original line number Diff line number Diff line
@@ -171,7 +171,7 @@ bool AudioTrack::isDirectOutputSupported(const audio_config_base_t& config, 


    auto result = [&]() -> ConversionResult<bool> {

        media::AudioConfigBase configAidl = VALUE_OR_RETURN(

                legacy2aidl_audio_config_base_t_AudioConfigBase(config));

                legacy2aidl_audio_config_base_t_AudioConfigBase(config, false /*isInput*/));

        media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN(

                legacy2aidl_audio_attributes_t_AudioAttributesInternal(attributes));

        bool retAidl;

media/libaudioclient/IAudioFlinger.cpp

+14 −8
Original line number Diff line number Diff line
@@ -55,7 +55,9 @@ using binder::Status; 
ConversionResult<media::CreateTrackRequest> IAudioFlinger::CreateTrackInput::toAidl() const {

    media::CreateTrackRequest aidl;

    aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));

    aidl.config = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(config));

    // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.

    aidl.config = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(

                    config, false /*isInput*/));

    aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));

    aidl.sharedBuffer = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(sharedBuffer));

    aidl.notificationsPerBuffer = VALUE_OR_RETURN(convertIntegral<int32_t>(notificationsPerBuffer));
@@ -74,7 +76,9 @@ ConversionResult<IAudioFlinger::CreateTrackInput> 
IAudioFlinger::CreateTrackInput::fromAidl(const media::CreateTrackRequest& aidl) {

    IAudioFlinger::CreateTrackInput legacy;

    legacy.attr = VALUE_OR_RETURN(aidl2legacy_AudioAttributesInternal_audio_attributes_t(aidl.attr));

    legacy.config = VALUE_OR_RETURN(aidl2legacy_AudioConfig_audio_config_t(aidl.config));

    // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.

    legacy.config = VALUE_OR_RETURN(

            aidl2legacy_AudioConfig_audio_config_t(aidl.config, false /*isInput*/));

    legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));

    legacy.sharedBuffer = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.sharedBuffer));

    legacy.notificationsPerBuffer = VALUE_OR_RETURN(
@@ -139,7 +143,8 @@ ConversionResult<media::CreateRecordRequest> 
IAudioFlinger::CreateRecordInput::toAidl() const {

    media::CreateRecordRequest aidl;

    aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));

    aidl.config = VALUE_OR_RETURN(legacy2aidl_audio_config_base_t_AudioConfigBase(config));

    aidl.config = VALUE_OR_RETURN(

            legacy2aidl_audio_config_base_t_AudioConfigBase(config, true /*isInput*/));

    aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));

    aidl.riid = VALUE_OR_RETURN(legacy2aidl_audio_unique_id_t_int32_t(riid));

    aidl.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
@@ -159,7 +164,8 @@ IAudioFlinger::CreateRecordInput::fromAidl( 
    IAudioFlinger::CreateRecordInput legacy;

    legacy.attr = VALUE_OR_RETURN(

            aidl2legacy_AudioAttributesInternal_audio_attributes_t(aidl.attr));

    legacy.config = VALUE_OR_RETURN(aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config));

    legacy.config = VALUE_OR_RETURN(

            aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config, true /*isInput*/));

    legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));

    legacy.riid = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_unique_id_t(aidl.riid));

    legacy.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
@@ -412,8 +418,8 @@ size_t AudioFlingerClientAdapter::getInputBufferSize(uint32_t sampleRate, audio_ 
        int32_t sampleRateAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));

        media::AudioFormatDescription formatAidl = VALUE_OR_RETURN(

                legacy2aidl_audio_format_t_AudioFormatDescription(format));

        media::AudioChannelMask channelMaskAidl = VALUE_OR_RETURN(

                legacy2aidl_audio_channel_mask_t_AudioChannelMask(channelMask));

        media::AudioChannelLayout channelMaskAidl = VALUE_OR_RETURN(

                legacy2aidl_audio_channel_mask_t_AudioChannelLayout(channelMask, true /*isInput*/));

        int64_t aidlRet;

        RETURN_IF_ERROR(statusTFromBinderStatus(

                mDelegate->getInputBufferSize(sampleRateAidl, formatAidl, channelMaskAidl,
@@ -939,13 +945,13 @@ Status AudioFlingerServerAdapter::registerClient(const sp<media::IAudioFlingerCl 


Status AudioFlingerServerAdapter::getInputBufferSize(int32_t sampleRate,

                                                     const media::AudioFormatDescription& format,

                                                     media::AudioChannelMask channelMask,

                                                     const media::AudioChannelLayout& channelMask,

                                                     int64_t* _aidl_return) {

    uint32_t sampleRateLegacy = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(sampleRate));

    audio_format_t formatLegacy = VALUE_OR_RETURN_BINDER(

            aidl2legacy_AudioFormatDescription_audio_format_t(format));

    audio_channel_mask_t channelMaskLegacy = VALUE_OR_RETURN_BINDER(

            aidl2legacy_AudioChannelMask_audio_channel_mask_t(channelMask));

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(channelMask, true /*isInput*/));

    size_t size = mDelegate->getInputBufferSize(sampleRateLegacy, formatLegacy, channelMaskLegacy);

    *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int64_t>(size));

    return Status::ok();