🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
137 lines
4.4 KiB
137 lines
4.4 KiB
#ifndef FILTERS_BIQUAD_H
|
|
#define FILTERS_BIQUAD_H
|
|
|
|
#include <cmath>
|
|
#include <utility>
|
|
|
|
#include "AL/al.h"
|
|
#include "math_defs.h"
|
|
|
|
|
|
/* Filters implementation is based on the "Cookbook formulae for audio
|
|
* EQ biquad filter coefficients" by Robert Bristow-Johnson
|
|
* http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
|
|
*/
|
|
/* Implementation note: For the shelf filters, the specified gain is for the
|
|
* reference frequency, which is the centerpoint of the transition band. This
|
|
* better matches EFX filter design. To set the gain for the shelf itself, use
|
|
* the square root of the desired linear gain (or halve the dB gain).
|
|
*/
|
|
|
|
enum class BiquadType {
|
|
/** EFX-style low-pass filter, specifying a gain and reference frequency. */
|
|
HighShelf,
|
|
/** EFX-style high-pass filter, specifying a gain and reference frequency. */
|
|
LowShelf,
|
|
/** Peaking filter, specifying a gain and reference frequency. */
|
|
Peaking,
|
|
|
|
/** Low-pass cut-off filter, specifying a cut-off frequency. */
|
|
LowPass,
|
|
/** High-pass cut-off filter, specifying a cut-off frequency. */
|
|
HighPass,
|
|
/** Band-pass filter, specifying a center frequency. */
|
|
BandPass,
|
|
};
|
|
|
|
template<typename Real>
|
|
class BiquadFilterR {
|
|
/* Last two delayed components for direct form II. */
|
|
Real z1{0.0f}, z2{0.0f};
|
|
/* Transfer function coefficients "b" (numerator) */
|
|
Real b0{1.0f}, b1{0.0f}, b2{0.0f};
|
|
/* Transfer function coefficients "a" (denominator; a0 is pre-applied). */
|
|
Real a1{0.0f}, a2{0.0f};
|
|
|
|
public:
|
|
void clear() noexcept { z1 = z2 = 0.0f; }
|
|
|
|
/**
|
|
* Sets the filter state for the specified filter type and its parameters.
|
|
*
|
|
* \param type The type of filter to apply.
|
|
* \param gain The gain for the reference frequency response. Only used by
|
|
* the Shelf and Peaking filter types.
|
|
* \param f0norm The reference frequency normal (ref_freq / sample_rate).
|
|
* This is the center point for the Shelf, Peaking, and
|
|
* BandPass filter types, or the cutoff frequency for the
|
|
* LowPass and HighPass filter types.
|
|
* \param rcpQ The reciprocal of the Q coefficient for the filter's
|
|
* transition band. Can be generated from calc_rcpQ_from_slope
|
|
* or calc_rcpQ_from_bandwidth as needed.
|
|
*/
|
|
void setParams(BiquadType type, Real gain, Real f0norm, Real rcpQ);
|
|
|
|
void copyParamsFrom(const BiquadFilterR &other)
|
|
{
|
|
b0 = other.b0;
|
|
b1 = other.b1;
|
|
b2 = other.b2;
|
|
a1 = other.a1;
|
|
a2 = other.a2;
|
|
}
|
|
|
|
|
|
void process(Real *dst, const Real *src, int numsamples);
|
|
|
|
void passthru(int numsamples) noexcept
|
|
{
|
|
if(LIKELY(numsamples >= 2))
|
|
{
|
|
z1 = 0.0f;
|
|
z2 = 0.0f;
|
|
}
|
|
else if(numsamples == 1)
|
|
{
|
|
z1 = z2;
|
|
z2 = 0.0f;
|
|
}
|
|
}
|
|
|
|
/* Rather hacky. It's just here to support "manual" processing. */
|
|
std::pair<Real,Real> getComponents() const noexcept
|
|
{ return {z1, z2}; }
|
|
void setComponents(Real z1_, Real z2_) noexcept
|
|
{ z1 = z1_; z2 = z2_; }
|
|
Real processOne(const Real in, Real &z1_, Real &z2_) const noexcept
|
|
{
|
|
Real out{in*b0 + z1_};
|
|
z1_ = in*b1 - out*a1 + z2_;
|
|
z2_ = in*b2 - out*a2;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
using BiquadFilter = BiquadFilterR<float>;
|
|
|
|
/**
|
|
* Calculates the rcpQ (i.e. 1/Q) coefficient for shelving filters, using the
|
|
* reference gain and shelf slope parameter.
|
|
* \param gain 0 < gain
|
|
* \param slope 0 < slope <= 1
|
|
*/
|
|
inline float calc_rcpQ_from_slope(float gain, float slope)
|
|
{ return std::sqrt((gain + 1.0f/gain)*(1.0f/slope - 1.0f) + 2.0f); }
|
|
|
|
inline double calc_rcpQ_from_slope(double gain, double slope)
|
|
{ return std::sqrt((gain + 1.0/gain)*(1.0/slope - 1.0) + 2.0); }
|
|
|
|
/**
|
|
* Calculates the rcpQ (i.e. 1/Q) coefficient for filters, using the normalized
|
|
* reference frequency and bandwidth.
|
|
* \param f0norm 0 < f0norm < 0.5.
|
|
* \param bandwidth 0 < bandwidth
|
|
*/
|
|
inline float calc_rcpQ_from_bandwidth(float f0norm, float bandwidth)
|
|
{
|
|
const float w0{al::MathDefs<float>::Tau() * f0norm};
|
|
return 2.0f*std::sinh(std::log(2.0f)/2.0f*bandwidth*w0/std::sin(w0));
|
|
}
|
|
|
|
inline double calc_rcpQ_from_bandwidth(double f0norm, double bandwidth)
|
|
{
|
|
const double w0{al::MathDefs<double>::Tau() * f0norm};
|
|
return 2.0*std::sinh(std::log(2.0)/2.0*bandwidth*w0/std::sin(w0));
|
|
}
|
|
|
|
#endif /* FILTERS_BIQUAD_H */
|