audio/aidl/vts/VtsHalEqualizerTargetTest.cpp

/*
 * 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 <algorithm>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <vector>

#define LOG_TAG "VtsHalEqualizerTest"

#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android/binder_interface_utils.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <gtest/gtest.h>

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

#include "AudioHalBinderServiceUtil.h"
#include "EffectHelper.h"
#include "TestUtils.h"
#include "effect-impl/EffectUUID.h"

using namespace android;

using aidl::android::hardware::audio::effect::Capability;
using aidl::android::hardware::audio::effect::Descriptor;
using aidl::android::hardware::audio::effect::Equalizer;
using aidl::android::hardware::audio::effect::IEffect;
using aidl::android::hardware::audio::effect::IFactory;
using aidl::android::hardware::audio::effect::kEqualizerTypeUUID;
using aidl::android::hardware::audio::effect::Parameter;

/**
 * Here we focus on specific effect (equalizer) parameter checking, general IEffect interfaces
 * testing performed in VtsAudioEfectTargetTest.
 */

enum ParamName { PARAM_INSTANCE_NAME, PARAM_BAND_LEVEL };
using EqualizerParamTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>;

/*
Testing parameter range, assuming the parameter supported by effect is in this range.
This range is verified with IEffect.getDescriptor(), for any index supported vts expect EX_NONE
from IEffect.setParameter(), otherwise expect EX_ILLEGAL_ARGUMENT.
*/
const std::vector<int> kBandLevels = {0, -10, 10};  // needs update with implementation

class EqualizerTest : public ::testing::TestWithParam<EqualizerParamTestParam>,
                      public EffectHelper {
  public:
    EqualizerTest() : mBandLevel(std::get<PARAM_BAND_LEVEL>(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));

        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);
        ASSERT_NO_FATAL_FAILURE(setTagRange());
    }
    void TearDown() override {
        ASSERT_NO_FATAL_FAILURE(close(mEffect));
        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
    }

    std::pair<int, int> setPresetIndexRange(const Equalizer::Capability& cap) const {
        const auto [min, max] =
                std::minmax_element(cap.presets.begin(), cap.presets.end(),
                                    [](const auto& a, const auto& b) { return a.index < b.index; });
        return {min->index, max->index};
    }
    std::pair<int, int> setBandIndexRange(const Equalizer::Capability& cap) const {
        const auto [min, max] =
                std::minmax_element(cap.bandFrequencies.begin(), cap.bandFrequencies.end(),
                                    [](const auto& a, const auto& b) { return a.index < b.index; });
        return {min->index, max->index};
    }
    void setTagRange() {
        Descriptor desc;
        ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
        Equalizer::Capability& eqCap = desc.capability.get<Capability::equalizer>();
        mPresetIndex = setPresetIndexRange(eqCap);
        mBandIndex = setBandIndexRange(eqCap);
    }

    static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
    std::shared_ptr<IFactory> mFactory;
    std::shared_ptr<IEffect> mEffect;
    Descriptor mDescriptor;
    std::pair<int, int> mPresetIndex;
    std::pair<int, int> mBandIndex;
    const int mBandLevel;
    Descriptor mDesc;

    void SetAndGetEqualizerParameters() {
        ASSERT_NE(nullptr, mEffect);
        for (auto& it : mTags) {
            auto& tag = it.first;
            auto& eq = it.second;

            // validate parameter
            const bool valid = isTagInRange(it.first, it.second);
            const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;

            // set
            Parameter expectParam;
            Parameter::Specific specific;
            specific.set<Parameter::Specific::equalizer>(eq);
            expectParam.set<Parameter::specific>(specific);
            EXPECT_STATUS(expected, mEffect->setParameter(expectParam))
                    << expectParam.toString() << "\n"
                    << mDesc.toString();

            // only get if parameter in range and set success
            if (expected == EX_NONE) {
                Parameter getParam;
                Parameter::Id id;
                Equalizer::Id eqId;
                eqId.set<Equalizer::Id::commonTag>(tag);
                id.set<Parameter::Id::equalizerTag>(eqId);
                // if set success, then get should match
                EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));
                EXPECT_TRUE(isEqParameterExpected(expectParam, getParam))
                        << "\nexpect:" << expectParam.toString()
                        << "\ngetParam:" << getParam.toString();
            }
        }
    }

    bool isEqParameterExpected(const Parameter& expect, const Parameter& target) {
        // if parameter same, then for sure they are matched
        if (expect == target) return true;

        // if not, see if target include the expect parameter, and others all default (0).
        /*
         * This is to verify the case of client setParameter to a single bandLevel ({3, -1} for
         * example), and return of getParameter must be [{0, 0}, {1, 0}, {2, 0}, {3, -1}, {4, 0}]
         */
        EXPECT_EQ(expect.getTag(), Parameter::specific);
        EXPECT_EQ(target.getTag(), Parameter::specific);

        Parameter::Specific expectSpec = expect.get<Parameter::specific>(),
                            targetSpec = target.get<Parameter::specific>();
        EXPECT_EQ(expectSpec.getTag(), Parameter::Specific::equalizer);
        EXPECT_EQ(targetSpec.getTag(), Parameter::Specific::equalizer);

        Equalizer expectEq = expectSpec.get<Parameter::Specific::equalizer>(),
                  targetEq = targetSpec.get<Parameter::Specific::equalizer>();
        EXPECT_EQ(expectEq.getTag(), targetEq.getTag());

        auto eqTag = targetEq.getTag();
        switch (eqTag) {
            case Equalizer::bandLevels: {
                auto expectBl = expectEq.get<Equalizer::bandLevels>();
                std::sort(expectBl.begin(), expectBl.end(),
                          [](const auto& a, const auto& b) { return a.index < b.index; });
                expectBl.erase(std::unique(expectBl.begin(), expectBl.end()), expectBl.end());
                auto targetBl = targetEq.get<Equalizer::bandLevels>();
                return std::includes(targetBl.begin(), targetBl.end(), expectBl.begin(),
                                     expectBl.end());
            }
            case Equalizer::preset: {
                return expectEq.get<Equalizer::preset>() == targetEq.get<Equalizer::preset>();
            }
            default:
                return false;
        }
        return false;
    }

    void addPresetParam(int preset) {
        Equalizer eq;
        eq.set<Equalizer::preset>(preset);
        mTags.push_back({Equalizer::preset, eq});
    }

    void addBandLevelsParam(std::vector<Equalizer::BandLevel>& bandLevels) {
        Equalizer eq;
        eq.set<Equalizer::bandLevels>(bandLevels);
        mTags.push_back({Equalizer::bandLevels, eq});
    }

    bool isTagInRange(const Equalizer::Tag& tag, const Equalizer& eq) const {
        switch (tag) {
            case Equalizer::preset: {
                int index = eq.get<Equalizer::preset>();
                return index >= mPresetIndex.first && index <= mPresetIndex.second;
            }
            case Equalizer::bandLevels: {
                auto& bandLevel = eq.get<Equalizer::bandLevels>();
                return isBandInRange(bandLevel);
            }
            default:
                return false;
        }
        return false;
    }

    bool isBandInRange(const std::vector<Equalizer::BandLevel>& bandLevel) const {
        for (auto& it : bandLevel) {
            if (it.index < mBandIndex.first || it.index > mBandIndex.second) return false;
        }
        return true;
    }

    Parameter::Specific getDefaultParamSpecific() {
        Equalizer eq = Equalizer::make<Equalizer::preset>(0);
        Parameter::Specific specific =
                Parameter::Specific::make<Parameter::Specific::equalizer>(eq);
        return specific;
    }

  private:
    std::vector<std::pair<Equalizer::Tag, Equalizer>> mTags;

    bool validCapabilityTag(Capability& cap) { return cap.getTag() == Capability::equalizer; }

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

TEST_P(EqualizerTest, SetAndGetPresetOutOfLowerBound) {
    addPresetParam(mPresetIndex.second - 1);
    ASSERT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetPresetOutOfUpperBound) {
    addPresetParam(mPresetIndex.second + 1);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetPresetAtLowerBound) {
    addPresetParam(mPresetIndex.first);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetPresetAtHigherBound) {
    addPresetParam(mPresetIndex.second);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetPresetInBound) {
    addPresetParam((mPresetIndex.first + mPresetIndex.second) >> 1);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetBandOutOfLowerBound) {
    std::vector<Equalizer::BandLevel> bandLevels{{mBandIndex.first - 1, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetBandOutOfUpperBound) {
    std::vector<Equalizer::BandLevel> bandLevels{{mBandIndex.second + 1, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetBandAtLowerBound) {
    std::vector<Equalizer::BandLevel> bandLevels{{mBandIndex.first, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetBandAtHigherBound) {
    std::vector<Equalizer::BandLevel> bandLevels{{mBandIndex.second, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetBandInBound) {
    std::vector<Equalizer::BandLevel> bandLevels{
            {(mBandIndex.first + mBandIndex.second) >> 1, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetMultiBands) {
    addPresetParam(mPresetIndex.first);
    std::vector<Equalizer::BandLevel> bandLevels{
            {mBandIndex.first, mBandLevel},
            {mBandIndex.second, mBandLevel},
            {(mBandIndex.first + mBandIndex.second) >> 1, mBandLevel}};
    addBandLevelsParam(bandLevels);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

TEST_P(EqualizerTest, SetAndGetMultipleParams) {
    std::vector<Equalizer::BandLevel> bandLevels{
            {(mBandIndex.first + mBandIndex.second) >> 1, mBandLevel}};
    addBandLevelsParam(bandLevels);
    addPresetParam((mPresetIndex.first + mPresetIndex.second) >> 1);
    EXPECT_NO_FATAL_FAILURE(SetAndGetEqualizerParameters());
}

INSTANTIATE_TEST_SUITE_P(
        EqualizerTest, EqualizerTest,
        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
                                   IFactory::descriptor, kEqualizerTypeUUID)),
                           testing::ValuesIn(kBandLevels)),
        [](const testing::TestParamInfo<EqualizerTest::ParamType>& info) {
            auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
            std::string bandLevel = std::to_string(std::get<PARAM_BAND_LEVEL>(info.param));
            std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
                               descriptor.common.name + "_UUID_" +
                               descriptor.common.id.uuid.toString() + "_bandLevel_" + bandLevel;
            std::replace_if(
                    name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
            return name;
        });
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EqualizerTest);

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    ABinderProcess_setThreadPoolMaxThreadCount(1);
    ABinderProcess_startThreadPool();
    return RUN_ALL_TESTS();
}