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

Commit d5e61bcf authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes Ie59cdd64,I35e5c83b 

* changes:
  Switch the framework AIDL to use AudioChannelLayout
  Refactor AudioIoDescriptor
parents 643db4b8 9dec7011

media/libaudioclient/AidlConversion.cpp

+81 −70
Original line number Diff line number Diff line
@@ -279,17 +279,7 @@ 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> aidl2legacy_AudioIoConfigEvent_audio_io_config_event(

ConversionResult<audio_io_config_event_t> aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(

        media::AudioIoConfigEvent aidl) {

    switch (aidl) {

        case media::AudioIoConfigEvent::OUTPUT_REGISTERED:
@@ -314,8 +304,8 @@ ConversionResult<audio_io_config_event> aidl2legacy_AudioIoConfigEvent_audio_io_ 
    return unexpected(BAD_VALUE);

}



ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_AudioIoConfigEvent(

        audio_io_config_event legacy) {

ConversionResult<media::AudioIoConfigEvent> legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(

        audio_io_config_event_t legacy) {

    switch (legacy) {

        case AUDIO_OUTPUT_REGISTERED:

            return media::AudioIoConfigEvent::OUTPUT_REGISTERED;
@@ -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(
@@ -1962,35 +1955,40 @@ ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch( 


ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(

        const media::AudioIoDescriptor& aidl) {

    sp<AudioIoDescriptor> legacy(new AudioIoDescriptor());

    legacy->mIoHandle = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));

    legacy->mPatch = VALUE_OR_RETURN(aidl2legacy_AudioPatch_audio_patch(aidl.patch));

    legacy->mSamplingRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));

    legacy->mFormat = VALUE_OR_RETURN(

    const audio_io_handle_t io_handle = VALUE_OR_RETURN(

            aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));

    const struct audio_patch patch = VALUE_OR_RETURN(

            aidl2legacy_AudioPatch_audio_patch(aidl.patch));

    const bool isInput = aidl.isInput;

    const uint32_t sampling_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));

    const audio_format_t format = VALUE_OR_RETURN(

            aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));

    legacy->mChannelMask =

            VALUE_OR_RETURN(aidl2legacy_AudioChannelMask_audio_channel_mask_t(aidl.channelMask));

    legacy->mFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));

    legacy->mFrameCountHAL = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCountHAL));

    legacy->mLatency = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.latency));

    legacy->mPortId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));

    return legacy;

    const audio_channel_mask_t channel_mask = VALUE_OR_RETURN(

            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));

    const audio_port_handle_t port_id = VALUE_OR_RETURN(

            aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));

    return sp<AudioIoDescriptor>::make(io_handle, patch, isInput, sampling_rate, format,

            channel_mask, frame_count, frame_count_hal, latency, port_id);

}



ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(

        const sp<AudioIoDescriptor>& legacy) {

    media::AudioIoDescriptor aidl;

    aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->mIoHandle));

    aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->mPatch));

    aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mSamplingRate));

    aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->getIoHandle()));

    aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->getPatch()));

    aidl.isInput = legacy->getIsInput();

    aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getSamplingRate()));

    aidl.format = VALUE_OR_RETURN(

            legacy2aidl_audio_format_t_AudioFormatDescription(legacy->mFormat));

    aidl.channelMask = VALUE_OR_RETURN(

            legacy2aidl_audio_channel_mask_t_AudioChannelMask(legacy->mChannelMask));

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

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

    aidl.latency = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->mLatency));

    aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy->mPortId));

            legacy2aidl_audio_format_t_AudioFormatDescription(legacy->getFormat()));

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

    aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy->getPortId()));

    return aidl;

}
@@ -2289,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;
@@ -2318,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(
@@ -2348,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));
@@ -2361,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));
@@ -2374,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;

}
@@ -2718,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));
@@ -2735,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(
@@ -2744,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));
@@ -2762,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(
@@ -2774,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));
@@ -2786,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));
@@ -2811,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)) {
@@ -2848,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);
@@ -2868,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

+38 −43

File changed.

Preview size limit exceeded, changes collapsed.

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