media/libeffects/lvm/tests/EffectBundleTest.cpp

/*
 * Copyright 2021 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 <system/audio_effects/effect_bassboost.h>
#include <system/audio_effects/effect_equalizer.h>
#include <system/audio_effects/effect_virtualizer.h>
#include "EffectTestHelper.h"

using namespace android;
typedef enum {
    EFFECT_BASS_BOOST,
    EFFECT_EQUALIZER,
    EFFECT_VIRTUALIZER,
    EFFECT_VOLUME
} effect_type_t;

const std::map<effect_type_t, effect_uuid_t> kEffectUuids = {
        // NXP SW BassBoost
        {EFFECT_BASS_BOOST,
         {0x8631f300, 0x72e2, 0x11df, 0xb57e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
        // NXP SW Equalizer
        {EFFECT_EQUALIZER,
         {0xce772f20, 0x847d, 0x11df, 0xbb17, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
        // NXP SW Virtualizer
        {EFFECT_VIRTUALIZER,
         {0x1d4033c0, 0x8557, 0x11df, 0x9f2d, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
        // NXP SW Volume
        {EFFECT_VOLUME, {0x119341a0, 0x8469, 0x11df, 0x81f9, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
};

const size_t kNumEffectUuids = std::size(kEffectUuids);

constexpr float kMinAmplitude = -1.0f;
constexpr float kMaxAmplitude = 1.0f;

using SingleEffectTestParam = std::tuple<int, int, int, int, int>;
class SingleEffectTest : public ::testing::TestWithParam<SingleEffectTestParam> {
  public:
    SingleEffectTest()
        : mChMask(EffectTestHelper::kChMasks[std::get<0>(GetParam())]),
          mChannelCount(audio_channel_count_from_out_mask(mChMask)),
          mSampleRate(EffectTestHelper::kSampleRates[std::get<1>(GetParam())]),
          mFrameCount(EffectTestHelper::kFrameCounts[std::get<2>(GetParam())]),
          mLoopCount(EffectTestHelper::kLoopCounts[std::get<3>(GetParam())]),
          mTotalFrameCount(mFrameCount * mLoopCount),
          mEffectType((effect_type_t)std::get<4>(GetParam())),
          mUuid(kEffectUuids.at(mEffectType)) {}

    const size_t mChMask;
    const size_t mChannelCount;
    const size_t mSampleRate;
    const size_t mFrameCount;
    const size_t mLoopCount;
    const size_t mTotalFrameCount;
    const effect_type_t mEffectType;
    const effect_uuid_t mUuid;
};

// Tests applying a single effect
TEST_P(SingleEffectTest, SimpleProcess) {
    SCOPED_TRACE(testing::Message()
                 << "chMask: " << mChMask << " sampleRate: " << mSampleRate
                 << " frameCount: " << mFrameCount << " loopCount: " << mLoopCount);

    EffectTestHelper effect(&mUuid, mChMask, mChMask, mSampleRate, mFrameCount, mLoopCount);

    ASSERT_NO_FATAL_FAILURE(effect.createEffect());
    ASSERT_NO_FATAL_FAILURE(effect.setConfig());

    // Initialize input buffer with deterministic pseudo-random values
    std::vector<float> input(mTotalFrameCount * mChannelCount);
    std::vector<float> output(mTotalFrameCount * mChannelCount);
    std::minstd_rand gen(mChMask);
    std::uniform_real_distribution<> dis(kMinAmplitude, kMaxAmplitude);
    for (auto& in : input) {
        in = dis(gen);
    }
    ASSERT_NO_FATAL_FAILURE(effect.process(input.data(), output.data()));
    ASSERT_NO_FATAL_FAILURE(effect.releaseEffect());
}

INSTANTIATE_TEST_SUITE_P(
        EffectBundleTestAll, SingleEffectTest,
        ::testing::Combine(::testing::Range(0, (int)EffectTestHelper::kNumChMasks),
                           ::testing::Range(0, (int)EffectTestHelper::kNumSampleRates),
                           ::testing::Range(0, (int)EffectTestHelper::kNumFrameCounts),
                           ::testing::Range(0, (int)EffectTestHelper::kNumLoopCounts),
                           ::testing::Range(0, (int)kNumEffectUuids)));

using SingleEffectComparisonTestParam = std::tuple<int, int, int, int>;
class SingleEffectComparisonTest
    : public ::testing::TestWithParam<SingleEffectComparisonTestParam> {
  public:
    SingleEffectComparisonTest()
        : mSampleRate(EffectTestHelper::kSampleRates[std::get<0>(GetParam())]),
          mFrameCount(EffectTestHelper::kFrameCounts[std::get<1>(GetParam())]),
          mLoopCount(EffectTestHelper::kLoopCounts[std::get<2>(GetParam())]),
          mTotalFrameCount(mFrameCount * mLoopCount),
          mEffectType((effect_type_t)std::get<3>(GetParam())),
          mUuid(kEffectUuids.at(mEffectType)) {}

    const size_t mSampleRate;
    const size_t mFrameCount;
    const size_t mLoopCount;
    const size_t mTotalFrameCount;
    const effect_type_t mEffectType;
    const effect_uuid_t mUuid;
};

// Compares first two channels in multi-channel output to stereo output when same effect is applied
TEST_P(SingleEffectComparisonTest, SimpleProcess) {
    SCOPED_TRACE(testing::Message() << " sampleRate: " << mSampleRate << " frameCount: "
                                    << mFrameCount << " loopCount: " << mLoopCount);

    // Initialize mono input buffer with deterministic pseudo-random values
    std::vector<float> monoInput(mTotalFrameCount);

    std::minstd_rand gen(mSampleRate);
    std::uniform_real_distribution<> dis(kMinAmplitude, kMaxAmplitude);
    for (auto& in : monoInput) {
        in = dis(gen);
    }

    // Generate stereo by repeating mono channel data
    std::vector<float> stereoInput(mTotalFrameCount * FCC_2);
    adjust_channels(monoInput.data(), FCC_1, stereoInput.data(), FCC_2, sizeof(float),
                    mTotalFrameCount * sizeof(float) * FCC_1);

    // Apply effect on stereo channels
    EffectTestHelper stereoEffect(&mUuid, AUDIO_CHANNEL_OUT_STEREO, AUDIO_CHANNEL_OUT_STEREO,
                                  mSampleRate, mFrameCount, mLoopCount);

    ASSERT_NO_FATAL_FAILURE(stereoEffect.createEffect());
    ASSERT_NO_FATAL_FAILURE(stereoEffect.setConfig());

    std::vector<float> stereoOutput(mTotalFrameCount * FCC_2);
    ASSERT_NO_FATAL_FAILURE(stereoEffect.process(stereoInput.data(), stereoOutput.data()));
    ASSERT_NO_FATAL_FAILURE(stereoEffect.releaseEffect());

    // Convert stereo float data to stereo int16_t to be used as reference
    std::vector<int16_t> stereoRefI16(mTotalFrameCount * FCC_2);
    memcpy_to_i16_from_float(stereoRefI16.data(), stereoOutput.data(), mTotalFrameCount * FCC_2);

    for (size_t chMask : EffectTestHelper::kChMasks) {
        size_t channelCount = audio_channel_count_from_out_mask(chMask);
        EffectTestHelper testEffect(&mUuid, chMask, chMask, mSampleRate, mFrameCount, mLoopCount);

        ASSERT_NO_FATAL_FAILURE(testEffect.createEffect());
        ASSERT_NO_FATAL_FAILURE(testEffect.setConfig());

        std::vector<float> testInput(mTotalFrameCount * channelCount);

        // Repeat mono channel data to all the channels
        // adjust_channels() zero fills channels > 2, hence can't be used here
        for (size_t i = 0; i < mTotalFrameCount; ++i) {
            auto* fp = &testInput[i * channelCount];
            std::fill(fp, fp + channelCount, monoInput[i]);
        }

        std::vector<float> testOutput(mTotalFrameCount * channelCount);
        ASSERT_NO_FATAL_FAILURE(testEffect.process(testInput.data(), testOutput.data()));
        ASSERT_NO_FATAL_FAILURE(testEffect.releaseEffect());

        // Extract first two channels
        std::vector<float> stereoTestOutput(mTotalFrameCount * FCC_2);
        adjust_channels(testOutput.data(), channelCount, stereoTestOutput.data(), FCC_2,
                        sizeof(float), mTotalFrameCount * sizeof(float) * channelCount);

        // Convert the test data to int16_t
        std::vector<int16_t> stereoTestI16(mTotalFrameCount * FCC_2);
        memcpy_to_i16_from_float(stereoTestI16.data(), stereoTestOutput.data(),
                                 mTotalFrameCount * FCC_2);

        if (EFFECT_BASS_BOOST == mEffectType) {
            // SNR must be above the threshold
            float snr = computeSnr<int16_t>(stereoRefI16.data(), stereoTestI16.data(),
                                            mTotalFrameCount * FCC_2);
            ASSERT_GT(snr, EffectTestHelper::kSNRThreshold)
                    << "SNR " << snr << "is lower than " << EffectTestHelper::kSNRThreshold;
        } else {
            ASSERT_EQ(0,
                      memcmp(stereoRefI16.data(), stereoTestI16.data(), mTotalFrameCount * FCC_2))
                    << "First two channels do not match with stereo output \n";
        }
    }
}

INSTANTIATE_TEST_SUITE_P(
        EffectBundleTestAll, SingleEffectComparisonTest,
        ::testing::Combine(::testing::Range(0, (int)EffectTestHelper::kNumSampleRates),
                           ::testing::Range(0, (int)EffectTestHelper::kNumFrameCounts),
                           ::testing::Range(0, (int)EffectTestHelper::kNumLoopCounts),
                           ::testing::Range(0, (int)kNumEffectUuids)));

using SingleEffectDefaultSetParamTestParam = std::tuple<int, int, int>;
class SingleEffectDefaultSetParamTest
    : public ::testing::TestWithParam<SingleEffectDefaultSetParamTestParam> {
  public:
    SingleEffectDefaultSetParamTest()
        : mChMask(EffectTestHelper::kChMasks[std::get<0>(GetParam())]),
          mChannelCount(audio_channel_count_from_out_mask(mChMask)),
          mSampleRate(16000),
          mFrameCount(EffectTestHelper::kFrameCounts[std::get<1>(GetParam())]),
          mLoopCount(1),
          mTotalFrameCount(mFrameCount * mLoopCount),
          mEffectType((effect_type_t)std::get<2>(GetParam())),
          mUuid(kEffectUuids.at(mEffectType)) {}

    const size_t mChMask;
    const size_t mChannelCount;
    const size_t mSampleRate;
    const size_t mFrameCount;
    const size_t mLoopCount;
    const size_t mTotalFrameCount;
    const effect_type_t mEffectType;
    const effect_uuid_t mUuid;
};

// Tests verifying that redundant setParam calls do not alter output
TEST_P(SingleEffectDefaultSetParamTest, SimpleProcess) {
    SCOPED_TRACE(testing::Message()
                 << "chMask: " << mChMask << " sampleRate: " << mSampleRate
                 << " frameCount: " << mFrameCount << " loopCount: " << mLoopCount);
    // effect.process() handles mTotalFrameCount * mChannelCount samples in each call.
    // This test calls process() twice per effect, hence total samples when allocating
    // input and output vectors is twice the number of samples processed in one call.
    size_t totalNumSamples = 2 * mTotalFrameCount * mChannelCount;
    // Initialize input buffer with deterministic pseudo-random values
    std::vector<float> input(totalNumSamples);
    std::minstd_rand gen(mChMask);
    std::uniform_real_distribution<> dis(kMinAmplitude, kMaxAmplitude);
    for (auto& in : input) {
        in = dis(gen);
    }

    uint32_t key;
    int32_t value1, value2;
    switch (mEffectType) {
        case EFFECT_BASS_BOOST:
            key = BASSBOOST_PARAM_STRENGTH;
            value1 = 1;
            value2 = 14;
            break;
        case EFFECT_VIRTUALIZER:
            key = VIRTUALIZER_PARAM_STRENGTH;
            value1 = 0;
            value2 = 100;
            break;
        case EFFECT_EQUALIZER:
            key = EQ_PARAM_CUR_PRESET;
            value1 = 0;
            value2 = 1;
            break;
        case EFFECT_VOLUME:
            key = 0 /* VOLUME_PARAM_LEVEL */;
            value1 = 0;
            value2 = -100;
            break;
        default:
            FAIL() << "Unsupported effect type : " << mEffectType;
    }

    EffectTestHelper refEffect(&mUuid, mChMask, mChMask, mSampleRate, mFrameCount, mLoopCount);

    ASSERT_NO_FATAL_FAILURE(refEffect.createEffect());
    ASSERT_NO_FATAL_FAILURE(refEffect.setConfig());

    if (EFFECT_BASS_BOOST == mEffectType) {
        ASSERT_NO_FATAL_FAILURE(refEffect.setParam<int16_t>(key, value1));
    } else {
        ASSERT_NO_FATAL_FAILURE(refEffect.setParam<int32_t>(key, value1));
    }
    std::vector<float> refOutput(totalNumSamples);
    float* pInput = input.data();
    float* pOutput = refOutput.data();
    ASSERT_NO_FATAL_FAILURE(refEffect.process(pInput, pOutput));

    pInput += totalNumSamples / 2;
    pOutput += totalNumSamples / 2;
    ASSERT_NO_FATAL_FAILURE(refEffect.process(pInput, pOutput));
    ASSERT_NO_FATAL_FAILURE(refEffect.releaseEffect());

    EffectTestHelper testEffect(&mUuid, mChMask, mChMask, mSampleRate, mFrameCount, mLoopCount);

    ASSERT_NO_FATAL_FAILURE(testEffect.createEffect());
    ASSERT_NO_FATAL_FAILURE(testEffect.setConfig());

    if (EFFECT_BASS_BOOST == mEffectType) {
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int16_t>(key, value1));
    } else {
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int32_t>(key, value1));
    }

    std::vector<float> testOutput(totalNumSamples);
    pInput = input.data();
    pOutput = testOutput.data();
    ASSERT_NO_FATAL_FAILURE(testEffect.process(pInput, pOutput));

    // Call setParam once to change the parameters, and then call setParam again
    // to restore the parameters to the initial state, making the first setParam
    // call redundant
    if (EFFECT_BASS_BOOST == mEffectType) {
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int16_t>(key, value2));
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int16_t>(key, value1));
    } else {
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int32_t>(key, value2));
        ASSERT_NO_FATAL_FAILURE(testEffect.setParam<int32_t>(key, value1));
    }

    pInput += totalNumSamples / 2;
    pOutput += totalNumSamples / 2;
    ASSERT_NO_FATAL_FAILURE(testEffect.process(pInput, pOutput));
    ASSERT_NO_FATAL_FAILURE(testEffect.releaseEffect());
    ASSERT_TRUE(areNearlySame(refOutput.data(), testOutput.data(), totalNumSamples))
            << "Outputs do not match with default setParam calls";
}

INSTANTIATE_TEST_SUITE_P(
        EffectBundleTestAll, SingleEffectDefaultSetParamTest,
        ::testing::Combine(::testing::Range(0, (int)EffectTestHelper::kNumChMasks),
                           ::testing::Range(0, (int)EffectTestHelper::kNumFrameCounts),
                           ::testing::Range(0, (int)kNumEffectUuids)));

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    int status = RUN_ALL_TESTS();
    ALOGV("Test result = %d\n", status);
    return status;
}