dsp::IIR::Filter: noise/glitches when automating frequency via (slow) LFO

Audio Plugins
21

The funny (sad?) thing is that you’ve spent a lot of time trying to get this JUCE filter to work but you could have implemented the whole thing by hand in a fraction of the time. This isn’t to throw shade on you, just to say that the JUCE dsp module isn’t necessarily the easiest to use. Under the hood it’s just a basic biquad filter.

Calculating the coefficients:

void peakingRBJ(double sampleRate, double frequency, double Q, double dbGain) 
{
    const double omega = 2.0 * M_PI * frequency / sampleRate;
    const double sinOmega = std::sin(omega);
    const double cosOmega = std::cos(omega);
    const double alpha = sinOmega / (2.0 * Q);
    const double A = std::pow(10.0, dbGain / 40.0);
    a0 =  1.0 + alpha * A;
    a1 = -2.0 * cosOmega;
    a2 =  1.0 - alpha * A;
    b0 =  1.0 + alpha / A;
    b1 =  a1;
    b2 =  1.0 - alpha / A;
}

Filter class:

class BiQuadFilter
{
public:
    void reset() noexcept
    {
        z1 = z2 = 0.0f;
    }

    float processSample(float x) noexcept
    {
        const float y = a0 * x + z1;
        z1 = a1 * x - b1 * y + z2;
        z2 = a2 * x - b2 * y;
        return y;
    }

    float a0 = 1.0f, a1 = 0.0f, a2 = 0.0f, b1 = 0.0f, b2 = 0.0f;

private:
    float z1, z2;
};

Note that you’ll need separate BiQuadFilter instances for the left and right channels.

Assigning the coefficients to the filter:

filter.a0 = a0 / b0;
filter.a1 = a1 / b0;
filter.a2 = a2 / b0;
filter.b1 = b1 / b0;
filter.b2 = b2 / b0;

This dividing by b0 can be avoided by rewriting the coefficient calculation math but in this case I’m using the peaking filter formulation from the RBJ cookbook, which includes b0.

1 Like
22

Yeah, good point!

Honestly I asked myself that question before starting: write it from scratch (good for learning and knowing exactly what’s going on) or use the DSP module (better implementation, works out of the box)? I’ve always been taught not to reinvent the wheel and use library code where possible so I opted for the DSP module.

But you’re right here, for my simple use case what you shared seems to be enough and without all the extra complication.

I think I had a similar problem in the past, if I remember correctly I was writing a delay, tried using the built-in DSP classes but ran into issues/limitations, so eventually I wrote my own circular buffer (complete with fractional delay) and it was all sorted (with much less effort than expected).

Not sure if that’s necessarily best practice, but I agree that sometimes it can just be the simplest thing to do (plus a good way to learn how things work under the hood and to have more control if needed).

Thanks again for all the advice, much appreciated! :slight_smile:

23

If you look at the source code, the resulting newCoefficients[] must be identical. But I do recommend using double precision (at least when calculating coeffs).

And I also agree with @kerfuffle . As I said before, if you change coeffs very fast, the redundant checks in juce::dsp::IIR may hurt the performance a little bit. I use my own IIR filter to improve efficiency:

1 Like