Merge "HapticGenerator: Use HapticBiquadFilter type" (fda80af0) · Commits · e / os / android_frameworks_av

media/libeffects/hapticgenerator/EffectHapticGenerator.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -108,7 +108,7 @@ int HapticGenerator_Init(struct HapticGeneratorContext *context) {
		void addBiquadFilter(
		std::vector<std::function<void(float , const float , size_t)>> &processingChain,
		struct HapticGeneratorProcessorsRecord &processorsRecord,
		std::shared_ptr<BiquadFilter> filter) {
		std::shared_ptr<HapticBiquadFilter> filter) {
		// The process chain captures the shared pointer of the filter in lambda.
		// The process record will keep a shared pointer to the filter so that it is possible to access
		// the filter outside of the process chain.

media/libeffects/hapticgenerator/EffectHapticGenerator.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ struct HapticGeneratorParam {

		// A structure to keep all shared pointers for all processors in HapticGenerator.
		struct HapticGeneratorProcessorsRecord {
		std::vector<std::shared_ptr<BiquadFilter>> filters;
		std::vector<std::shared_ptr<HapticBiquadFilter>> filters;
		std::vector<std::shared_ptr<Ramp>> ramps;
		std::vector<std::shared_ptr<SlowEnvelope>> slowEnvs;
		};

media/libeffects/hapticgenerator/Processors.cpp

+14 −14

Original line number	Diff line number	Diff line
		@@ -134,22 +134,22 @@ BiquadFilterCoefficients lpfCoefs(const float cornerFrequency, const float sampl
		return coefficient;
		}

		std::shared_ptr<BiquadFilter> createLPF(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createLPF(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount) {
		BiquadFilterCoefficients coefficient = lpfCoefs(cornerFrequency, sampleRate);
		return std::make_shared<BiquadFilter>(channelCount, coefficient);
		return std::make_shared<HapticBiquadFilter>(channelCount, coefficient);
		}

		std::shared_ptr<BiquadFilter> createLPF2(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createLPF2(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount) {
		BiquadFilterCoefficients coefficient = lpfCoefs(cornerFrequency, sampleRate);
		return std::make_shared<BiquadFilter>(
		return std::make_shared<HapticBiquadFilter>(
		channelCount, cascadeFirstOrderFilters(coefficient, coefficient));
		}

		std::shared_ptr<BiquadFilter> createHPF2(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createHPF2(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount) {
		BiquadFilterCoefficients coefficient;
		@@ -162,7 +162,7 @@ std::shared_ptr<BiquadFilter> createHPF2(const float cornerFrequency,
		coefficient[2] = 0.0f;
		coefficient[3] = -realPoleZ;
		coefficient[4] = 0.0f;
		return std::make_shared<BiquadFilter>(
		return std::make_shared<HapticBiquadFilter>(
		channelCount, cascadeFirstOrderFilters(coefficient, coefficient));
		}

		@@ -178,24 +178,24 @@ BiquadFilterCoefficients apfCoefs(const float cornerFrequency, const float sampl
		return coefficient;
		}

		std::shared_ptr<BiquadFilter> createAPF(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createAPF(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount) {
		BiquadFilterCoefficients coefficient = apfCoefs(cornerFrequency, sampleRate);
		return std::make_shared<BiquadFilter>(channelCount, coefficient);
		return std::make_shared<HapticBiquadFilter>(channelCount, coefficient);
		}

		std::shared_ptr<BiquadFilter> createAPF2(const float cornerFrequency1,
		std::shared_ptr<HapticBiquadFilter> createAPF2(const float cornerFrequency1,
		const float cornerFrequency2,
		const float sampleRate,
		const size_t channelCount) {
		BiquadFilterCoefficients coefs1 = apfCoefs(cornerFrequency1, sampleRate);
		BiquadFilterCoefficients coefs2 = apfCoefs(cornerFrequency2, sampleRate);
		return std::make_shared<BiquadFilter>(
		return std::make_shared<HapticBiquadFilter>(
		channelCount, cascadeFirstOrderFilters(coefs1, coefs2));
		}

		std::shared_ptr<BiquadFilter> createBPF(const float ringingFrequency,
		std::shared_ptr<HapticBiquadFilter> createBPF(const float ringingFrequency,
		const float q,
		const float sampleRate,
		const size_t channelCount) {
		@@ -207,10 +207,10 @@ std::shared_ptr<BiquadFilter> createBPF(const float ringingFrequency,
		coefficient[2] = 0.0f;
		coefficient[3] = -2 * real;
		coefficient[4] = real * real + img * img;
		return std::make_shared<BiquadFilter>(channelCount, coefficient);
		return std::make_shared<HapticBiquadFilter>(channelCount, coefficient);
		}

		std::shared_ptr<BiquadFilter> createBSF(const float ringingFrequency,
		std::shared_ptr<HapticBiquadFilter> createBSF(const float ringingFrequency,
		const float zq,
		const float pq,
		const float sampleRate,
		@@ -228,7 +228,7 @@ std::shared_ptr<BiquadFilter> createBSF(const float ringingFrequency,
		coefficient[2] = zeroCoeff2 * norm;
		coefficient[3] = poleCoeff1;
		coefficient[4] = poleCoeff2;
		return std::make_shared<BiquadFilter>(channelCount, coefficient);
		return std::make_shared<HapticBiquadFilter>(channelCount, coefficient);
		}

		} // namespace android::audio_effect::haptic_generator

media/libeffects/hapticgenerator/Processors.h

+9 −9

Original line number	Diff line number	Diff line
		@@ -24,7 +24,7 @@

		#include <audio_utils/BiquadFilter.h>

		using android::audio_utils::BiquadFilter;
		using HapticBiquadFilter = android::audio_utils::BiquadFilter<float>;
		using BiquadFilterCoefficients = std::array<float, android::audio_utils::kBiquadNumCoefs>;

		namespace android::audio_effect::haptic_generator {
		@@ -51,7 +51,7 @@ public:
		void clear();

		private:
		const std::shared_ptr<BiquadFilter> mLpf;
		const std::shared_ptr<HapticBiquadFilter> mLpf;
		std::vector<float> mLpfInBuffer;
		std::vector<float> mLpfOutBuffer;
		const float mNormalizationPower;
		@@ -64,36 +64,36 @@ private:
		BiquadFilterCoefficients cascadeFirstOrderFilters(const BiquadFilterCoefficients &coefs1,
		const BiquadFilterCoefficients &coefs2);

		std::shared_ptr<BiquadFilter> createLPF(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createLPF(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount);

		// Create two cascaded LPF with same corner frequency.
		std::shared_ptr<BiquadFilter> createLPF2(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createLPF2(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount);

		// Create two cascaded HPF with same corner frequency.
		std::shared_ptr<BiquadFilter> createHPF2(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createHPF2(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount);

		std::shared_ptr<BiquadFilter> createAPF(const float cornerFrequency,
		std::shared_ptr<HapticBiquadFilter> createAPF(const float cornerFrequency,
		const float sampleRate,
		const size_t channelCount);

		// Create two cascaded APF with two different corner frequency.
		std::shared_ptr<BiquadFilter> createAPF2(const float cornerFrequency1,
		std::shared_ptr<HapticBiquadFilter> createAPF2(const float cornerFrequency1,
		const float cornerFrequency2,
		const float sampleRate,
		const size_t channelCount);

		std::shared_ptr<BiquadFilter> createBPF(const float ringingFrequency,
		std::shared_ptr<HapticBiquadFilter> createBPF(const float ringingFrequency,
		const float q,
		const float sampleRate,
		const size_t channelCount);

		std::shared_ptr<BiquadFilter> createBSF(const float ringingFrequency,
		std::shared_ptr<HapticBiquadFilter> createBSF(const float ringingFrequency,
		const float zq,
		const float pq,
		const float sampleRate,