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

Commit 88de9c4b authored by Harish Mahendrakar's avatar Harish Mahendrakar
Browse files

EffectBundleTest: Move helper class to a separate file 

This helps in extending the tests for other effects

Bug: 178513382
Test: atest EffectBundleTest
Test: atest --host EffectBundleTest

Change-Id: Id830e4b8cb496a2ac7a83c6efc3c6ed0144859b5
parent 99e9d191

media/libeffects/lvm/tests/Android.bp

+4 −1
Original line number Diff line number Diff line
@@ -15,7 +15,10 @@ cc_test { 
    gtest: true,

    host_supported: true,

    test_suites: ["device-tests"],

    srcs: ["EffectBundleTest.cpp"],

    srcs: [

        "EffectBundleTest.cpp",

        "EffectTestHelper.cpp",

    ],

    static_libs: [

        "libaudioutils",

        "libbundlewrapper",

media/libeffects/lvm/tests/EffectBundleTest.cpp

+32 −168
Original line number Diff line number Diff line
@@ -14,22 +14,8 @@ 
 * limitations under the License.

 */



#include <array>

#include <audio_utils/channels.h>

#include <audio_utils/primitives.h>

#include <climits>

#include <cstdlib>

#include <gtest/gtest.h>

#include <hardware/audio_effect.h>

#include <log/log.h>

#include <random>

#include <system/audio.h>

#include <vector>



extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;



// Corresponds to SNR for 1 bit difference between two int16_t signals

constexpr float kSNRThreshold = 90.308998;

#include "EffectTestHelper.h"

using namespace android;



// Update isBassBoost, if the order of effects is updated

constexpr effect_uuid_t kEffectUuids[] = {
@@ -50,120 +36,15 @@ static bool isBassBoost(const effect_uuid_t* uuid) { 


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



constexpr audio_channel_mask_t kChMasks[] = {

        AUDIO_CHANNEL_OUT_MONO,          AUDIO_CHANNEL_OUT_STEREO,

        AUDIO_CHANNEL_OUT_2POINT1,       AUDIO_CHANNEL_OUT_2POINT0POINT2,

        AUDIO_CHANNEL_OUT_QUAD,          AUDIO_CHANNEL_OUT_QUAD_BACK,

        AUDIO_CHANNEL_OUT_QUAD_SIDE,     AUDIO_CHANNEL_OUT_SURROUND,

        AUDIO_CHANNEL_INDEX_MASK_4,      AUDIO_CHANNEL_OUT_2POINT1POINT2,

        AUDIO_CHANNEL_OUT_3POINT0POINT2, AUDIO_CHANNEL_OUT_PENTA,

        AUDIO_CHANNEL_INDEX_MASK_5,      AUDIO_CHANNEL_OUT_3POINT1POINT2,

        AUDIO_CHANNEL_OUT_5POINT1,       AUDIO_CHANNEL_OUT_5POINT1_BACK,

        AUDIO_CHANNEL_OUT_5POINT1_SIDE,  AUDIO_CHANNEL_INDEX_MASK_6,

        AUDIO_CHANNEL_OUT_6POINT1,       AUDIO_CHANNEL_INDEX_MASK_7,

        AUDIO_CHANNEL_OUT_5POINT1POINT2, AUDIO_CHANNEL_OUT_7POINT1,

        AUDIO_CHANNEL_INDEX_MASK_8,      AUDIO_CHANNEL_INDEX_MASK_9,

        AUDIO_CHANNEL_INDEX_MASK_10,     AUDIO_CHANNEL_INDEX_MASK_11,

        AUDIO_CHANNEL_INDEX_MASK_12,     AUDIO_CHANNEL_INDEX_MASK_13,

        AUDIO_CHANNEL_INDEX_MASK_14,     AUDIO_CHANNEL_INDEX_MASK_15,

        AUDIO_CHANNEL_INDEX_MASK_16,     AUDIO_CHANNEL_INDEX_MASK_17,

        AUDIO_CHANNEL_INDEX_MASK_18,     AUDIO_CHANNEL_INDEX_MASK_19,

        AUDIO_CHANNEL_INDEX_MASK_20,     AUDIO_CHANNEL_INDEX_MASK_21,

        AUDIO_CHANNEL_INDEX_MASK_22,     AUDIO_CHANNEL_INDEX_MASK_23,

        AUDIO_CHANNEL_INDEX_MASK_24,

};



constexpr size_t kNumChMasks = std::size(kChMasks);



constexpr size_t kSampleRates[] = {8000,  11025, 12000, 16000, 22050,  24000, 32000,

                                   44100, 48000, 88200, 96000, 176400, 192000};



constexpr size_t kNumSampleRates = std::size(kSampleRates);



constexpr size_t kFrameCounts[] = {4, 2048};



constexpr size_t kNumFrameCounts = std::size(kFrameCounts);



constexpr size_t kLoopCounts[] = {1, 4};



constexpr size_t kNumLoopCounts = std::size(kLoopCounts);



class EffectBundleHelper {

  public:

    EffectBundleHelper(const effect_uuid_t* uuid, size_t chMask, size_t sampleRate,

                       size_t frameCount, size_t loopCount)

        : mUuid(uuid),

          mChMask(chMask),

          mChannelCount(audio_channel_count_from_out_mask(mChMask)),

          mSampleRate(sampleRate),

          mFrameCount(frameCount),

          mLoopCount(loopCount) {}

    void createEffect();

    void releaseEffect();

    void configEffect();

    void process(float* input, float* output);



  private:

    const effect_uuid_t* mUuid;

    const size_t mChMask;

    const size_t mChannelCount;

    const size_t mSampleRate;

    const size_t mFrameCount;

    const size_t mLoopCount;

    effect_handle_t mEffectHandle{};

};



void EffectBundleHelper::createEffect() {

    int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.create_effect(mUuid, 1, 1, &mEffectHandle);

    ASSERT_EQ(status, 0) << "create_effect returned an error " << status << "\n";

}



void EffectBundleHelper::releaseEffect() {

    int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.release_effect(mEffectHandle);

    ASSERT_EQ(status, 0) << "release_effect returned an error " << status << "\n";

}



void EffectBundleHelper::configEffect() {

    effect_config_t config{};

    config.inputCfg.samplingRate = config.outputCfg.samplingRate = mSampleRate;

    config.inputCfg.channels = config.outputCfg.channels = mChMask;

    config.inputCfg.format = config.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;



    int reply = 0;

    uint32_t replySize = sizeof(reply);

    int status = (*mEffectHandle)

                         ->command(mEffectHandle, EFFECT_CMD_SET_CONFIG, sizeof(effect_config_t),

                                   &config, &replySize, &reply);

    ASSERT_EQ(status, 0) << "command returned an error " << status << "\n";

    ASSERT_EQ(reply, 0) << "command reply non zero " << reply << "\n";



    status = (*mEffectHandle)

                     ->command(mEffectHandle, EFFECT_CMD_ENABLE, 0, nullptr, &replySize, &reply);

    ASSERT_EQ(status, 0) << "command enable returned an error " << status << "\n";

    ASSERT_EQ(reply, 0) << "command reply non zero " << reply << "\n";

}



void EffectBundleHelper::process(float* input, float* output) {

    audio_buffer_t inBuffer = {.frameCount = mFrameCount, .f32 = input};

    audio_buffer_t outBuffer = {.frameCount = mFrameCount, .f32 = output};

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

        int status = (*mEffectHandle)->process(mEffectHandle, &inBuffer, &outBuffer);

        ASSERT_EQ(status, 0) << "process returned an error " << status << "\n";



        inBuffer.f32 += mFrameCount * mChannelCount;

        outBuffer.f32 += mFrameCount * mChannelCount;

    }

}



typedef std::tuple<int, int, int, int, int> SingleEffectTestParam;

class SingleEffectTest : public ::testing::TestWithParam<SingleEffectTestParam> {

  public:

    SingleEffectTest()

        : mChMask(kChMasks[std::get<0>(GetParam())]),

        : mChMask(EffectTestHelper::kChMasks[std::get<0>(GetParam())]),

          mChannelCount(audio_channel_count_from_out_mask(mChMask)),

          mSampleRate(kSampleRates[std::get<1>(GetParam())]),

          mFrameCount(kFrameCounts[std::get<2>(GetParam())]),

          mLoopCount(kLoopCounts[std::get<3>(GetParam())]),

          mSampleRate(EffectTestHelper::kSampleRates[std::get<1>(GetParam())]),

          mFrameCount(EffectTestHelper::kFrameCounts[std::get<2>(GetParam())]),

          mLoopCount(EffectTestHelper::kLoopCounts[std::get<3>(GetParam())]),

          mTotalFrameCount(mFrameCount * mLoopCount),

          mUuid(&kEffectUuids[std::get<4>(GetParam())]) {}
@@ -182,10 +63,10 @@ TEST_P(SingleEffectTest, SimpleProcess) { 
                 << "chMask: " << mChMask << " sampleRate: " << mSampleRate

                 << " frameCount: " << mFrameCount << " loopCount: " << mLoopCount);



    EffectBundleHelper effect(mUuid, mChMask, mSampleRate, mFrameCount, mLoopCount);

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



    ASSERT_NO_FATAL_FAILURE(effect.createEffect());

    ASSERT_NO_FATAL_FAILURE(effect.configEffect());

    ASSERT_NO_FATAL_FAILURE(effect.setConfig());



    // Initialize input buffer with deterministic pseudo-random values

    std::vector<float> input(mTotalFrameCount * mChannelCount);
@@ -199,11 +80,12 @@ TEST_P(SingleEffectTest, SimpleProcess) { 
    ASSERT_NO_FATAL_FAILURE(effect.releaseEffect());

}



INSTANTIATE_TEST_SUITE_P(EffectBundleTestAll, SingleEffectTest,

                         ::testing::Combine(::testing::Range(0, (int)kNumChMasks),

                                            ::testing::Range(0, (int)kNumSampleRates),

                                            ::testing::Range(0, (int)kNumFrameCounts),

                                            ::testing::Range(0, (int)kNumLoopCounts),

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)));



typedef std::tuple<int, int, int, int> SingleEffectComparisonTestParam;
@@ -211,9 +93,9 @@ class SingleEffectComparisonTest 
    : public ::testing::TestWithParam<SingleEffectComparisonTestParam> {

  public:

    SingleEffectComparisonTest()

        : mSampleRate(kSampleRates[std::get<0>(GetParam())]),

          mFrameCount(kFrameCounts[std::get<1>(GetParam())]),

          mLoopCount(kLoopCounts[std::get<2>(GetParam())]),

        : mSampleRate(EffectTestHelper::kSampleRates[std::get<0>(GetParam())]),

          mFrameCount(EffectTestHelper::kFrameCounts[std::get<1>(GetParam())]),

          mLoopCount(EffectTestHelper::kLoopCounts[std::get<2>(GetParam())]),

          mTotalFrameCount(mFrameCount * mLoopCount),

          mUuid(&kEffectUuids[std::get<3>(GetParam())]) {}
@@ -224,26 +106,6 @@ class SingleEffectComparisonTest 
    const effect_uuid_t* mUuid;

};



template <typename T>

float computeSnr(const T* ref, const T* tst, size_t count) {

    double signal{};

    double noise{};



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

        const double value(ref[i]);

        const double diff(tst[i] - value);

        signal += value * value;

        noise += diff * diff;

    }

    // Initialized to a value greater than kSNRThreshold to handle

    // cases where ref and tst match exactly

    float snr = kSNRThreshold + 1.0f;

    if (signal > 0.0f && noise > 0.0f) {

        snr = 10.f * log(signal / noise);

    }

    return snr;

}



// 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: "
@@ -264,11 +126,11 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) { 
                    mTotalFrameCount * sizeof(float) * FCC_1);



    // Apply effect on stereo channels

    EffectBundleHelper stereoEffect(mUuid, AUDIO_CHANNEL_OUT_STEREO, mSampleRate, mFrameCount,

                                    mLoopCount);

    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.configEffect());

    ASSERT_NO_FATAL_FAILURE(stereoEffect.setConfig());



    std::vector<float> stereoOutput(mTotalFrameCount * FCC_2);

    ASSERT_NO_FATAL_FAILURE(stereoEffect.process(stereoInput.data(), stereoOutput.data()));
@@ -278,12 +140,12 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) { 
    std::vector<int16_t> stereoRefI16(mTotalFrameCount * FCC_2);

    memcpy_to_i16_from_float(stereoRefI16.data(), stereoOutput.data(), mTotalFrameCount * FCC_2);



    for (size_t chMask : kChMasks) {

    for (size_t chMask : EffectTestHelper::kChMasks) {

        size_t channelCount = audio_channel_count_from_out_mask(chMask);

        EffectBundleHelper testEffect(mUuid, chMask, mSampleRate, mFrameCount, mLoopCount);

        EffectTestHelper testEffect(mUuid, chMask, chMask, mSampleRate, mFrameCount, mLoopCount);



        ASSERT_NO_FATAL_FAILURE(testEffect.createEffect());

        ASSERT_NO_FATAL_FAILURE(testEffect.configEffect());

        ASSERT_NO_FATAL_FAILURE(testEffect.setConfig());



        std::vector<float> testInput(mTotalFrameCount * channelCount);
@@ -312,7 +174,8 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) { 
            // SNR must be above the threshold

            float snr = computeSnr<int16_t>(stereoRefI16.data(), stereoTestI16.data(),

                                            mTotalFrameCount * FCC_2);

            ASSERT_GT(snr, kSNRThreshold) << "SNR " << snr << "is lower than " << kSNRThreshold;

            ASSERT_GT(snr, EffectTestHelper::kSNRThreshold)

                    << "SNR " << snr << "is lower than " << EffectTestHelper::kSNRThreshold;

        } else {

            ASSERT_EQ(0,

                      memcmp(stereoRefI16.data(), stereoTestI16.data(), mTotalFrameCount * FCC_2))
@@ -321,10 +184,11 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) { 
    }

}



INSTANTIATE_TEST_SUITE_P(EffectBundleTestAll, SingleEffectComparisonTest,

                         ::testing::Combine(::testing::Range(0, (int)kNumSampleRates),

                                            ::testing::Range(0, (int)kNumFrameCounts),

                                            ::testing::Range(0, (int)kNumLoopCounts),

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)));



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

media/libeffects/lvm/tests/EffectTestHelper.cpp

0 → 100644
+81 −0
Original line number Diff line number Diff line 
/*

 * 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 "EffectTestHelper.h"

extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;



namespace android {



void EffectTestHelper::createEffect() {

    int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.create_effect(mUuid, 1, 1, &mEffectHandle);

    ASSERT_EQ(status, 0) << "create_effect returned an error " << status;

}



void EffectTestHelper::releaseEffect() {

    int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.release_effect(mEffectHandle);

    ASSERT_EQ(status, 0) << "release_effect returned an error " << status;

}



void EffectTestHelper::setConfig() {

    effect_config_t config{};

    config.inputCfg.samplingRate = config.outputCfg.samplingRate = mSampleRate;

    config.inputCfg.channels = mInChMask;

    config.outputCfg.channels = mOutChMask;

    config.inputCfg.format = config.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;



    int reply = 0;

    uint32_t replySize = sizeof(reply);

    int status = (*mEffectHandle)

                         ->command(mEffectHandle, EFFECT_CMD_SET_CONFIG, sizeof(effect_config_t),

                                   &config, &replySize, &reply);

    ASSERT_EQ(status, 0) << "set_config returned an error " << status;

    ASSERT_EQ(reply, 0) << "set_config reply non zero " << reply;



    status = (*mEffectHandle)

                     ->command(mEffectHandle, EFFECT_CMD_ENABLE, 0, nullptr, &replySize, &reply);

    ASSERT_EQ(status, 0) << "cmd_enable returned an error " << status;

    ASSERT_EQ(reply, 0) << "cmd_enable reply non zero " << reply;

}



void EffectTestHelper::setParam(uint32_t type, uint32_t value) {

    int reply = 0;

    uint32_t replySize = sizeof(reply);

    uint32_t paramData[2] = {type, value};

    auto effectParam = new effect_param_t[sizeof(effect_param_t) + sizeof(paramData)];

    memcpy(&effectParam->data[0], &paramData[0], sizeof(paramData));

    effectParam->psize = sizeof(paramData[0]);

    effectParam->vsize = sizeof(paramData[1]);

    int status = (*mEffectHandle)

                         ->command(mEffectHandle, EFFECT_CMD_SET_PARAM,

                                   sizeof(effect_param_t) + sizeof(paramData), effectParam,

                                   &replySize, &reply);

    delete[] effectParam;

    ASSERT_EQ(status, 0) << "set_param returned an error " << status;

    ASSERT_EQ(reply, 0) << "set_param reply non zero " << reply;

}



void EffectTestHelper::process(float* input, float* output) {

    audio_buffer_t inBuffer = {.frameCount = mFrameCount, .f32 = input};

    audio_buffer_t outBuffer = {.frameCount = mFrameCount, .f32 = output};

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

        int status = (*mEffectHandle)->process(mEffectHandle, &inBuffer, &outBuffer);

        ASSERT_EQ(status, 0) << "process returned an error " << status;



        inBuffer.f32 += mFrameCount * mInChannelCount;

        outBuffer.f32 += mFrameCount * mOutChannelCount;

    }

}

}  // namespace android

media/libeffects/lvm/tests/EffectTestHelper.h

0 → 100644
+123 −0
Original line number Diff line number Diff line 
/*

 * 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.

 */



#pragma once



#include <array>

#include <audio_utils/channels.h>

#include <audio_utils/primitives.h>

#include <climits>

#include <cstdlib>

#include <gtest/gtest.h>

#include <hardware/audio_effect.h>

#include <log/log.h>

#include <random>

#include <stdint.h>

#include <system/audio.h>

#include <vector>



namespace android {

template <typename T>

static float computeSnr(const T* ref, const T* tst, size_t count) {

    double signal{};

    double noise{};



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

        const double value(ref[i]);

        const double diff(tst[i] - value);

        signal += value * value;

        noise += diff * diff;

    }

    // Initialized to large value to handle

    // cases where ref and tst match exactly

    float snr = FLT_MAX;

    if (signal > 0.0f && noise > 0.0f) {

        snr = 10.f * log(signal / noise);

    }

    return snr;

}



class EffectTestHelper {

  public:

    EffectTestHelper(const effect_uuid_t* uuid, size_t inChMask, size_t outChMask,

                     size_t sampleRate, size_t frameCount, size_t loopCount)

        : mUuid(uuid),

          mInChMask(inChMask),

          mInChannelCount(audio_channel_count_from_out_mask(mInChMask)),

          mOutChMask(outChMask),

          mOutChannelCount(audio_channel_count_from_out_mask(mOutChMask)),

          mSampleRate(sampleRate),

          mFrameCount(frameCount),

          mLoopCount(loopCount) {}

    void createEffect();

    void releaseEffect();

    void setConfig();

    void setParam(uint32_t type, uint32_t val);

    void process(float* input, float* output);



    // Corresponds to SNR for 1 bit difference between two int16_t signals

    static constexpr float kSNRThreshold = 90.308998;



    static constexpr audio_channel_mask_t kChMasks[] = {

            AUDIO_CHANNEL_OUT_MONO,          AUDIO_CHANNEL_OUT_STEREO,

            AUDIO_CHANNEL_OUT_2POINT1,       AUDIO_CHANNEL_OUT_2POINT0POINT2,

            AUDIO_CHANNEL_OUT_QUAD,          AUDIO_CHANNEL_OUT_QUAD_BACK,

            AUDIO_CHANNEL_OUT_QUAD_SIDE,     AUDIO_CHANNEL_OUT_SURROUND,

            AUDIO_CHANNEL_INDEX_MASK_4,      AUDIO_CHANNEL_OUT_2POINT1POINT2,

            AUDIO_CHANNEL_OUT_3POINT0POINT2, AUDIO_CHANNEL_OUT_PENTA,

            AUDIO_CHANNEL_INDEX_MASK_5,      AUDIO_CHANNEL_OUT_3POINT1POINT2,

            AUDIO_CHANNEL_OUT_5POINT1,       AUDIO_CHANNEL_OUT_5POINT1_BACK,

            AUDIO_CHANNEL_OUT_5POINT1_SIDE,  AUDIO_CHANNEL_INDEX_MASK_6,

            AUDIO_CHANNEL_OUT_6POINT1,       AUDIO_CHANNEL_INDEX_MASK_7,

            AUDIO_CHANNEL_OUT_5POINT1POINT2, AUDIO_CHANNEL_OUT_7POINT1,

            AUDIO_CHANNEL_INDEX_MASK_8,      AUDIO_CHANNEL_INDEX_MASK_9,

            AUDIO_CHANNEL_INDEX_MASK_10,     AUDIO_CHANNEL_INDEX_MASK_11,

            AUDIO_CHANNEL_INDEX_MASK_12,     AUDIO_CHANNEL_INDEX_MASK_13,

            AUDIO_CHANNEL_INDEX_MASK_14,     AUDIO_CHANNEL_INDEX_MASK_15,

            AUDIO_CHANNEL_INDEX_MASK_16,     AUDIO_CHANNEL_INDEX_MASK_17,

            AUDIO_CHANNEL_INDEX_MASK_18,     AUDIO_CHANNEL_INDEX_MASK_19,

            AUDIO_CHANNEL_INDEX_MASK_20,     AUDIO_CHANNEL_INDEX_MASK_21,

            AUDIO_CHANNEL_INDEX_MASK_22,     AUDIO_CHANNEL_INDEX_MASK_23,

            AUDIO_CHANNEL_INDEX_MASK_24,

    };



    static constexpr size_t kNumChMasks = std::size(kChMasks);



    static constexpr size_t kSampleRates[] = {8000,  11025, 12000, 16000, 22050,  24000, 32000,

                                              44100, 48000, 88200, 96000, 176400, 192000};



    static constexpr size_t kNumSampleRates = std::size(kSampleRates);



    static constexpr size_t kFrameCounts[] = {4, 2048};



    static constexpr size_t kNumFrameCounts = std::size(kFrameCounts);



    static constexpr size_t kLoopCounts[] = {1, 4};



    static constexpr size_t kNumLoopCounts = std::size(kLoopCounts);



  private:

    const effect_uuid_t* mUuid;

    const size_t mInChMask;

    const size_t mInChannelCount;

    const size_t mOutChMask;

    const size_t mOutChannelCount;

    const size_t mSampleRate;

    const size_t mFrameCount;

    const size_t mLoopCount;

    effect_handle_t mEffectHandle{};

};

}  // namespace android