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

Commit 51202507 authored by Shunkai Yao's avatar Shunkai Yao
Browse files

Add libAudioHal AIDL interface placeholder 

Add cpp backend only and ndk backend only conversion.
Add placeholder for DeviceHalInterface and EffectHalInterface.
Add several EffectHalInterface test cases to help testing.

Bug: 261129656
Test: Flash to Cuttlefish and run cts
Test: Flash to Panther and run audio use cases.

Merged-In: Ieaf5d7d72bd7d3e1897964b7abe211456766f443
Change-Id: Ieaf5d7d72bd7d3e1897964b7abe211456766f443
parent 49879b76

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>