media/libeffects/tests/common/EffectTestHelper.h - LeafOS-Project/android_frameworks_av - Gitiles

 /*
  * 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 <dlfcn.h>
 #include <gtest/gtest.h>
 #include <hardware/audio_effect.h>
 #include <log/log.h>
 #include <random>
 #include <stdint.h>
 #include <system/audio.h>
 #include <vector>

 extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;
 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;
 }

 template <typename T>
 static float areNearlySame(const T* ref, const T* tst, size_t count) {
     T delta;
     if constexpr (std::is_floating_point_v<T>) {
         delta = std::numeric_limits<T>::epsilon();
     } else {
         delta = 1;
     }
     for (size_t i = 0; i < count; ++i) {
         const double diff(tst[i] - ref[i]);
         if (abs(diff) > delta) {
             return false;
         }
     }
     return true;
 }

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

     template <typename VALUE_DTYPE>
     void setParam(uint32_t type, VALUE_DTYPE const value) {
         int reply = 0;
         uint32_t replySize = sizeof(reply);

         uint8_t paramData[sizeof(effect_param_t) + sizeof(type) + sizeof(value)];
         auto effectParam = (effect_param_t*)paramData;

         memcpy(&effectParam->data[0], &type, sizeof(type));
         memcpy(&effectParam->data[sizeof(type)], &value, sizeof(value));
         effectParam->psize = sizeof(type);
         effectParam->vsize = sizeof(value);
         int status = (*mEffectHandle)
                              ->command(mEffectHandle, EFFECT_CMD_SET_PARAM,
                                        sizeof(effect_param_t) + sizeof(type) + sizeof(value),
                                        effectParam, &replySize, &reply);
         ASSERT_EQ(status, 0) << "set_param returned an error " << status;
         ASSERT_EQ(reply, 0) << "set_param reply non zero " << reply;
     };

     template <bool MULTI_VALUES, typename T>
     int32_t getParam(uint32_t type, std::vector<T>& values) {
         const int kMaxEffectParamValues = 10;
         uint32_t cmd[sizeof(effect_param_t) / sizeof(uint32_t) + 1];
         uint32_t reply[sizeof(effect_param_t) / sizeof(uint32_t) + 1 + 1 + kMaxEffectParamValues];

         effect_param_t* p = (effect_param_t*)cmd;
         p->psize = sizeof(uint32_t);
         if (MULTI_VALUES) {
             p->vsize = (kMaxEffectParamValues + 1) * sizeof(T);
         } else {
             p->vsize = sizeof(T);
         }
         *(uint32_t*)p->data = type;
         uint32_t replySize = sizeof(effect_param_t) + p->psize + p->vsize;

         int32_t status = (*mEffectHandle)
                                  ->command(mEffectHandle, EFFECT_CMD_GET_PARAM,
                                            sizeof(effect_param_t) + sizeof(uint32_t), cmd,
                                            &replySize, reply);
         if (status) {
             return status;
         }
         if (p->status) {
             return p->status;
         }
         if (replySize <
             sizeof(effect_param_t) + sizeof(uint32_t) + (MULTI_VALUES ? 2 : 1) * sizeof(T)) {
             return -EINVAL;
         }

         T* params = (T*)((uint8_t*)reply + sizeof(effect_param_t) + sizeof(uint32_t));
         int numParams = 1;
         if (MULTI_VALUES) {
             numParams = (int)*params++;
         }
         if (numParams > kMaxEffectParamValues) {
             return -EINVAL;
         }
         values.clear();
         std::copy(&params[0], &params[numParams], back_inserter(values));
         return 0;
     }

     template <typename T>
     int setParam(uint32_t type, const std::vector<T>& values) {
         int reply = 0;
         uint32_t replySize = sizeof(reply);

         uint32_t cmd[sizeof(effect_param_t) / sizeof(uint32_t) + 1 + values.size()];
         effect_param_t* p = (effect_param_t*)cmd;
         p->psize = sizeof(uint32_t);
         p->vsize = sizeof(T) * values.size();
         *(uint32_t*)p->data = type;
         memcpy((uint32_t*)p->data + 1, values.data(), sizeof(T) * values.size());

         int status = (*mEffectHandle)
                              ->command(mEffectHandle, EFFECT_CMD_SET_PARAM,
                                        sizeof(effect_param_t) + p->psize + p->vsize, p, &replySize,
                                        &reply);
         if (status) {
             return status;
         }
         if (reply) {
             return reply;
         }
         return 0;
     }

     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
	/*
	* 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 <dlfcn.h>
	#include <gtest/gtest.h>
	#include <hardware/audio_effect.h>
	#include <log/log.h>
	#include <random>
	#include <stdint.h>
	#include <system/audio.h>
	#include <vector>

	extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;
	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;
	}

	template <typename T>
	static float areNearlySame(const T* ref, const T* tst, size_t count) {
	T delta;
	if constexpr (std::is_floating_point_v<T>) {
	delta = std::numeric_limits<T>::epsilon();
	} else {
	delta = 1;
	}
	for (size_t i = 0; i < count; ++i) {
	const double diff(tst[i] - ref[i]);
	if (abs(diff) > delta) {
	return false;
	}
	}
	return true;
	}

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

	template <typename VALUE_DTYPE>
	void setParam(uint32_t type, VALUE_DTYPE const value) {
	int reply = 0;
	uint32_t replySize = sizeof(reply);

	uint8_t paramData[sizeof(effect_param_t) + sizeof(type) + sizeof(value)];
	auto effectParam = (effect_param_t*)paramData;

	memcpy(&effectParam->data[0], &type, sizeof(type));
	memcpy(&effectParam->data[sizeof(type)], &value, sizeof(value));
	effectParam->psize = sizeof(type);
	effectParam->vsize = sizeof(value);
	int status = (*mEffectHandle)
	->command(mEffectHandle, EFFECT_CMD_SET_PARAM,
	sizeof(effect_param_t) + sizeof(type) + sizeof(value),
	effectParam, &replySize, &reply);
	ASSERT_EQ(status, 0) << "set_param returned an error " << status;
	ASSERT_EQ(reply, 0) << "set_param reply non zero " << reply;
	};

	template <bool MULTI_VALUES, typename T>
	int32_t getParam(uint32_t type, std::vector<T>& values) {
	const int kMaxEffectParamValues = 10;
	uint32_t cmd[sizeof(effect_param_t) / sizeof(uint32_t) + 1];
	uint32_t reply[sizeof(effect_param_t) / sizeof(uint32_t) + 1 + 1 + kMaxEffectParamValues];

	effect_param_t* p = (effect_param_t*)cmd;
	p->psize = sizeof(uint32_t);
	if (MULTI_VALUES) {
	p->vsize = (kMaxEffectParamValues + 1) * sizeof(T);
	} else {
	p->vsize = sizeof(T);
	}
	(uint32_t)p->data = type;
	uint32_t replySize = sizeof(effect_param_t) + p->psize + p->vsize;

	int32_t status = (*mEffectHandle)
	->command(mEffectHandle, EFFECT_CMD_GET_PARAM,
	sizeof(effect_param_t) + sizeof(uint32_t), cmd,
	&replySize, reply);
	if (status) {
	return status;
	}
	if (p->status) {
	return p->status;
	}
	if (replySize <
	sizeof(effect_param_t) + sizeof(uint32_t) + (MULTI_VALUES ? 2 : 1) * sizeof(T)) {
	return -EINVAL;
	}

	T* params = (T)((uint8_t)reply + sizeof(effect_param_t) + sizeof(uint32_t));
	int numParams = 1;
	if (MULTI_VALUES) {
	numParams = (int)*params++;
	}
	if (numParams > kMaxEffectParamValues) {
	return -EINVAL;
	}
	values.clear();
	std::copy(&params[0], &params[numParams], back_inserter(values));
	return 0;
	}

	template <typename T>
	int setParam(uint32_t type, const std::vector<T>& values) {
	int reply = 0;
	uint32_t replySize = sizeof(reply);

	uint32_t cmd[sizeof(effect_param_t) / sizeof(uint32_t) + 1 + values.size()];
	effect_param_t* p = (effect_param_t*)cmd;
	p->psize = sizeof(uint32_t);
	p->vsize = sizeof(T) * values.size();
	(uint32_t)p->data = type;
	memcpy((uint32_t)p->data + 1, values.data(), sizeof(T) values.size());

	int status = (*mEffectHandle)
	->command(mEffectHandle, EFFECT_CMD_SET_PARAM,
	sizeof(effect_param_t) + p->psize + p->vsize, p, &replySize,
	&reply);
	if (status) {
	return status;
	}
	if (reply) {
	return reply;
	}
	return 0;
	}

	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