EqFilter.h

Go to the documentation of this file.

/*
 * eqfilter.cpp - defination of EqFilterclass.
 *
 * Copyright (c) 2014 David French <dave/dot/french3/at/googlemail/dot/com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef EQFILTER_H
#define EQFILTER_H
 
#include <numbers>
 
#include "BasicFilters.h"
#include "lmms_math.h"
 
namespace lmms
{

class EqFilter
{
public:
        EqFilter() :
                m_sampleRate(0),
                m_freq(0),
                m_res(0),
                m_gain(0),
                m_bw(0)
        {
 
        }
 
 
 
 
        virtual inline void setSampleRate( int sampleRate )
        {
                if( sampleRate != m_sampleRate )
                {
                        m_sampleRate = sampleRate;
                        calcCoefficents();
                }
        }
 
 
 
 
        virtual inline void setFrequency( float freq ){
                if ( freq != m_freq )
                {
                        m_freq = freq;
                        calcCoefficents();
                }
        }
 
 
 
 
        virtual inline void setQ( float res )
        {
                if ( res != m_res )
                {
                        m_res = res;
                        calcCoefficents();
                }
        }
 
 
 
 
        virtual inline void setGain( float gain )
        {
                if ( gain != m_gain )
                {
                        m_gain = gain;
                        calcCoefficents();
                }
        }
 
 
 
        virtual inline void setParameters( float sampleRate, float freq, float res, float gain )
        {
                bool hasChanged = ( sampleRate != m_sampleRate ||
                                    freq != m_freq ||
                                    res != m_res ||
                                    gain != m_gain );
                if ( hasChanged )
                {
                        m_sampleRate = sampleRate;
                        m_freq = freq;
                        m_res = res;
                        m_gain = gain;
                        calcCoefficents();
                }
        }
 

        inline float update( float in, ch_cnt_t ch, float frameProgress)
        {
                float initailF =  m_biQuadFrameInitial.update( in, ch );
                float targetF = m_biQuadFrameTarget.update( in, ch );
 
                if(frameProgress > 0.99999 )
                {
                        m_biQuadFrameInitial= m_biQuadFrameTarget;
                }
 
                return (1.0f-frameProgress) * initailF + frameProgress * targetF;
 
        }
 
 
protected:
        virtual void calcCoefficents(){
                setCoeffs( 0, 0, 0, 0, 0 );
 
        }
 
        inline void setCoeffs( float a1, float a2, float b0, float b1, float b2 )
        {
                m_biQuadFrameTarget.setCoeffs( a1, a2, b0, b1, b2 );
        }
 
 
 
 
 
 
        float m_sampleRate;
        float m_freq;
        float m_res;
        float m_gain;
        float m_bw;
        StereoBiQuad m_biQuadFrameInitial;
        StereoBiQuad m_biQuadFrameTarget;
};
 
 
 

class EqHp12Filter : public EqFilter
{
public :
        void calcCoefficents() override
        {
 
                // calc intermediate
                float w0 = 2 * std::numbers::pi_v<float> * m_freq / m_sampleRate;
                float c = std::cos(w0);
                float s = std::sin(w0);
                float alpha = s / ( 2 * m_res );
 
                //calc coefficents
                float b0 = (1 + c) * 0.5;
                float b1 = (-(1 + c));
                float b2 = (1 + c) * 0.5;
                float a0 = 1 + alpha;
                float a1 = (-2 * c);
                float a2 = 1 - alpha;
 
                //normalise
                b0 /= a0;
                b1 /= a0;
                b2 /= a0;
                a1 /= a0;
                a2 /= a0;
 
                a0 = 1;
 
                setCoeffs( a1, a2, b0, b1, b2 );
 
 
        }
};
 
 
 

class EqLp12Filter : public EqFilter
{
public :
        void calcCoefficents() override
        {
 
                // calc intermediate
                float w0 = 2 * std::numbers::pi_v<float> * m_freq / m_sampleRate;
                float c = std::cos(w0);
                float s = std::sin(w0);
                float alpha = s / ( 2 * m_res );
 
                //calc coefficents
                float b0 = (1 - c) * 0.5;
                float b1 = 1 - c;
                float b2 = (1 - c) * 0.5;
                float a0 = 1 + alpha;
                float a1 = -2 * c;
                float a2 = 1 - alpha;
 
                //normalise
                b0 /= a0;
                b1 /= a0;
                b2 /= a0;
                a1 /= a0;
                a2 /= a0;
 
                a0 = 1;
 
                setCoeffs( a1, a2, b0, b1, b2 );
        }
};
 
 

class EqPeakFilter : public EqFilter
{
public:
 
 
        void calcCoefficents() override
        {
                using namespace std::numbers;
                // calc intermediate
                float w0 = 2 * pi_v<float> * m_freq / m_sampleRate;
                float c = std::cos(w0);
                float s = std::sin(w0);
                float A = fastPow10f(m_gain * 0.025);
                float alpha = s * std::sinh(ln2 / 2 * m_bw * w0 / std::sin(w0));
 
                //calc coefficents
                float b0 = 1 + alpha * A;
                float b1 = -2 * c;
                float b2 = 1 - alpha * A;
                float a0 = 1 + alpha / A;
                float a1 = -2 * c;
                float a2 = 1 - alpha / A;
 
                //normalise
                b0 /= a0;
                b1 /= a0;
                b2 /= a0;
                a1 /= a0;
                a2 /= a0;
                a0 = 1;
 
                setCoeffs( a1, a2, b0, b1, b2 );
        }
 
        inline void setParameters( float sampleRate, float freq, float bw, float gain ) override
        {
                bool hasChanged = false;
                if( sampleRate != m_sampleRate )
                {
                        m_sampleRate = sampleRate;
                        hasChanged = true;
                }
                if ( freq != m_freq )
                {
                        m_freq = freq;
                        hasChanged = true;
                }
                if ( bw != m_bw )
                {
                        m_bw = bw;
                        hasChanged = true;
                }
                if ( gain != m_gain )
                {
                        m_gain = gain;
                        hasChanged = true;
                }
 
                if ( hasChanged ) { calcCoefficents(); }
        }
};
 
 
 
 
class EqLowShelfFilter : public EqFilter
{
public :
        void calcCoefficents() override
        {
 
                // calc intermediate
                float w0 = 2 * std::numbers::pi_v<float> * m_freq / m_sampleRate;
                float c = std::cos(w0);
                float s = std::sin(w0);
                float A = fastPow10f(m_gain * 0.025);
                // float alpha = s / (2 * m_res);
                float beta = std::sqrt(A) / m_res;
 
                //calc coefficents
                float b0 = A * ((A + 1) - (A - 1) * c + beta * s);
                float b1 = 2 * A * ((A - 1) - (A + 1) * c);
                float b2 = A * ((A + 1) - (A - 1) * c - beta * s);
                float a0 = (A + 1) + (A - 1) * c + beta * s;
                float a1 = -2 * ((A - 1) + (A + 1) * c);
                float a2 = (A + 1) + (A - 1) * c - beta * s;
 
                //normalise
                b0 /= a0;
                b1 /= a0;
                b2 /= a0;
                a1 /= a0;
                a2 /= a0;
 
                a0 = 1;
 
                setCoeffs( a1, a2, b0, b1, b2 );
 
 
        }
};
 
class EqHighShelfFilter : public EqFilter
{
public :
        void calcCoefficents() override
        {
 
                // calc intermediate
                float w0 = 2 * std::numbers::pi_v<float> * m_freq / m_sampleRate;
                float c = std::cos(w0);
                float s = std::sin(w0);
                float A = fastPow10f(m_gain * 0.025);
                float beta = std::sqrt(A) / m_res;
 
                //calc coefficents
                float b0 = A * ((A + 1) + (A - 1) * c + beta * s);
                float b1 = -2 * A * ((A - 1) + (A + 1) * c);
                float b2 = A * ((A + 1) + (A - 1) * c - beta * s);
                float a0 = (A + 1) - (A - 1) * c + beta * s;
                float a1 = 2 * ((A - 1) - (A + 1) * c);
                float a2 = (A + 1) - (A - 1) * c - beta * s;
 
                //normalise
                b0 /= a0;
                b1 /= a0;
                b2 /= a0;
                a1 /= a0;
                a2 /= a0;
                a0 = 1;
 
                setCoeffs( a1, a2, b0, b1, b2 );
        }
};
 
 
 
 
class EqLinkwitzRiley : public StereoLinkwitzRiley
{
public:
        EqLinkwitzRiley() :
                StereoLinkwitzRiley( 44100),
                m_freq(0 ),
                m_sr( 1 )
        {
        }
 
        virtual inline void setSR( int sampleRate )
        {
                if( sampleRate != m_sr )
                {
                        m_sr = sampleRate;
                        setSampleRate( sampleRate );
                        setLowpass(m_freq);
                }
        }
 
 
 
 
        virtual inline void setFrequency( float freq ){
                if ( freq != m_freq )
                {
                        m_freq = freq;
                        setLowpass(m_freq);
                }
        }
 
 
 
 
        virtual void processBuffer( SampleFrame* buf, const f_cnt_t frames )
        {
                for ( f_cnt_t f = 0 ; f < frames ; ++f)
                {
                        buf[f][0] = update( buf[f][0] , 0);
                        buf[f][1] = update( buf[f][1] , 1);
                }
        }
protected:
 
        float m_freq;
        int m_sr;
 
 
};
 
 
} // namespace lmms
 
 
#endif // EQFILTER_H