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

Commit 5359f835 authored by Ytai Ben-tsvi's avatar Ytai Ben-tsvi Committed by Android (Google) Code Review
Browse files

Merge changes from topic "aidlize-audioflinger2" 

* changes:
  Break-up libaudioclient_aidl_conversion
  Add missing header dependencies
  Prepare openOutput() signature to AIDL conversion
  Extract VALUE_OR_RETURN_STATUS to AidlConversion
  Disambiguate types
  Add some missing @hide annotations
  Prepare openInput() signature to AIDL conversion
  AIDLize createEffect params
  Include the returned IAudio{Track,Record} in response parcelable
  Make IAudioRecord pure (stable) AIDL
  Convert IAudioTrack to AIDL
parents 10d525e7 643783e4

Android.bp

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

        "aidl/android/media/InterpolatorConfig.aidl",

        "aidl/android/media/InterpolatorType.aidl",

        "aidl/android/media/MicrophoneInfoData.aidl",

        "aidl/android/media/VolumeShaperConfiguration.aidl",

        "aidl/android/media/VolumeShaperConfigurationOptionFlag.aidl",

        "aidl/android/media/VolumeShaperConfigurationType.aidl",
@@ -20,8 +21,37 @@ aidl_interface { 
            min_sdk_version: "29",

            apex_available: [

                "//apex_available:platform",

                "com.android.bluetooth.updatable",

                "com.android.media",

                "com.android.media.swcodec",

            ],

        },

    },

}



cc_library_headers {

    name: "av-headers",

    export_include_dirs: ["include"],

    static_libs: [

        "av-types-aidl-unstable-cpp",

    ],

    export_static_lib_headers: [

        "av-types-aidl-unstable-cpp",

    ],

    header_libs: [

        "libaudioclient_aidl_conversion_util",

    ],

    export_header_lib_headers: [

        "libaudioclient_aidl_conversion_util",

    ],

    host_supported: true,

    vendor_available: true,

    double_loadable: true,

    min_sdk_version: "29",

    apex_available: [

        "//apex_available:platform",

        "com.android.bluetooth.updatable",

        "com.android.media",

        "com.android.media.swcodec",

    ],

}

aidl/android/media/MicrophoneInfoData.aidl

0 → 100644
+39 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.media;



/**

 * {@hide}

 */

parcelable MicrophoneInfoData {

    @utf8InCpp String deviceId;

    int portId;

    int type;

    @utf8InCpp String address;

    int deviceLocation;

    int deviceGroup;

    int indexInTheGroup;

    float[] geometricLocation;

    float[] orientation;

    float[] frequencies;

    float[] frequencyResponses;

    int[] channelMapping;

    float sensitivity;

    float maxSpl;

    float minSpl;

    int directionality;

}

include/media/MicrophoneInfo.h

+68 −103
Original line number Diff line number Diff line
@@ -17,33 +17,24 @@ 
#ifndef ANDROID_MICROPHONE_INFO_H

#define ANDROID_MICROPHONE_INFO_H



#include <android/media/MicrophoneInfoData.h>

#include <binder/Parcel.h>

#include <binder/Parcelable.h>

#include <media/AidlConversionUtil.h>

#include <system/audio.h>

#include <utils/String16.h>

#include <utils/Vector.h>



namespace android {

namespace media {



#define RETURN_IF_FAILED(calledOnce)                                     \

    {                                                                    \

        status_t returnStatus = calledOnce;                              \

        if (returnStatus) {                                              \

            ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \

            return returnStatus;                                         \

         }                                                               \

    }



class MicrophoneInfo : public Parcelable {

public:

    MicrophoneInfo() = default;

    MicrophoneInfo(const MicrophoneInfo& microphoneInfo) = default;

    MicrophoneInfo(audio_microphone_characteristic_t& characteristic) {

        mDeviceId = String16(&characteristic.device_id[0]);

        mDeviceId = std::string(&characteristic.device_id[0]);

        mPortId = characteristic.id;

        mType = characteristic.device;

        mAddress = String16(&characteristic.address[0]);

        mAddress = std::string(&characteristic.address[0]);

        mDeviceLocation = characteristic.location;

        mDeviceGroup = characteristic.group;

        mIndexInTheGroup = characteristic.index_in_the_group;
@@ -53,8 +44,8 @@ public: 
        mOrientation.push_back(characteristic.orientation.x);

        mOrientation.push_back(characteristic.orientation.y);

        mOrientation.push_back(characteristic.orientation.z);

        Vector<float> frequencies;

        Vector<float> responses;

        std::vector<float> frequencies;

        std::vector<float> responses;

        for (size_t i = 0; i < characteristic.num_frequency_responses; i++) {

            frequencies.push_back(characteristic.frequency_responses[0][i]);

            responses.push_back(characteristic.frequency_responses[1][i]);
@@ -73,76 +64,73 @@ public: 
    virtual ~MicrophoneInfo() = default;



    virtual status_t writeToParcel(Parcel* parcel) const {

        RETURN_IF_FAILED(parcel->writeString16(mDeviceId));

        RETURN_IF_FAILED(parcel->writeInt32(mPortId));

        RETURN_IF_FAILED(parcel->writeUint32(mType));

        RETURN_IF_FAILED(parcel->writeString16(mAddress));

        RETURN_IF_FAILED(parcel->writeInt32(mDeviceLocation));

        RETURN_IF_FAILED(parcel->writeInt32(mDeviceGroup));

        RETURN_IF_FAILED(parcel->writeInt32(mIndexInTheGroup));

        RETURN_IF_FAILED(writeFloatVector(parcel, mGeometricLocation));

        RETURN_IF_FAILED(writeFloatVector(parcel, mOrientation));

        MicrophoneInfoData parcelable;

        return writeToParcelable(&parcelable)

               ?: parcelable.writeToParcel(parcel);

    }



    virtual status_t writeToParcelable(MicrophoneInfoData* parcelable) const {

        parcelable->deviceId = mDeviceId;

        parcelable->portId = mPortId;

        parcelable->type = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(mType));

        parcelable->address = mAddress;

        parcelable->deviceGroup = mDeviceGroup;

        parcelable->indexInTheGroup = mIndexInTheGroup;

        parcelable->geometricLocation = mGeometricLocation;

        parcelable->orientation = mOrientation;

        if (mFrequencyResponses.size() != 2) {

            return BAD_VALUE;

        }

        for (size_t i = 0; i < mFrequencyResponses.size(); i++) {

            RETURN_IF_FAILED(parcel->writeInt32(mFrequencyResponses[i].size()));

            RETURN_IF_FAILED(writeFloatVector(parcel, mFrequencyResponses[i]));

        }

        std::vector<int> channelMapping;

        for (size_t i = 0; i < mChannelMapping.size(); ++i) {

            channelMapping.push_back(mChannelMapping[i]);

        }

        RETURN_IF_FAILED(parcel->writeInt32Vector(channelMapping));

        RETURN_IF_FAILED(parcel->writeFloat(mSensitivity));

        RETURN_IF_FAILED(parcel->writeFloat(mMaxSpl));

        RETURN_IF_FAILED(parcel->writeFloat(mMinSpl));

        RETURN_IF_FAILED(parcel->writeInt32(mDirectionality));

        parcelable->frequencies = mFrequencyResponses[0];

        parcelable->frequencyResponses = mFrequencyResponses[1];

        parcelable->channelMapping = mChannelMapping;

        parcelable->sensitivity = mSensitivity;

        parcelable->maxSpl = mMaxSpl;

        parcelable->minSpl = mMinSpl;

        parcelable->directionality = mDirectionality;

        return OK;

    }



    virtual status_t readFromParcel(const Parcel* parcel) {

        RETURN_IF_FAILED(parcel->readString16(&mDeviceId));

        RETURN_IF_FAILED(parcel->readInt32(&mPortId));

        RETURN_IF_FAILED(parcel->readUint32(&mType));

        RETURN_IF_FAILED(parcel->readString16(&mAddress));

        RETURN_IF_FAILED(parcel->readInt32(&mDeviceLocation));

        RETURN_IF_FAILED(parcel->readInt32(&mDeviceGroup));

        RETURN_IF_FAILED(parcel->readInt32(&mIndexInTheGroup));

        RETURN_IF_FAILED(readFloatVector(parcel, &mGeometricLocation, 3));

        RETURN_IF_FAILED(readFloatVector(parcel, &mOrientation, 3));

        int32_t frequenciesNum;

        RETURN_IF_FAILED(parcel->readInt32(&frequenciesNum));

        Vector<float> frequencies;

        RETURN_IF_FAILED(readFloatVector(parcel, &frequencies, frequenciesNum));

        int32_t responsesNum;

        RETURN_IF_FAILED(parcel->readInt32(&responsesNum));

        Vector<float> responses;

        RETURN_IF_FAILED(readFloatVector(parcel, &responses, responsesNum));

        if (frequencies.size() != responses.size()) {

        MicrophoneInfoData data;

        return data.readFromParcel(parcel)

            ?: readFromParcelable(data);

    }



    virtual status_t readFromParcelable(const MicrophoneInfoData& parcelable) {

        mDeviceId = parcelable.deviceId;

        mPortId = parcelable.portId;

        mType = VALUE_OR_RETURN_STATUS(convertReinterpret<uint32_t>(parcelable.type));

        mAddress = parcelable.address;

        mDeviceLocation = parcelable.deviceLocation;

        mDeviceGroup = parcelable.deviceGroup;

        mIndexInTheGroup = parcelable.indexInTheGroup;

        if (parcelable.geometricLocation.size() != 3) {

            return BAD_VALUE;

        }

        mFrequencyResponses.push_back(frequencies);

        mFrequencyResponses.push_back(responses);

        std::vector<int> channelMapping;

        status_t result = parcel->readInt32Vector(&channelMapping);

        if (result != OK) {

            return result;

        mGeometricLocation = parcelable.geometricLocation;

        if (parcelable.orientation.size() != 3) {

            return BAD_VALUE;

        }

        if (channelMapping.size() != AUDIO_CHANNEL_COUNT_MAX) {

        mOrientation = parcelable.orientation;

        if (parcelable.frequencies.size() != parcelable.frequencyResponses.size()) {

            return BAD_VALUE;

        }

        for (size_t i = 0; i < channelMapping.size(); i++) {

            mChannelMapping.push_back(channelMapping[i]);



        mFrequencyResponses.push_back(parcelable.frequencies);

        mFrequencyResponses.push_back(parcelable.frequencyResponses);

        if (parcelable.channelMapping.size() != AUDIO_CHANNEL_COUNT_MAX) {

            return BAD_VALUE;

        }

        RETURN_IF_FAILED(parcel->readFloat(&mSensitivity));

        RETURN_IF_FAILED(parcel->readFloat(&mMaxSpl));

        RETURN_IF_FAILED(parcel->readFloat(&mMinSpl));

        RETURN_IF_FAILED(parcel->readInt32(&mDirectionality));

        mChannelMapping = parcelable.channelMapping;

        mSensitivity = parcelable.sensitivity;

        mMaxSpl = parcelable.maxSpl;

        mMinSpl = parcelable.minSpl;

        mDirectionality = parcelable.directionality;

        return OK;

    }



    String16 getDeviceId() const {

    std::string getDeviceId() const {

        return mDeviceId;

    }
@@ -154,7 +142,7 @@ public: 
        return mType;

    }



    String16 getAddress() const {

    std::string getAddress() const {

        return mAddress;

    }
@@ -170,19 +158,19 @@ public: 
        return mIndexInTheGroup;

    }



    const Vector<float>& getGeometricLocation() const {

    const std::vector<float>& getGeometricLocation() const {

        return mGeometricLocation;

    }



    const Vector<float>& getOrientation() const {

    const std::vector<float>& getOrientation() const {

        return mOrientation;

    }



    const Vector<Vector<float>>& getFrequencyResponses() const {

    const std::vector<std::vector<float>>& getFrequencyResponses() const {

        return mFrequencyResponses;

    }



    const Vector<int>& getChannelMapping() const {

    const std::vector<int>& getChannelMapping() const {

        return mChannelMapping;

    }
@@ -203,40 +191,17 @@ public: 
    }



private:

    status_t readFloatVector(

            const Parcel* parcel, Vector<float> *vectorPtr, size_t defaultLength) {

        std::optional<std::vector<float>> v;

        status_t result = parcel->readFloatVector(&v);

        if (result != OK) return result;

        vectorPtr->clear();

        if (v) {

            for (const auto& iter : *v) {

                vectorPtr->push_back(iter);

            }

        } else {

            vectorPtr->resize(defaultLength);

        }

        return OK;

    }

    status_t writeFloatVector(Parcel* parcel, const Vector<float>& vector) const {

        std::vector<float> v;

        for (size_t i = 0; i < vector.size(); i++) {

            v.push_back(vector[i]);

        }

        return parcel->writeFloatVector(v);

    }



    String16 mDeviceId;

    std::string mDeviceId;

    int32_t mPortId;

    uint32_t mType;

    String16 mAddress;

    std::string mAddress;

    int32_t mDeviceLocation;

    int32_t mDeviceGroup;

    int32_t mIndexInTheGroup;

    Vector<float> mGeometricLocation;

    Vector<float> mOrientation;

    Vector<Vector<float>> mFrequencyResponses;

    Vector<int> mChannelMapping;

    std::vector<float> mGeometricLocation;

    std::vector<float> mOrientation;

    std::vector<std::vector<float>> mFrequencyResponses;

    std::vector<int> mChannelMapping;

    float mSensitivity;

    float mMaxSpl;

    float mMinSpl;

media/libaudioclient/AidlConversion.cpp

+157 −11
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 


#define LOG_TAG "AidlConversion"

//#define LOG_NDEBUG 0

#include <system/audio.h>

#include <utils/Log.h>



#include "media/AidlConversion.h"
@@ -135,12 +134,6 @@ ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) { 


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



template<typename To, typename From>

ConversionResult<To> convertReinterpret(From from) {

    static_assert(sizeof(From) == sizeof(To));

    return static_cast<To>(from);

}



enum class Direction {

    INPUT, OUTPUT

};
@@ -290,6 +283,14 @@ ConversionResult<std::string> legacy2aidl_String16_string(const String16& legacy 
    return std::string(String8(legacy).c_str());

}



ConversionResult<String8> aidl2legacy_string_view_String8(std::string_view aidl) {

    return String8(aidl.data(), aidl.size());

}



ConversionResult<std::string> legacy2aidl_String8_string(const String8& legacy) {

    return std::string(legacy.c_str());

}



// The legacy enum is unnamed. Thus, we use int.

ConversionResult<int> aidl2legacy_AudioPortConfigType(media::AudioPortConfigType aidl) {

    switch (aidl) {
@@ -1513,7 +1514,7 @@ legacy2aidl_audio_attributes_t_AudioAttributesInternal(const audio_attributes_t& 
}



ConversionResult<audio_encapsulation_mode_t>

aidl2legacy_audio_encapsulation_mode_t_AudioEncapsulationMode(media::AudioEncapsulationMode aidl) {

aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(media::AudioEncapsulationMode aidl) {

    switch (aidl) {

        case media::AudioEncapsulationMode::NONE:

            return AUDIO_ENCAPSULATION_MODE_NONE;
@@ -1526,7 +1527,7 @@ aidl2legacy_audio_encapsulation_mode_t_AudioEncapsulationMode(media::AudioEncaps 
}



ConversionResult<media::AudioEncapsulationMode>

legacy2aidl_AudioEncapsulationMode_audio_encapsulation_mode_t(audio_encapsulation_mode_t legacy) {

legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(audio_encapsulation_mode_t legacy) {

    switch (legacy) {

        case AUDIO_ENCAPSULATION_MODE_NONE:

            return media::AudioEncapsulationMode::NONE;
@@ -1558,7 +1559,7 @@ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const media::AudioOffloadInfo& 
    legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));

    legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));

    legacy.encapsulation_mode = VALUE_OR_RETURN(

            aidl2legacy_audio_encapsulation_mode_t_AudioEncapsulationMode(aidl.encapsulationMode));

            aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));

    legacy.content_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.contentId));

    legacy.sync_id = VALUE_OR_RETURN(convertReinterpret<int32_t>(aidl.syncId));

    return legacy;
@@ -1593,7 +1594,7 @@ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(const audio_offload_info_t& le 
            return unexpected(BAD_VALUE);

        }

        aidl.encapsulationMode = VALUE_OR_RETURN(

                legacy2aidl_AudioEncapsulationMode_audio_encapsulation_mode_t(

                legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode(

                        legacy.encapsulation_mode));

        aidl.contentId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.content_id));

        aidl.syncId = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.sync_id));
@@ -1683,4 +1684,149 @@ legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy) { 
    return aidl;

}



ConversionResult<AudioTimestamp>

aidl2legacy_AudioTimestamp(const media::AudioTimestampInternal& aidl) {

    AudioTimestamp legacy;

    legacy.mPosition = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.position));

    legacy.mTime.tv_sec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sec));

    legacy.mTime.tv_nsec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.nsec));

    return legacy;

}



ConversionResult<media::AudioTimestampInternal>

legacy2aidl_AudioTimestamp(const AudioTimestamp& legacy) {

    media::AudioTimestampInternal aidl;

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

    aidl.sec = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.mTime.tv_sec));

    aidl.nsec = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mTime.tv_nsec));

    return aidl;

}



ConversionResult<audio_uuid_t>

aidl2legacy_AudioUuid_audio_uuid_t(const media::AudioUuid& aidl) {

    audio_uuid_t legacy;

    legacy.timeLow = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.timeLow));

    legacy.timeMid = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeMid));

    legacy.timeHiAndVersion = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.timeHiAndVersion));

    legacy.clockSeq = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.clockSeq));

    if (aidl.node.size() != std::size(legacy.node)) {

        return unexpected(BAD_VALUE);

    }

    std::copy(aidl.node.begin(), aidl.node.end(), legacy.node);

    return legacy;

}



ConversionResult<media::AudioUuid>

legacy2aidl_audio_uuid_t_AudioUuid(const audio_uuid_t& legacy) {

    media::AudioUuid aidl;

    aidl.timeLow = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.timeLow));

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

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

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

    std::copy(legacy.node, legacy.node + std::size(legacy.node), std::back_inserter(aidl.node));

    return aidl;

}



ConversionResult<effect_descriptor_t>

aidl2legacy_EffectDescriptor_effect_descriptor_t(const media::EffectDescriptor& aidl) {

    effect_descriptor_t legacy;

    legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.type));

    legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.uuid));

    legacy.apiVersion = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.apiVersion));

    legacy.flags = VALUE_OR_RETURN(convertReinterpret<uint32_t>(aidl.flags));

    legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.cpuLoad));

    legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.memoryUsage));

    RETURN_IF_ERROR(aidl2legacy_string(aidl.name, legacy.name, sizeof(legacy.name)));

    RETURN_IF_ERROR(

            aidl2legacy_string(aidl.implementor, legacy.implementor, sizeof(legacy.implementor)));

    return legacy;

}



ConversionResult<media::EffectDescriptor>

legacy2aidl_effect_descriptor_t_EffectDescriptor(const effect_descriptor_t& legacy) {

    media::EffectDescriptor aidl;

    aidl.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));

    aidl.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));

    aidl.apiVersion = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.apiVersion));

    aidl.flags = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy.flags));

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

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

    aidl.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));

    aidl.implementor = VALUE_OR_RETURN(

            legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));

    return aidl;

}



ConversionResult<audio_encapsulation_metadata_type_t>

aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t(

        media::AudioEncapsulationMetadataType aidl) {

    switch (aidl) {

        case media::AudioEncapsulationMetadataType::NONE:

            return AUDIO_ENCAPSULATION_METADATA_TYPE_NONE;

        case media::AudioEncapsulationMetadataType::FRAMEWORK_TUNER:

            return AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER;

        case media::AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR:

            return AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<media::AudioEncapsulationMetadataType>

legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType(

        audio_encapsulation_metadata_type_t legacy) {

    switch (legacy) {

        case AUDIO_ENCAPSULATION_METADATA_TYPE_NONE:

            return media::AudioEncapsulationMetadataType::NONE;

        case AUDIO_ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER:

            return media::AudioEncapsulationMetadataType::FRAMEWORK_TUNER;

        case AUDIO_ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR:

            return media::AudioEncapsulationMetadataType::DVB_AD_DESCRIPTOR;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<uint32_t>

aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {

    return convertBitmask<uint32_t,

                          int32_t,

                          audio_encapsulation_mode_t,

                          media::AudioEncapsulationMode>(

            aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,

            index2enum_index<media::AudioEncapsulationMode>,

            enumToMask_index<uint32_t, audio_encapsulation_mode_t>);

}



ConversionResult<int32_t>

legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {

    return convertBitmask<int32_t,

                          uint32_t,

                          media::AudioEncapsulationMode,

                          audio_encapsulation_mode_t>(

            legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,

            index2enum_index<audio_encapsulation_mode_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMode>);

}



ConversionResult<uint32_t>

aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {

    return convertBitmask<uint32_t,

                          int32_t,

                          audio_encapsulation_metadata_type_t,

                          media::AudioEncapsulationMetadataType>(

            aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,

            index2enum_index<media::AudioEncapsulationMetadataType>,

            enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);

}



ConversionResult<int32_t>

legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {

    return convertBitmask<int32_t,

                          uint32_t,

                          media::AudioEncapsulationMetadataType,

                          audio_encapsulation_metadata_type_t>(

            legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,

            index2enum_index<audio_encapsulation_metadata_type_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMetadataType>);

}



}  // namespace android

media/libaudioclient/Android.bp

+66 −17

File changed.

Preview size limit exceeded, changes collapsed.