Snap for 7717622 from 4cd7136c4d9b80f0f1478b2f81679e7cf67bcb8e to sc-v2-release (6eae8c99) · Commits · e / os / android_frameworks_av

media/libeffects/downmix/benchmark/downmix_benchmark.cpp

+22 −22

Original line number	Diff line number	Diff line
		@@ -64,28 +64,28 @@ Pixel 4XL
		--------------------------------------------------------
		Benchmark Time CPU Iterations
		--------------------------------------------------------
		BM_Downmix/0 3553 ns 3545 ns 197503 AUDIO_CHANNEL_OUT_MONO
		BM_Downmix/1 2846 ns 2840 ns 202849
		BM_Downmix/2 4436 ns 4426 ns 158176 AUDIO_CHANNEL_OUT_STEREO
		BM_Downmix/3 5320 ns 5307 ns 131870 AUDIO_CHANNEL_OUT_2POINT1
		BM_Downmix/4 4437 ns 4426 ns 159523 AUDIO_CHANNEL_OUT_2POINT0POINT2
		BM_Downmix/5 2493 ns 2487 ns 281496 AUDIO_CHANNEL_OUT_QUAD
		BM_Downmix/6 2493 ns 2487 ns 281456 AUDIO_CHANNEL_OUT_QUAD_SIDE
		BM_Downmix/7 6204 ns 6188 ns 115044 AUDIO_CHANNEL_OUT_SURROUND
		BM_Downmix/8 5320 ns 5307 ns 100000 AUDIO_CHANNEL_OUT_2POINT1POINT2
		BM_Downmix/9 5320 ns 5307 ns 100000 AUDIO_CHANNEL_OUT_3POINT0POINT2
		BM_Downmix/10 7088 ns 7071 ns 108264 AUDIO_CHANNEL_OUT_PENTA
		BM_Downmix/11 6203 ns 6188 ns 117021 AUDIO_CHANNEL_OUT_3POINT1POINT2
		BM_Downmix/12 3105 ns 3097 ns 226182 AUDIO_CHANNEL_OUT_5POINT1
		BM_Downmix/13 3112 ns 3105 ns 225488 AUDIO_CHANNEL_OUT_5POINT1_SIDE
		BM_Downmix/14 8855 ns 8831 ns 79265 AUDIO_CHANNEL_OUT_6POINT1
		BM_Downmix/15 7971 ns 7951 ns 90918 AUDIO_CHANNEL_OUT_5POINT1POINT2
		BM_Downmix/16 3547 ns 3539 ns 197780 AUDIO_CHANNEL_OUT_7POINT1
		BM_Downmix/17 7972 ns 7953 ns 90101 AUDIO_CHANNEL_OUT_5POINT1POINT4
		BM_Downmix/18 9737 ns 9714 ns 72773 AUDIO_CHANNEL_OUT_7POINT1POINT2
		BM_Downmix/19 9745 ns 9721 ns 72015 AUDIO_CHANNEL_OUT_7POINT1POINT4
		BM_Downmix/20 7070 ns 7053 ns 109476 AUDIO_CHANNEL_OUT_13POINT_360RA
		BM_Downmix/21 12413 ns 12381 ns 57455 AUDIO_CHANNEL_OUT_22POINT2
		BM_Downmix/0 2845 ns 2839 ns 246585 AUDIO_CHANNEL_OUT_MONO
		BM_Downmix/1 2844 ns 2838 ns 246599
		BM_Downmix/2 3727 ns 3719 ns 188227 AUDIO_CHANNEL_OUT_STEREO
		BM_Downmix/3 4609 ns 4600 ns 152148 AUDIO_CHANNEL_OUT_2POINT1
		BM_Downmix/4 3727 ns 3719 ns 188228 AUDIO_CHANNEL_OUT_2POINT0POINT2
		BM_Downmix/5 1787 ns 1784 ns 392384 AUDIO_CHANNEL_OUT_QUAD
		BM_Downmix/6 1787 ns 1783 ns 392527 AUDIO_CHANNEL_OUT_QUAD_SIDE
		BM_Downmix/7 5493 ns 5481 ns 127740 AUDIO_CHANNEL_OUT_SURROUND
		BM_Downmix/8 4610 ns 4600 ns 152168 AUDIO_CHANNEL_OUT_2POINT1POINT2
		BM_Downmix/9 4610 ns 4600 ns 152162 AUDIO_CHANNEL_OUT_3POINT0POINT2
		BM_Downmix/10 6377 ns 6362 ns 110042 AUDIO_CHANNEL_OUT_PENTA
		BM_Downmix/11 5493 ns 5481 ns 127683 AUDIO_CHANNEL_OUT_3POINT1POINT2
		BM_Downmix/12 2758 ns 2752 ns 251488 AUDIO_CHANNEL_OUT_5POINT1
		BM_Downmix/13 2683 ns 2677 ns 261421 AUDIO_CHANNEL_OUT_5POINT1_SIDE
		BM_Downmix/14 8141 ns 8124 ns 86157 AUDIO_CHANNEL_OUT_6POINT1
		BM_Downmix/15 7265 ns 7249 ns 96554 AUDIO_CHANNEL_OUT_5POINT1POINT2
		BM_Downmix/16 3158 ns 3151 ns 222188 AUDIO_CHANNEL_OUT_7POINT1
		BM_Downmix/17 7291 ns 7276 ns 96226 AUDIO_CHANNEL_OUT_5POINT1POINT4
		BM_Downmix/18 9050 ns 9031 ns 77512 AUDIO_CHANNEL_OUT_7POINT1POINT2
		BM_Downmix/19 9056 ns 9036 ns 77467 AUDIO_CHANNEL_OUT_7POINT1POINT4
		BM_Downmix/20 6426 ns 6412 ns 109164 AUDIO_CHANNEL_OUT_13POINT_360RA
		BM_Downmix/21 11743 ns 11716 ns 59762 AUDIO_CHANNEL_OUT_22POINT2
		*/

		static void BM_Downmix(benchmark::State& state) {

media/libeffects/downmix/tests/downmix_tests.cpp

+11 −11

Original line number	Diff line number	Diff line
		@@ -56,17 +56,17 @@ static constexpr audio_channel_mask_t kConsideredChannels =
		(audio_channel_mask_t)(AUDIO_CHANNEL_OUT_7POINT1 \| AUDIO_CHANNEL_OUT_BACK_CENTER);

		constexpr inline float kScaleFromChannelIdx[] = {
		0.5f, // AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1u,
		0.5f, // AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2u,
		0.5f * M_SQRT1_2, // AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4u,
		0.5f * M_SQRT1_2, // AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8u,
		0.5f, // AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10u,
		0.5f, // AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20u,
		1.f, // AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1u,
		1.f, // AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2u,
		M_SQRT1_2, // AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4u,
		0.5f, // AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8u,
		M_SQRT1_2, // AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10u,
		M_SQRT1_2, // AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20u,
		0, // AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40u,
		0, // AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80u,
		0.5f * M_SQRT1_2, // AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100u,
		0.5f, // AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200u,
		0.5f, // AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400u,
		0.5f, // AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100u,
		M_SQRT1_2, // AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200u,
		M_SQRT1_2, // AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400u,
		0, // AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800u,
		0, // AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000u,
		0, // AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000u,

media/libeffects/lvm/lib/Eq/src/LVEQNB_Control.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -313,9 +313,9 @@ LVEQNB_ReturnStatus_en LVEQNB_Control(LVEQNB_Handle_t hInstance, LVEQNB_Params_t
		*/
		pInstance->eqBiquad.resize(pParams->NBands,
		android::audio_utils::BiquadFilter<LVM_FLOAT>(pParams->NrChannels));
		LVEQNB_ClearFilterHistory(pInstance);

		if (bChange \|\| modeChange) {
		LVEQNB_ClearFilterHistory(pInstance);
		/*
		* If the sample rate has changed clear the history
		*/

media/libeffects/lvm/tests/EffectBundleTest.cpp

+167 −24

Original line number	Diff line number	Diff line
		@@ -14,29 +14,39 @@
		* 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;

		// Update isBassBoost, if the order of effects is updated
		constexpr effect_uuid_t kEffectUuids[] = {
		const std::map<effect_type_t, effect_uuid_t> kEffectUuids = {
		// NXP SW BassBoost
		{0x8631f300, 0x72e2, 0x11df, 0xb57e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
		// NXP SW Virtualizer
		{0x1d4033c0, 0x8557, 0x11df, 0x9f2d, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
		{EFFECT_BASS_BOOST,
		{0x8631f300, 0x72e2, 0x11df, 0xb57e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
		// NXP SW Equalizer
		{0xce772f20, 0x847d, 0x11df, 0xbb17, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
		{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
		{0x119341a0, 0x8469, 0x11df, 0x81f9, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
		{EFFECT_VOLUME, {0x119341a0, 0x8469, 0x11df, 0x81f9, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}},
		};

		static bool isBassBoost(const effect_uuid_t* uuid) {
		// Update this, if the order of effects in kEffectUuids is updated
		return uuid == &kEffectUuids[0];
		}
		const size_t kNumEffectUuids = std::size(kEffectUuids);

		constexpr size_t kNumEffectUuids = std::size(kEffectUuids);
		constexpr float kMinAmplitude = -1.0f;
		constexpr float kMaxAmplitude = 1.0f;

		typedef std::tuple<int, int, int, int, int> SingleEffectTestParam;
		using SingleEffectTestParam = std::tuple<int, int, int, int, int>;
		class SingleEffectTest : public ::testing::TestWithParam<SingleEffectTestParam> {
		public:
		SingleEffectTest()
		@@ -46,7 +56,8 @@ class SingleEffectTest : public ::testing::TestWithParam<SingleEffectTestParam>
		mFrameCount(EffectTestHelper::kFrameCounts[std::get<2>(GetParam())]),
		mLoopCount(EffectTestHelper::kLoopCounts[std::get<3>(GetParam())]),
		mTotalFrameCount(mFrameCount * mLoopCount),
		mUuid(&kEffectUuids[std::get<4>(GetParam())]) {}
		mEffectType((effect_type_t)std::get<4>(GetParam())),
		mUuid(kEffectUuids.at(mEffectType)) {}

		const size_t mChMask;
		const size_t mChannelCount;
		@@ -54,7 +65,8 @@ class SingleEffectTest : public ::testing::TestWithParam<SingleEffectTestParam>
		const size_t mFrameCount;
		const size_t mLoopCount;
		const size_t mTotalFrameCount;
		const effect_uuid_t* mUuid;
		const effect_type_t mEffectType;
		const effect_uuid_t mUuid;
		};

		// Tests applying a single effect
		@@ -63,7 +75,7 @@ TEST_P(SingleEffectTest, SimpleProcess) {
		<< "chMask: " << mChMask << " sampleRate: " << mSampleRate
		<< " frameCount: " << mFrameCount << " loopCount: " << mLoopCount);

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

		ASSERT_NO_FATAL_FAILURE(effect.createEffect());
		ASSERT_NO_FATAL_FAILURE(effect.setConfig());
		@@ -72,7 +84,7 @@ TEST_P(SingleEffectTest, SimpleProcess) {
		std::vector<float> input(mTotalFrameCount * mChannelCount);
		std::vector<float> output(mTotalFrameCount * mChannelCount);
		std::minstd_rand gen(mChMask);
		std::uniform_real_distribution<> dis(-1.0f, 1.0f);
		std::uniform_real_distribution<> dis(kMinAmplitude, kMaxAmplitude);
		for (auto& in : input) {
		in = dis(gen);
		}
		@@ -88,7 +100,7 @@ INSTANTIATE_TEST_SUITE_P(
		::testing::Range(0, (int)EffectTestHelper::kNumLoopCounts),
		::testing::Range(0, (int)kNumEffectUuids)));

		typedef std::tuple<int, int, int, int> SingleEffectComparisonTestParam;
		using SingleEffectComparisonTestParam = std::tuple<int, int, int, int>;
		class SingleEffectComparisonTest
		: public ::testing::TestWithParam<SingleEffectComparisonTestParam> {
		public:
		@@ -97,13 +109,15 @@ class SingleEffectComparisonTest
		mFrameCount(EffectTestHelper::kFrameCounts[std::get<1>(GetParam())]),
		mLoopCount(EffectTestHelper::kLoopCounts[std::get<2>(GetParam())]),
		mTotalFrameCount(mFrameCount * mLoopCount),
		mUuid(&kEffectUuids[std::get<3>(GetParam())]) {}
		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_uuid_t* mUuid;
		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
		@@ -115,7 +129,7 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) {
		std::vector<float> monoInput(mTotalFrameCount);

		std::minstd_rand gen(mSampleRate);
		std::uniform_real_distribution<> dis(-1.0f, 1.0f);
		std::uniform_real_distribution<> dis(kMinAmplitude, kMaxAmplitude);
		for (auto& in : monoInput) {
		in = dis(gen);
		}
		@@ -126,7 +140,7 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) {
		mTotalFrameCount * sizeof(float) * FCC_1);

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

		ASSERT_NO_FATAL_FAILURE(stereoEffect.createEffect());
		@@ -142,7 +156,7 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) {

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

		ASSERT_NO_FATAL_FAILURE(testEffect.createEffect());
		ASSERT_NO_FATAL_FAILURE(testEffect.setConfig());
		@@ -170,7 +184,7 @@ TEST_P(SingleEffectComparisonTest, SimpleProcess) {
		memcpy_to_i16_from_float(stereoTestI16.data(), stereoTestOutput.data(),
		mTotalFrameCount * FCC_2);

		if (isBassBoost(mUuid)) {
		if (EFFECT_BASS_BOOST == mEffectType) {
		// SNR must be above the threshold
		float snr = computeSnr<int16_t>(stereoRefI16.data(), stereoTestI16.data(),
		mTotalFrameCount * FCC_2);
		@@ -191,6 +205,135 @@ INSTANTIATE_TEST_SUITE_P(
		::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();

media/libeffects/lvm/tests/EffectTestHelper.cpp

+0 −17

Original line number	Diff line number	Diff line
		@@ -50,23 +50,6 @@ void EffectTestHelper::setConfig() {
		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};