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

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

Merge "Implement libAudioHal AIDL EffectsFactoryHalInterface getProcessings"... 

Merge "Implement libAudioHal AIDL EffectsFactoryHalInterface getProcessings" into udc-dev am: 37f5d129

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



Change-Id: I44036ce82e945797b3d000b13b93d57a6e8c0faa
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 3dc1b3d9 37f5d129

media/audioaidlconversion/include/media/AidlConversionCppNdk-impl.h

+5 −0
Original line number Diff line number Diff line
@@ -288,6 +288,11 @@ aidl2legacy_AudioOutputFlags_audio_output_flags_t(media::audio::common::AudioOut 
ConversionResult<media::audio::common::AudioOutputFlags>

legacy2aidl_audio_output_flags_t_AudioOutputFlags(audio_output_flags_t legacy);



ConversionResult<audio_stream_type_t>

aidl2legacy_AudioStreamType_audio_stream_type_t(media::audio::common::AudioStreamType aidl);

ConversionResult<media::audio::common::AudioStreamType>

legacy2aidl_audio_stream_type_t_AudioStreamType(audio_stream_type_t legacy);



// This type is unnamed in the original definition, thus we name it here.

using audio_port_config_mix_ext_usecase = decltype(audio_port_config_mix_ext::usecase);

ConversionResult<audio_port_config_mix_ext_usecase>

media/libaudioclient/include/media/AidlConversion.h

+0 −5
Original line number Diff line number Diff line
@@ -72,11 +72,6 @@ status_t legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt( 
        media::audio::common::AudioPortDeviceExt* aidl,

        media::AudioPortDeviceExtSys* aidlDeviceExt);



ConversionResult<audio_stream_type_t> aidl2legacy_AudioStreamType_audio_stream_type_t(

        media::audio::common::AudioStreamType aidl);

ConversionResult<media::audio::common::AudioStreamType>

legacy2aidl_audio_stream_type_t_AudioStreamType(audio_stream_type_t legacy);



ConversionResult<audio_port_config_mix_ext> aidl2legacy_AudioPortMixExt(

        const media::audio::common::AudioPortMixExt& aidl, media::AudioPortRole role,

        const media::AudioPortMixExtSys& aidlMixExt);

media/libaudiohal/impl/EffectsFactoryHalAidl.cpp

+79 −7
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ using ::aidl::android::aidl_utils::statusTFromBinderStatus; 
using ::aidl::android::hardware::audio::effect::Descriptor;

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

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

using ::aidl::android::media::audio::common::AudioSource;

using ::aidl::android::media::audio::common::AudioStreamType;

using ::aidl::android::media::audio::common::AudioUuid;

using ::android::base::unexpected;

using ::android::detail::AudioHalVersionInfo;
@@ -96,7 +98,13 @@ EffectsFactoryHalAidl::EffectsFactoryHalAidl(std::shared_ptr<IFactory> effectsFa 
          return list;

      }()),

      mEffectCount(mNonProxyDescList.size() + mProxyDescList.size()),

      mEffectProcessings(nullptr /* TODO: add AIDL implementation */) {

      mAidlProcessings([this]() -> std::vector<Processing> {

          std::vector<Processing> processings;

          if (!mFactory || !mFactory->queryProcessing(std::nullopt, &processings).isOk()) {

              ALOGE("%s queryProcessing failed", __func__);

          }

          return processings;

      }()) {

    ALOG_ASSERT(mFactory != nullptr, "Provided IEffectsFactory service is NULL");

    ALOGI("%s with %zu nonProxyEffects and %zu proxyEffects", __func__, mNonProxyDescList.size(),

          mProxyDescList.size());
@@ -274,15 +282,79 @@ bool EffectsFactoryHalAidl::isProxyEffect(const AudioUuid& uuid) const { 
}



std::shared_ptr<const effectsConfig::Processings> EffectsFactoryHalAidl::getProcessings() const {

    return mEffectProcessings;



    auto getConfigEffectWithDescriptor =

            [](const auto& desc) -> std::shared_ptr<const effectsConfig::Effect> {

        effectsConfig::Effect effect = {.name = desc.common.name, .isProxy = false};

        if (const auto uuid =

                    ::aidl::android::aidl2legacy_AudioUuid_audio_uuid_t(desc.common.id.uuid);

            uuid.ok()) {

            static_cast<effectsConfig::EffectImpl>(effect).uuid = uuid.value();

            return std::make_shared<const effectsConfig::Effect>(effect);

        } else {

            return nullptr;

        }

    };



    auto getConfigProcessingWithAidlProcessing =

            [&](const auto& aidlProcess, std::vector<effectsConfig::InputStream>& preprocess,

                std::vector<effectsConfig::OutputStream>& postprocess) {

                if (aidlProcess.type.getTag() == Processing::Type::streamType) {

                    AudioStreamType aidlType =

                            aidlProcess.type.template get<Processing::Type::streamType>();

                    const auto type =

                            ::aidl::android::aidl2legacy_AudioStreamType_audio_stream_type_t(

                                    aidlType);

                    if (!type.ok()) {

                        return;

                    }



                    std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;

                    std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),

                                   std::back_inserter(effects), getConfigEffectWithDescriptor);

                    effectsConfig::OutputStream stream = {.type = type.value(),

                                                          .effects = std::move(effects)};

                    postprocess.emplace_back(stream);

                } else if (aidlProcess.type.getTag() == Processing::Type::source) {

                    AudioSource aidlType =

                            aidlProcess.type.template get<Processing::Type::source>();

                    const auto type =

                            ::aidl::android::aidl2legacy_AudioSource_audio_source_t(aidlType);

                    if (!type.ok()) {

                        return;

                    }



                    std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;

                    std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),

                                   std::back_inserter(effects), getConfigEffectWithDescriptor);

                    effectsConfig::InputStream stream = {.type = type.value(),

                                                         .effects = std::move(effects)};

                    preprocess.emplace_back(stream);

                }

            };



    static std::shared_ptr<const effectsConfig::Processings> processings(

            [&]() -> std::shared_ptr<const effectsConfig::Processings> {

                std::vector<effectsConfig::InputStream> preprocess;

                std::vector<effectsConfig::OutputStream> postprocess;

                for (const auto& processing : mAidlProcessings) {

                    getConfigProcessingWithAidlProcessing(processing, preprocess, postprocess);

                }



                if (0 == preprocess.size() && 0 == postprocess.size()) {

                    return nullptr;

                }



::android::error::Result<size_t> EffectsFactoryHalAidl::getSkippedElements() const {

    if (!mEffectProcessings) {

        return ::android::base::unexpected(BAD_VALUE);

                return std::make_shared<const effectsConfig::Processings>(

                        effectsConfig::Processings({.preprocess = std::move(preprocess),

                                                    .postprocess = std::move(postprocess)}));

            }());



    return processings;

}



    // Only return 0 for AIDL, because the AIDL interface doesn't aware of configuration file

// Return 0 for AIDL, as the AIDL interface is not aware of the configuration file.

::android::error::Result<size_t> EffectsFactoryHalAidl::getSkippedElements() const {

    return 0;

}

media/libaudiohal/impl/EffectsFactoryHalAidl.h

+2 −1
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <mutex>



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

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

#include <android-base/thread_annotations.h>

#include <media/audiohal/EffectsFactoryHalInterface.h>

#include <system/thread_defs.h>
@@ -82,7 +83,7 @@ class EffectsFactoryHalAidl final : public EffectsFactoryHalInterface { 
    // total number of effects including proxy effects

    const size_t mEffectCount;

    // Query result of pre and post processing from effect factory

    const std::shared_ptr<const effectsConfig::Processings> mEffectProcessings;

    const std::vector<Processing> mAidlProcessings;



    std::mutex mLock;

    uint64_t mEffectIdCounter GUARDED_BY(mLock) = 0;  // Align with HIDL (0 is INVALID_ID)

media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp

+42 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
 */



//#define LOG_NDEBUG 0

#include <algorithm>

#include <cstddef>

#include <cstdint>

#include <cstring>
@@ -92,6 +93,47 @@ TEST(libAudioHalTest, createEffect) { 
    }

}



TEST(libAudioHalTest, getProcessings) {

    auto factory = EffectsFactoryHalInterface::create();

    ASSERT_NE(nullptr, factory);



    const auto &processings = factory->getProcessings();

    if (processings) {

        EXPECT_NE(0UL, processings->preprocess.size() + processings->postprocess.size() +

                               processings->deviceprocess.size());



        auto processingChecker = [](const auto& processings) {

            if (processings.size() != 0) {

                // any process need at least 1 effect inside

                std::for_each(processings.begin(), processings.end(), [](const auto& process) {

                    EXPECT_NE(0ul, process.effects.size());

                    // any effect should have a valid name string, and not proxy

                    for (const auto& effect : process.effects) {

                        SCOPED_TRACE("Effect: {" +

                                     (effect == nullptr

                                              ? "NULL}"

                                              : ("{name: " + effect->name + ", isproxy: " +

                                                 (effect->isProxy ? "true" : "false") + ", sw: " +

                                                 (effect->libSw ? "non-null" : "null") + ", hw: " +

                                                 (effect->libHw ? "non-null" : "null") + "}")));

                        EXPECT_NE(nullptr, effect);

                        EXPECT_NE("", effect->name);

                        EXPECT_EQ(false, effect->isProxy);

                        EXPECT_EQ(nullptr, effect->libSw);

                        EXPECT_EQ(nullptr, effect->libHw);

                    }

                });

            }

        };



        processingChecker(processings->preprocess);

        processingChecker(processings->postprocess);

        processingChecker(processings->deviceprocess);

    } else {

        GTEST_SKIP() << "no processing found, skipping the test";

    }

}



TEST(libAudioHalTest, getHalVersion) {

    auto factory = EffectsFactoryHalInterface::create();

    ASSERT_NE(nullptr, factory);