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

Commit b7677107 authored by Andy Hung's avatar Andy Hung
Browse files

HapticGenerator: Use HapticBiquadFilter type 

Allows greater control over Biquad implementation,
now templated on floating point type.

Test: atest SoundPoolHapticTest
Bug: 161393057
Change-Id: If0be9197251d38471dc73b2f604d966784701e30
parent 81a2b192

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,