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

Commit d168a280 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 11704135 from 429baea5 to 24Q3-release 

Change-Id: I1a99d2daa1f94701527e732b0418131c302851ba
parents ebd1e784 429baea5

audio/aidl/default/audio_effects_config.xml

+0 −1
Original line number Diff line number Diff line
@@ -78,7 +78,6 @@ 
        <effect name="haptic_generator" library="haptic_generator" uuid="97c4acd1-8b82-4f2f-832e-c2fe5d7a9931"/>

        <effect name="loudness_enhancer" library="loudness_enhancer" uuid="fa415329-2034-4bea-b5dc-5b381c8d1e2c"/>

        <effect name="env_reverb" library="env_reverbsw" uuid="fa819886-588b-11ed-9b6a-0242ac120002"/>

        <effect name="preset_reverb" library="preset_reverbsw" uuid="fa8199c6-588b-11ed-9b6a-0242ac120002"/>

        <effect name="reverb_env_aux" library="reverb" uuid="4a387fc0-8ab3-11df-8bad-0002a5d5c51b"/>

        <effect name="reverb_env_ins" library="reverb" uuid="c7a511a0-a3bb-11df-860e-0002a5d5c51b"/>

        <effect name="reverb_pre_aux" library="reverb" uuid="f29a1400-a3bb-11df-8ddc-0002a5d5c51b"/>

audio/aidl/vts/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -145,6 +145,9 @@ cc_test { 
    name: "VtsHalPresetReverbTargetTest",

    defaults: ["VtsHalAudioEffectTargetTestDefaults"],

    srcs: ["VtsHalPresetReverbTargetTest.cpp"],

    shared_libs: [

        "libaudioutils",

    ],

}



cc_test {

audio/aidl/vts/EffectHelper.h

+2 −0
Original line number Diff line number Diff line
@@ -70,6 +70,8 @@ typedef ::android::AidlMessageQueue<float, 
static inline std::string getPrefix(Descriptor& descriptor) {

    std::string prefix = "Implementor_" + descriptor.common.implementor + "_name_" +

                         descriptor.common.name + "_UUID_" + toString(descriptor.common.id.uuid);

    std::replace_if(

            prefix.begin(), prefix.end(), [](const char c) { return !std::isalnum(c); }, '_');

    return prefix;

}

audio/aidl/vts/VtsHalAudioCoreModuleTargetTest.cpp

+12 −7
Original line number Diff line number Diff line
@@ -1740,6 +1740,11 @@ TEST_P(AudioCoreModule, SetAudioPortConfigInvalidPortConfigId) { 
}



TEST_P(AudioCoreModule, TryConnectMissingDevice) {

    // Limit checks to connection types that are known to be detectable by HAL implementations.

    static const std::set<std::string> kCheckedConnectionTypes{

            AudioDeviceDescription::CONNECTION_HDMI, AudioDeviceDescription::CONNECTION_HDMI_ARC,

            AudioDeviceDescription::CONNECTION_HDMI_EARC, AudioDeviceDescription::CONNECTION_IP_V4,

            AudioDeviceDescription::CONNECTION_USB};

    ASSERT_NO_FATAL_FAILURE(SetUpModuleConfig());

    std::vector<AudioPort> ports = moduleConfig->getExternalDevicePorts();

    if (ports.empty()) {
@@ -1748,14 +1753,10 @@ TEST_P(AudioCoreModule, TryConnectMissingDevice) { 
    WithDebugFlags doNotSimulateConnections = WithDebugFlags::createNested(*debug);

    doNotSimulateConnections.flags().simulateDeviceConnections = false;

    ASSERT_NO_FATAL_FAILURE(doNotSimulateConnections.SetUp(module.get()));

    bool hasAtLeastOneCheckedConnection = false;

    for (const auto& port : ports) {

        // Virtual devices may not require external hardware and thus can always be connected.

        if (port.ext.get<AudioPortExt::device>().device.type.connection ==

                    AudioDeviceDescription::CONNECTION_VIRTUAL ||

            // SCO devices are handled at low level by DSP, may not be able to check actual

            // connection.

            port.ext.get<AudioPortExt::device>().device.type.connection ==

                    AudioDeviceDescription::CONNECTION_BT_SCO) {

        if (kCheckedConnectionTypes.count(

                    port.ext.get<AudioPortExt::device>().device.type.connection) == 0) {

            continue;

        }

        AudioPort portWithData = GenerateUniqueDeviceAddress(port), connectedPort;
@@ -1768,6 +1769,10 @@ TEST_P(AudioCoreModule, TryConnectMissingDevice) { 
            EXPECT_IS_OK(module->disconnectExternalDevice(connectedPort.id))

                    << "when disconnecting device port ID " << connectedPort.id;

        }

        hasAtLeastOneCheckedConnection = true;

    }

    if (!hasAtLeastOneCheckedConnection) {

        GTEST_SKIP() << "No external devices with connection types that can be checked.";

    }

}

audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp

+167 −63
Original line number Diff line number Diff line
@@ -17,11 +17,14 @@ 
#define LOG_TAG "VtsHalPresetReverbTargetTest"

#include <android-base/logging.h>

#include <android/binder_enums.h>

#include <audio_utils/power.h>

#include <system/audio.h>



#include "EffectHelper.h"



using namespace android;



using aidl::android::hardware::audio::common::getChannelCount;

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

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

using aidl::android::hardware::audio::effect::IEffect;
@@ -30,6 +33,68 @@ using aidl::android::hardware::audio::effect::Parameter; 
using aidl::android::hardware::audio::effect::PresetReverb;

using android::hardware::audio::common::testing::detail::TestExecutionTracer;



class PresetReverbHelper : public EffectHelper {

  public:

    void SetUpPresetReverb() {

        ASSERT_NE(nullptr, mFactory);

        ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));

        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = EffectHelper::createParamCommon(

                0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,

                kSamplingFrequency /* oSampleRate */, mFrameCount /* iFrameCount */,

                mFrameCount /* oFrameCount */);

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &mOpenEffectReturn, EX_NONE));

        ASSERT_NE(nullptr, mEffect);

    }



    void TearDownPresetReverb() {

        ASSERT_NO_FATAL_FAILURE(close(mEffect));

        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

        mOpenEffectReturn = IEffect::OpenEffectReturn{};

    }



    Parameter::Specific getDefaultParamSpecific() {

        PresetReverb pr = PresetReverb::make<PresetReverb::preset>(kDefaultPreset);

        Parameter::Specific specific =

                Parameter::Specific::make<Parameter::Specific::presetReverb>(pr);

        return specific;

    }



    Parameter createPresetReverbParam(const PresetReverb::Presets& param) {

        return Parameter::make<Parameter::specific>(

                Parameter::Specific::make<Parameter::Specific::presetReverb>(

                        PresetReverb::make<PresetReverb::preset>(param)));

    }



    void setAndVerifyPreset(const PresetReverb::Presets& param) {

        auto expectedParam = createPresetReverbParam(param);

        EXPECT_STATUS(EX_NONE, mEffect->setParameter(expectedParam)) << expectedParam.toString();



        PresetReverb::Id revId =

                PresetReverb::Id::make<PresetReverb::Id::commonTag>(PresetReverb::preset);



        auto id = Parameter::Id::make<Parameter::Id::presetReverbTag>(revId);

        // get parameter

        Parameter getParam;

        EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));

        EXPECT_EQ(expectedParam, getParam) << "\nexpectedParam:" << expectedParam.toString()

                                           << "\ngetParam:" << getParam.toString();

    }



    static constexpr int kSamplingFrequency = 44100;

    static constexpr int kDurationMilliSec = 2000;

    static constexpr int kBufferSize = kSamplingFrequency * kDurationMilliSec / 1000;

    int mStereoChannelCount =

            getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(

                    AudioChannelLayout::LAYOUT_STEREO));

    PresetReverb::Presets kDefaultPreset = PresetReverb::Presets::NONE;

    int mFrameCount = kBufferSize / mStereoChannelCount;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    IEffect::OpenEffectReturn mOpenEffectReturn;

    Descriptor mDescriptor;

};



/**

 * Here we focus on specific parameter checking, general IEffect interfaces testing performed in

 * VtsAudioEffectTargetTest.
@@ -44,88 +109,116 @@ const std::vector<PresetReverb::Presets> kPresetsValues{ 
        ndk::enum_range<PresetReverb::Presets>().end()};



class PresetReverbParamTest : public ::testing::TestWithParam<PresetReverbParamTestParam>,

                              public EffectHelper {

                              public PresetReverbHelper {

  public:

    PresetReverbParamTest() : mParamPresets(std::get<PARAM_PRESETS>(GetParam())) {

    PresetReverbParamTest() : mParamPreset(std::get<PARAM_PRESETS>(GetParam())) {

        std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());

    }



    void SetUp() override {

        ASSERT_NE(nullptr, mFactory);

        ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));

    void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpPresetReverb()); }



        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = EffectHelper::createParamCommon(

                0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,

                kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);

        IEffect::OpenEffectReturn ret;

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));

        ASSERT_NE(nullptr, mEffect);

    void TearDown() override { TearDownPresetReverb(); }



    const PresetReverb::Presets mParamPreset;

};



TEST_P(PresetReverbParamTest, SetAndGetPresets) {

    ASSERT_NO_FATAL_FAILURE(setAndVerifyPreset(mParamPreset));

}



using PresetReverbProcessTestParam = std::pair<std::shared_ptr<IFactory>, Descriptor>;



class PresetReverbProcessTest : public ::testing::TestWithParam<PresetReverbProcessTestParam>,

                                public PresetReverbHelper {

  public:

    PresetReverbProcessTest() {

        std::tie(mFactory, mDescriptor) = GetParam();

        generateSineWaveInput();

    }



    void SetUp() override {

        SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);

        ASSERT_NO_FATAL_FAILURE(SetUpPresetReverb());

    }

    void TearDown() override {

        ASSERT_NO_FATAL_FAILURE(close(mEffect));

        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

        SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);

        ASSERT_NO_FATAL_FAILURE(TearDownPresetReverb());

    }



    static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;

    PresetReverb::Presets mParamPresets = PresetReverb::Presets::NONE;



    void SetAndGetPresetReverbParameters() {

        for (auto& it : mTags) {

            auto& tag = it.first;

            auto& pr = it.second;



            // validate parameter

            Descriptor desc;

            ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));

            const bool valid = isParameterValid<PresetReverb, Range::presetReverb>(it.second, desc);

            const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;



            // set parameter

            Parameter expectParam;

            Parameter::Specific specific;

            specific.set<Parameter::Specific::presetReverb>(pr);

            expectParam.set<Parameter::specific>(specific);

            // All values are valid, set parameter should succeed

            EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();

    void generateSineWaveInput() {

        int frequency = 1000;

        for (size_t i = 0; i < kBufferSize; i++) {

            mInput.push_back(sin(2 * M_PI * frequency * i / kSamplingFrequency));

        }

    }



            // get parameter

            Parameter getParam;

            Parameter::Id id;

            PresetReverb::Id prId;

            prId.set<PresetReverb::Id::commonTag>(tag);

            id.set<Parameter::Id::presetReverbTag>(prId);

            EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));

    bool isAuxiliary() {

        return mDescriptor.common.flags.type ==

               aidl::android::hardware::audio::effect::Flags::Type::AUXILIARY;

    }



            EXPECT_EQ(expectParam, getParam);

    float computeReverbOutputEnergy(std::vector<float> output) {

        if (!isAuxiliary()) {

            // Extract auxiliary output

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

                output[i] -= mInput[i];

            }

        }

        return (audio_utils_compute_energy_mono(output.data(), AUDIO_FORMAT_PCM_FLOAT,

                                                output.size()));

    }



    void addPresetsParam(PresetReverb::Presets preset) {

        PresetReverb pr;

        pr.set<PresetReverb::preset>(preset);

        mTags.push_back({PresetReverb::preset, pr});

    void setPresetAndProcess(const PresetReverb::Presets& preset, std::vector<float>& output) {

        ASSERT_NO_FATAL_FAILURE(setAndVerifyPreset(preset));

        ASSERT_NO_FATAL_FAILURE(

                processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));

    }



    Parameter::Specific getDefaultParamSpecific() {

        PresetReverb pr = PresetReverb::make<PresetReverb::preset>(PresetReverb::Presets::NONE);

        Parameter::Specific specific =

                Parameter::Specific::make<Parameter::Specific::presetReverb>(pr);

        return specific;

    void validateIncreasingEnergy(const std::vector<PresetReverb::Presets>& presets) {

        float baseOutputEnergy = 0;



        for (PresetReverb::Presets preset : presets) {

            std::vector<float> output(kBufferSize);

            setPresetAndProcess(preset, output);

            float outputEnergy = computeReverbOutputEnergy(output);



            ASSERT_GT(outputEnergy, baseOutputEnergy);

            baseOutputEnergy = outputEnergy;

        }

    }



  private:

    std::vector<std::pair<PresetReverb::Tag, PresetReverb>> mTags;

    void CleanUp() { mTags.clear(); }

    std::vector<float> mInput;

};



TEST_P(PresetReverbParamTest, SetAndGetPresets) {

    EXPECT_NO_FATAL_FAILURE(addPresetsParam(mParamPresets));

    SetAndGetPresetReverbParameters();

TEST_P(PresetReverbProcessTest, DecreasingRoomSize) {

    std::vector<PresetReverb::Presets> roomPresets = {PresetReverb::Presets::LARGEROOM,

                                                      PresetReverb::Presets::MEDIUMROOM,

                                                      PresetReverb::Presets::SMALLROOM};

    validateIncreasingEnergy(roomPresets);

}



TEST_P(PresetReverbProcessTest, DecreasingHallSize) {

    std::vector<PresetReverb::Presets> hallPresets = {PresetReverb::Presets::LARGEHALL,

                                                      PresetReverb::Presets::MEDIUMHALL};

    validateIncreasingEnergy(hallPresets);

}



TEST_P(PresetReverbProcessTest, PresetPlate) {

    std::vector<float> output(kBufferSize);



    setPresetAndProcess(PresetReverb::Presets::PLATE, output);

    float outputEnergy = computeReverbOutputEnergy(output);

    // Since there is no comparator preset, validating it is greater than zero

    ASSERT_GT(outputEnergy, 0);

}



TEST_P(PresetReverbProcessTest, PresetNone) {

    std::vector<float> output(kBufferSize);



    setPresetAndProcess(kDefaultPreset, output);

    float outputEnergy = computeReverbOutputEnergy(output);

    // NONE type doesn't create reverb effect

    ASSERT_EQ(outputEnergy, 0);

}



INSTANTIATE_TEST_SUITE_P(
@@ -145,6 +238,17 @@ INSTANTIATE_TEST_SUITE_P( 


GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PresetReverbParamTest);



INSTANTIATE_TEST_SUITE_P(

        PresetReverbTest, PresetReverbProcessTest,

        testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                IFactory::descriptor, getEffectTypeUuidPresetReverb())),

        [](const testing::TestParamInfo<PresetReverbProcessTest::ParamType>& info) {

            auto descriptor = info.param;

            return getPrefix(descriptor.second);

        });



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PresetReverbProcessTest);



int main(int argc, char** argv) {

    ::testing::InitGoogleTest(&argc, argv);

    ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());