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

Commit d267aca7 authored by Shunkai Yao's avatar Shunkai Yao Committed by Automerger Merge Worker
Browse files

Merge "Add libAudioHal AIDL interface placeholder" am: ca6fd4e2 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2336690



Change-Id: Ie59b0bd34222bb901f93dc67061cde0d919f3a24
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents d53dce49 ca6fd4e2

media/audioaidlconversion/AidlConversionCppNdk.cpp

+8 −8
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ 
#include <media/stagefright/foundation/MediaDefs.h>



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

// Utilities

// AIDL CPP/NDK backend to legacy audio data structure conversion utilities.



#if defined(BACKEND_NDK)

/* AIDL String generated in NDK is different than CPP */
@@ -847,7 +847,7 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan 
            // Index masks do not have pre-defined values.

            if (const int bits = aidl.get<Tag::indexMask>();

                __builtin_popcount(bits) != 0 &&

                    __builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {

                __builtin_popcount(bits) <= (int)AUDIO_CHANNEL_COUNT_MAX) {

                return audio_channel_mask_from_representation_and_bits(

                        AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);

            } else {
@@ -1123,7 +1123,7 @@ ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_confi 
    for (size_t i = 0; i < numValues; ++i) {

        legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));

    }

    legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));

    legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<int>(aidl.rampDurationMs));

    return legacy;

}
@@ -1710,12 +1710,12 @@ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl) 
    legacy.format = base.format;

    legacy.stream_type = VALUE_OR_RETURN(

            aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));

    legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));

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

    legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));

    legacy.has_video = aidl.hasVideo;

    legacy.is_streaming = aidl.isStreaming;

    legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));

    legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));

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

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

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

    legacy.encapsulation_mode = VALUE_OR_RETURN(

            aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
@@ -1789,7 +1789,7 @@ legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInpu 
ConversionResult<audio_config_base_t>

aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {

    audio_config_base_t legacy;

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

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

    legacy.channel_mask = VALUE_OR_RETURN(

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

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

media/audioaidlconversion/AidlConversionNdk.cpp

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

 * Copyright (C) 2022 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.

 */



#include <utility>



#define LOG_TAG "AidlConversionNdk"

//#define LOG_NDEBUG 0

#include <utils/Log.h>



#include <media/AidlConversionCppNdk.h>

#include <media/AidlConversionNdk.h>



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

// AIDL NDK backend to legacy audio data structure conversion utilities.



namespace aidl {

namespace android {



using ::aidl::android::hardware::audio::effect::Descriptor;

using ::aidl::android::hardware::audio::effect::Flags;



using ::android::BAD_VALUE;

using ::android::base::unexpected;



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

// Converters



ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(Flags::Type type) {

    switch (type) {

        case Flags::Type::INSERT:

            return EFFECT_FLAG_TYPE_INSERT;

        case Flags::Type::AUXILIARY:

            return EFFECT_FLAG_TYPE_AUXILIARY;

        case Flags::Type::REPLACE:

            return EFFECT_FLAG_TYPE_REPLACE;

        case Flags::Type::PRE_PROC:

            return EFFECT_FLAG_TYPE_PRE_PROC;

        case Flags::Type::POST_PROC:

            return EFFECT_FLAG_TYPE_POST_PROC;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(Flags::Insert insert) {

    switch (insert) {

        case Flags::Insert::ANY:

            return EFFECT_FLAG_INSERT_ANY;

        case Flags::Insert::FIRST:

            return EFFECT_FLAG_INSERT_FIRST;

        case Flags::Insert::LAST:

            return EFFECT_FLAG_INSERT_LAST;

        case Flags::Insert::EXCLUSIVE:

            return EFFECT_FLAG_INSERT_EXCLUSIVE;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(Flags::Volume volume) {

    switch (volume) {

        case Flags::Volume::NONE:

            return 0;

        case Flags::Volume::CTRL:

            return EFFECT_FLAG_VOLUME_CTRL;

        case Flags::Volume::IND:

            return EFFECT_FLAG_VOLUME_IND;

        case Flags::Volume::MONITOR:

            return EFFECT_FLAG_VOLUME_MONITOR;

    }

    return unexpected(BAD_VALUE);

}

ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(

        Flags::HardwareAccelerator hwAcceleratorMode) {

    switch (hwAcceleratorMode) {

        case Flags::HardwareAccelerator::NONE:

            return 0;

        case Flags::HardwareAccelerator::SIMPLE:

            return EFFECT_FLAG_HW_ACC_SIMPLE;

        case Flags::HardwareAccelerator::TUNNEL:

            return EFFECT_FLAG_HW_ACC_TUNNEL;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<uint32_t> aidl2legacy_Flags_uint32(Flags aidl) {

    uint32_t legacy = 0;

    legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Type_uint32(aidl.type));

    legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Insert_uint32(aidl.insert));

    legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_Volume_uint32(aidl.volume));

    legacy |= VALUE_OR_RETURN(aidl2legacy_Flags_HardwareAccelerator_uint32(aidl.hwAcceleratorMode));



    if (aidl.offloadIndication) {

        legacy |= EFFECT_FLAG_OFFLOAD_SUPPORTED;

    }

    if (aidl.deviceIndication) {

        legacy |= EFFECT_FLAG_DEVICE_IND;

    }

    if (aidl.audioModeIndication) {

        legacy |= EFFECT_FLAG_AUDIO_MODE_IND;

    }

    if (aidl.audioSourceIndication) {

        legacy |= EFFECT_FLAG_AUDIO_SOURCE_IND;

    }

    if (aidl.noProcessing) {

        legacy |= EFFECT_FLAG_NO_PROCESS;

    }

    return legacy;

}



ConversionResult<Flags::Type> legacy2aidl_uint32_Flags_Type(uint32_t legacy) {

    switch (legacy & EFFECT_FLAG_TYPE_MASK) {

        case EFFECT_FLAG_TYPE_INSERT:

            return Flags::Type::INSERT;

        case EFFECT_FLAG_TYPE_AUXILIARY:

            return Flags::Type::AUXILIARY;

        case EFFECT_FLAG_TYPE_REPLACE:

            return Flags::Type::REPLACE;

        case EFFECT_FLAG_TYPE_PRE_PROC:

            return Flags::Type::PRE_PROC;

        case EFFECT_FLAG_TYPE_POST_PROC:

            return Flags::Type::POST_PROC;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<Flags::Insert> legacy2aidl_uint32_Flags_Insert(uint32_t legacy) {

    switch (legacy & EFFECT_FLAG_INSERT_MASK) {

        case EFFECT_FLAG_INSERT_ANY:

            return Flags::Insert::ANY;

        case EFFECT_FLAG_INSERT_FIRST:

            return Flags::Insert::FIRST;

        case EFFECT_FLAG_INSERT_LAST:

            return Flags::Insert::LAST;

        case EFFECT_FLAG_INSERT_EXCLUSIVE:

            return Flags::Insert::EXCLUSIVE;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<Flags::Volume> legacy2aidl_uint32_Flags_Volume(uint32_t legacy) {

    switch (legacy & EFFECT_FLAG_VOLUME_MASK) {

        case EFFECT_FLAG_VOLUME_IND:

            return Flags::Volume::IND;

        case EFFECT_FLAG_VOLUME_MONITOR:

            return Flags::Volume::MONITOR;

        case EFFECT_FLAG_VOLUME_NONE:

            return Flags::Volume::NONE;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<Flags::HardwareAccelerator> legacy2aidl_uint32_Flags_HardwareAccelerator(

        uint32_t legacy) {

    switch (legacy & EFFECT_FLAG_HW_ACC_MASK) {

        case EFFECT_FLAG_HW_ACC_SIMPLE:

            return Flags::HardwareAccelerator::SIMPLE;

        case EFFECT_FLAG_HW_ACC_TUNNEL:

            return Flags::HardwareAccelerator::TUNNEL;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<Flags> legacy2aidl_uint32_Flags(uint32_t legacy) {

    Flags aidl;



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

    aidl.insert = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Insert(legacy));

    aidl.volume = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Volume(legacy));

    aidl.hwAcceleratorMode = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_HardwareAccelerator(legacy));

    aidl.offloadIndication = (legacy & EFFECT_FLAG_OFFLOAD_SUPPORTED);

    aidl.deviceIndication = (legacy & EFFECT_FLAG_DEVICE_IND);

    aidl.audioModeIndication = (legacy & EFFECT_FLAG_AUDIO_MODE_IND);

    aidl.audioSourceIndication = (legacy & EFFECT_FLAG_AUDIO_SOURCE_IND);

    aidl.noProcessing = (legacy & EFFECT_FLAG_NO_PROCESS);

    return aidl;

}



ConversionResult<effect_descriptor_t>

aidl2legacy_Descriptor_effect_descriptor(const Descriptor& aidl) {

    effect_descriptor_t legacy;

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

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

    // legacy descriptor doesn't have proxy information

    // proxy = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.proxy));

    legacy.apiVersion = EFFECT_CONTROL_API_VERSION;

    legacy.flags = VALUE_OR_RETURN(aidl2legacy_Flags_uint32(aidl.common.flags));

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

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

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

    RETURN_IF_ERROR(aidl2legacy_string(aidl.common.implementor, legacy.implementor,

                                        sizeof(legacy.implementor)));

    return legacy;

}



ConversionResult<Descriptor>

legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& legacy) {

    Descriptor aidl;

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

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

    // legacy descriptor doesn't have proxy information

    // aidl.common.id.proxy

    aidl.common.flags = VALUE_OR_RETURN(legacy2aidl_uint32_Flags(legacy.flags));

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

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

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

    aidl.common.implementor =

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

    return aidl;

}



ConversionResult<buffer_config_t> aidl2legacy_AudioConfigBase_buffer_config_t(

        const media::audio::common::AudioConfigBase& aidl, bool isInput) {

    buffer_config_t legacy;



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

    legacy.mask |= EFFECT_CONFIG_SMP_RATE;



    legacy.channels = VALUE_OR_RETURN(

            aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));

    legacy.mask |= EFFECT_CONFIG_CHANNELS;



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

    legacy.mask |= EFFECT_CONFIG_FORMAT;



    return legacy;

}



ConversionResult<media::audio::common::AudioConfigBase>

legacy2aidl_AudioConfigBase_buffer_config_t(const buffer_config_t& legacy, bool isInput) {

    media::audio::common::AudioConfigBase aidl;



    if (legacy.mask & EFFECT_CONFIG_SMP_RATE) {

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

    }

    if (legacy.mask & EFFECT_CONFIG_CHANNELS) {

        aidl.channelMask = VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(

                static_cast<audio_channel_mask_t>(legacy.channels), isInput));

    }

    if (legacy.mask & EFFECT_CONFIG_FORMAT) {

        aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(

                static_cast<audio_format_t>(legacy.format)));

    }

    return aidl;

}



}  // namespace android

}  // aidl

media/audioaidlconversion/Android.bp

+13 −3
Original line number Diff line number Diff line
@@ -61,9 +61,9 @@ cc_defaults { 
    host_supported: true,

    vendor_available: true,

    double_loadable: true,

    min_sdk_version: "29",

    header_libs: [

        "libaudio_system_headers",

        "libhardware_headers",

    ],

    shared_libs: [

        "libbase",
@@ -102,7 +102,9 @@ cc_defaults { 
 */

cc_library {

    name: "libaudio_aidl_conversion_common_cpp",

    srcs: ["AidlConversionCppNdk.cpp"],

    srcs: [

        "AidlConversionCppNdk.cpp",

    ],

    header_libs: [

        "libaudio_aidl_conversion_common_util_cpp",

    ],
@@ -113,6 +115,7 @@ cc_library { 
        "audio_aidl_conversion_common_default",

        "latest_android_media_audio_common_types_cpp_export_shared",

    ],

    min_sdk_version: "29",

}



/**
@@ -120,7 +123,10 @@ cc_library { 
 */

cc_library {

    name: "libaudio_aidl_conversion_common_ndk",

    srcs: ["AidlConversionCppNdk.cpp"],

    srcs: [

        "AidlConversionCppNdk.cpp",

        "AidlConversionNdk.cpp",

    ],

    header_libs: [

        "libaudio_aidl_conversion_common_util_ndk",

    ],
@@ -129,12 +135,16 @@ cc_library { 
    ],

    defaults: [

        "audio_aidl_conversion_common_default",

        "latest_android_hardware_audio_common_ndk_shared",

        "latest_android_hardware_audio_effect_ndk_shared",

        "latest_android_media_audio_common_types_ndk_shared",

    ],

    shared_libs: [

        "libbinder_ndk",

        "libbase",

    ],

    cflags: [

        "-DBACKEND_NDK",

    ],

    min_sdk_version: "31", //AParcelableHolder has been introduced in 31

}

media/audioaidlconversion/include/media/AidlConversionNdk.h

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

 * Copyright (C) 2022 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.

 */



#pragma once



#include <android/binder_auto_utils.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>



/**

 * Can only handle conversion between AIDL (NDK backend) and legacy type.

 */

#include <hardware/audio_effect.h>

#include <media/AidlConversionUtil.h>

#include <system/audio_effect.h>



#include <aidl/android/hardware/audio/effect/IEffect.h>



namespace aidl {

namespace android {



ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(

        ::aidl::android::hardware::audio::effect::Flags::Type type);

ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(

        ::aidl::android::hardware::audio::effect::Flags::Insert insert);

ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(

        ::aidl::android::hardware::audio::effect::Flags::Volume volume);

ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(

        ::aidl::android::hardware::audio::effect::Flags::HardwareAccelerator hwAcceleratorMode);

ConversionResult<uint32_t> aidl2legacy_Flags_uint32(

        const ::aidl::android::hardware::audio::effect::Flags aidl);



ConversionResult<::aidl::android::hardware::audio::effect::Flags::Type>

legacy2aidl_uint32_Flags_Type(uint32_t legacy);

ConversionResult<::aidl::android::hardware::audio::effect::Flags::Insert>

legacy2aidl_uint32_Flags_Insert(uint32_t legacy);

ConversionResult<::aidl::android::hardware::audio::effect::Flags::Volume>

legacy2aidl_uint32_Flags_Volume(uint32_t legacy);

ConversionResult<::aidl::android::hardware::audio::effect::Flags::HardwareAccelerator>

legacy2aidl_uint32_Flags_HardwareAccelerator(uint32_t legacy);

ConversionResult<::aidl::android::hardware::audio::effect::Flags> legacy2aidl_uint32_Flags(

        uint32_t hal);



ConversionResult<effect_descriptor_t> aidl2legacy_Descriptor_effect_descriptor(

        const ::aidl::android::hardware::audio::effect::Descriptor& aidl);

ConversionResult<::aidl::android::hardware::audio::effect::Descriptor>

legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& hal);



ConversionResult<buffer_config_t> aidl2legacy_AudioConfigBase_buffer_config_t(

        const media::audio::common::AudioConfigBase& aidl, bool isInput);

ConversionResult<media::audio::common::AudioConfigBase> legacy2aidl_AudioConfigBase_buffer_config_t(

        const buffer_config_t& legacy, bool isInput);



}  // namespace android

}  // namespace aidl

media/audioaidlconversion/include/media/AidlConversionUtil.h

+2 −0
Original line number Diff line number Diff line
@@ -25,7 +25,9 @@ 
#include <error/Result.h>



#if defined(BACKEND_NDK)

#include <android/binder_enums.h>

#include <android/binder_status.h>



namespace aidl {

#else

#include <binder/Enums.h>