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

Commit 08c7d9e6 authored by Ytai Ben-Tsvi's avatar Ytai Ben-Tsvi
Browse files

Small changes around AIDL conversion code 

- Extract enum handling to the generic utilities (for use by a later
  commit).
- Small renaming and formatting changes.
- Removal of an unnecessary header dependency.

Test: Audio tests from CtsMediaTests
Change-Id: I598a85bf1081874ac04aab3f37fe757231e8837d
parent 868ec838

media/libaudioclient/AidlConversion.cpp

+29 −109
Original line number Diff line number Diff line
@@ -31,86 +31,6 @@ using base::unexpected; 


namespace {



////////////////////////////////////////////////////////////////////////////////////////////////////

// The code below establishes:

// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or

// enum types (in which case it evaluates to std::underlying_type_T<T>).



template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>

struct IntegralTypeOfStruct {

    using Type = T;

};



template<typename T>

struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {

    using Type = std::underlying_type_t<T>;

};



template<typename T>

using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;



////////////////////////////////////////////////////////////////////////////////////////////////////

// Utilities for handling bitmasks.



template<typename Enum>

Enum index2enum_index(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(index);

}



template<typename Enum>

Enum index2enum_bitmask(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(1 << index);

}



template<typename Mask, typename Enum>

Mask enumToMask_bitmask(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(e);

}



template<typename Mask, typename Enum>

Mask enumToMask_index(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)

            << static_cast<int>(e));

}



template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>

ConversionResult<DestMask> convertBitmask(

        SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,

        const std::function<SrcEnum(int)>& srcIndexToEnum,

        const std::function<DestMask(DestEnum)>& destEnumToMask) {

    using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;

    using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;



    UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);

    UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);



    int srcBitIndex = 0;

    while (usrc != 0) {

        if (usrc & 1) {

            SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);

            DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));

            DestMask destMask = destEnumToMask(destEnum);

            dest |= destMask;

        }

        ++srcBitIndex;

        usrc >>= 1;

    }

    return static_cast<DestMask>(dest);

}



template<typename Mask, typename Enum>

bool bitmaskIsSet(Mask mask, Enum index) {

    return (mask & enumToMask_index<Mask, Enum>(index)) != 0;

}



////////////////////////////////////////////////////////////////////////////////////////////////////



enum class Direction {

    INPUT, OUTPUT

};
@@ -318,7 +238,7 @@ ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl) { 
    return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(

            aidl, aidl2legacy_AudioPortConfigType_int32_t,

            // AudioPortConfigType enum is index-based.

            index2enum_index<media::AudioPortConfigType>,

            indexToEnum_index<media::AudioPortConfigType>,

            // AUDIO_PORT_CONFIG_* flags are mask-based.

            enumToMask_bitmask<unsigned int, int>);

}
@@ -327,7 +247,7 @@ ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) { 
    return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(

            legacy, legacy2aidl_int32_t_AudioPortConfigType,

            // AUDIO_PORT_CONFIG_* flags are mask-based.

            index2enum_bitmask<unsigned>,

            indexToEnum_bitmask<unsigned>,

            // AudioPortConfigType enum is index-based.

            enumToMask_index<int32_t, media::AudioPortConfigType>);

}
@@ -494,7 +414,7 @@ ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(i 
    return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, media::AudioGainMode>(

            aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,

            // AudioGainMode is index-based.

            index2enum_index<media::AudioGainMode>,

            indexToEnum_index<media::AudioGainMode>,

            // AUDIO_GAIN_MODE_* constants are mask-based.

            enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);

}
@@ -503,7 +423,7 @@ ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_ 
    return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, audio_gain_mode_t>(

            legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,

            // AUDIO_GAIN_MODE_* constants are mask-based.

            index2enum_bitmask<audio_gain_mode_t>,

            indexToEnum_bitmask<audio_gain_mode_t>,

            // AudioGainMode is index-based.

            enumToMask_index<int32_t, media::AudioGainMode>);

}
@@ -695,7 +615,7 @@ ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_ma 
    LegacyMask converted = VALUE_OR_RETURN(

            (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(

                    aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,

                    index2enum_index<media::AudioInputFlags>,

                    indexToEnum_index<media::AudioInputFlags>,

                    enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));

    return static_cast<audio_input_flags_t>(converted);

}
@@ -707,7 +627,7 @@ ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask( 
    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(

            legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,

            index2enum_bitmask<audio_input_flags_t>,

            indexToEnum_bitmask<audio_input_flags_t>,

            enumToMask_index<int32_t, media::AudioInputFlags>);

}
@@ -718,7 +638,7 @@ ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_ 
            audio_output_flags_t,

            media::AudioOutputFlags>(

            aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,

            index2enum_index<media::AudioOutputFlags>,

            indexToEnum_index<media::AudioOutputFlags>,

            enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);

}
@@ -729,7 +649,7 @@ ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask( 
    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(

            legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,

            index2enum_bitmask<audio_output_flags_t>,

            indexToEnum_bitmask<audio_output_flags_t>,

            enumToMask_index<int32_t, media::AudioOutputFlags>);

}
@@ -1468,7 +1388,7 @@ legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy) { 
ConversionResult<audio_flags_mask_t>

aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {

    return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(

            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, index2enum_index<media::AudioFlag>,

            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, indexToEnum_index<media::AudioFlag>,

            enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);

}
@@ -1476,7 +1396,7 @@ ConversionResult<int32_t> 
legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {

    return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(

            legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,

            index2enum_bitmask<audio_flags_mask_t>,

            indexToEnum_bitmask<audio_flags_mask_t>,

            enumToMask_index<int32_t, media::AudioFlag>);

}
@@ -1783,7 +1703,7 @@ aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) { 
            audio_encapsulation_mode_t,

            media::AudioEncapsulationMode>(

            aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,

            index2enum_index<media::AudioEncapsulationMode>,

            indexToEnum_index<media::AudioEncapsulationMode>,

            enumToMask_index<uint32_t, audio_encapsulation_mode_t>);

}
@@ -1794,7 +1714,7 @@ legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) { 
            media::AudioEncapsulationMode,

            audio_encapsulation_mode_t>(

            legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,

            index2enum_index<audio_encapsulation_mode_t>,

            indexToEnum_index<audio_encapsulation_mode_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMode>);

}
@@ -1805,7 +1725,7 @@ aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) { 
            audio_encapsulation_metadata_type_t,

            media::AudioEncapsulationMetadataType>(

            aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,

            index2enum_index<media::AudioEncapsulationMetadataType>,

            indexToEnum_index<media::AudioEncapsulationMetadataType>,

            enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);

}
@@ -1816,7 +1736,7 @@ legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) { 
            media::AudioEncapsulationMetadataType,

            audio_encapsulation_metadata_type_t>(

            legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,

            index2enum_index<audio_encapsulation_metadata_type_t>,

            indexToEnum_index<audio_encapsulation_metadata_type_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMetadataType>);

}

media/libaudioclient/include/media/AidlConversionUtil.h

+79 −0
Original line number Diff line number Diff line
@@ -110,6 +110,84 @@ convertContainer(const InputContainer& input, const Func& itemConversion) { 
    return output;

}



////////////////////////////////////////////////////////////////////////////////////////////////////

// The code below establishes:

// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or

// enum types (in which case it evaluates to std::underlying_type_T<T>).



template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>

struct IntegralTypeOfStruct {

    using Type = T;

};



template<typename T>

struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {

    using Type = std::underlying_type_t<T>;

};



template<typename T>

using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;



////////////////////////////////////////////////////////////////////////////////////////////////////

// Utilities for handling bitmasks.



template<typename Enum>

Enum indexToEnum_index(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(index);

}



template<typename Enum>

Enum indexToEnum_bitmask(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(1 << index);

}



template<typename Mask, typename Enum>

Mask enumToMask_bitmask(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(e);

}



template<typename Mask, typename Enum>

Mask enumToMask_index(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)

            << static_cast<int>(e));

}



template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>

ConversionResult<DestMask> convertBitmask(

        SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,

        const std::function<SrcEnum(int)>& srcIndexToEnum,

        const std::function<DestMask(DestEnum)>& destEnumToMask) {

    using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;

    using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;



    UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);

    UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);



    int srcBitIndex = 0;

    while (usrc != 0) {

        if (usrc & 1) {

            SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);

            DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));

            DestMask destMask = destEnumToMask(destEnum);

            dest |= destMask;

        }

        ++srcBitIndex;

        usrc >>= 1;

    }

    return static_cast<DestMask>(dest);

}



template<typename Mask, typename Enum>

bool bitmaskIsSet(Mask mask, Enum index) {

    return (mask & enumToMask_index<Mask, Enum>(index)) != 0;

}



////////////////////////////////////////////////////////////////////////////////////////////////////

// Utilities for working with AIDL unions.

// UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
@@ -225,6 +303,7 @@ static inline ::android::binder::Status binderStatusFromStatusT( 
    return Status::fromServiceSpecificError(status, emptyIfNull);

}





} // namespace aidl_utils



}  // namespace android

media/libaudiofoundation/AudioDeviceTypeAddr.cpp

+2 −1
Original line number Diff line number Diff line
@@ -15,13 +15,14 @@ 
 */



#include <media/AudioDeviceTypeAddr.h>



#include <arpa/inet.h>

#include <iostream>

#include <regex>

#include <set>

#include <sstream>



#include <media/AidlConversion.h>



namespace android {



namespace {

media/libaudiofoundation/include/media/AudioDeviceTypeAddr.h

+1 −1
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ 
#include <binder/Parcelable.h>

#include <binder/Parcel.h>

#include <media/AudioContainers.h>

#include <media/AidlConversion.h>

#include <media/AidlConversionUtil.h>

#include <system/audio.h>

#include <utils/Errors.h>