fxobjects.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK-Core File:  fxobjects.h
//
// -----------------------------------------------------------------------------
#pragma once
 
#include <memory>
#include <algorithm>
#include <math.h>
#include "guiconstants.h"
#include "filters.h"
#include <time.h>       /* time */
 
#define HAVE_FFTW 1
 
// --- constants & enumerations
//
// ---  by placing outside the class declaration, these will also be avaialble to anything
//      that #includes this file (sometimes needed)
const double kSmallestPositiveFloatValue = 1.175494351e-38;         /* min positive value */
const double kSmallestNegativeFloatValue = -1.175494351e-38;         /* min negative value */
const double kSqrtTwo = pow(2.0, 0.5);
const double kMinFilterFrequency = 20.0;
const double kMaxFilterFrequency = 20480.0; // 10 octaves above 20 Hz
const double ARC4RANDOMMAX = 4294967295.0;  // (2^32 - 1)
 
#define NEGATIVE       0
#define POSITIVE       1
 
// ------------------------------------------------------------------ //
// --- FUNCTIONS ---------------------------------------------------- //
// ------------------------------------------------------------------ //
 
inline bool checkFloatUnderflow(double& value)
{
    bool retValue = false;
    if (value > 0.0 && value < kSmallestPositiveFloatValue)
    {
        value = 0;
        retValue = true;
    }
    else if (value < 0.0 && value > kSmallestNegativeFloatValue)
    {
        value = 0;
        retValue = true;
    }
    return retValue;
}
 
inline double doLinearInterpolation(double x1, double x2, double y1, double y2, double x)
{
    double denom = x2 - x1;
    if (denom == 0)
        return y1; // --- should not ever happen
 
    // --- calculate decimal position of x
    double dx = (x - x1) / (x2 - x1);
 
    // --- use weighted sum method of interpolating
    return dx*y2 + (1 - dx)*y1;
}
 
inline double doLinearInterpolation(double y1, double y2, double fractional_X)
{
    // --- check invalid condition
    if (fractional_X >= 1.0) return y2;
 
    // --- use weighted sum method of interpolating
    return fractional_X*y2 + (1.0 - fractional_X)*y1;
}
 
inline double doLagrangeInterpolation(double* x, double* y, int n, double xbar)
{
    int i, j;
    double fx = 0.0;
    double l = 1.0;
    for (i = 0; i<n; i++)
    {
        l = 1.0;
        for (j = 0; j<n; j++)
        {
            if (j != i)
                l *= (xbar - x[j]) / (x[i] - x[j]);
        }
        fx += l*y[i];
    }
    return (fx);
}
 
 
inline void boundValue(double& value, double minValue, double maxValue)
{
    value = fmin(value, maxValue);
    value = fmax(value, minValue);
}
 
inline double doUnipolarModulationFromMin(double unipolarModulatorValue, double minValue, double maxValue)
{
    // --- UNIPOLAR bound
    boundValue(unipolarModulatorValue, 0.0, 1.0);
 
    // --- modulate from minimum value upwards
    return unipolarModulatorValue*(maxValue - minValue) + minValue;
}
 
inline double doUnipolarModulationFromMax(double unipolarModulatorValue, double minValue, double maxValue)
{
    // --- UNIPOLAR bound
    boundValue(unipolarModulatorValue, 0.0, 1.0);
 
    // --- modulate from maximum value downwards
    return maxValue - (1.0 - unipolarModulatorValue)*(maxValue - minValue);
}
 
inline double doBipolarModulation(double bipolarModulatorValue, double minValue, double maxValue)
{
    // --- BIPOLAR bound
    boundValue(bipolarModulatorValue, -1.0, 1.0);
 
    // --- calculate range and midpoint
    double halfRange = (maxValue - minValue) / 2.0;
    double midpoint = halfRange + minValue;
 
    return bipolarModulatorValue*(halfRange) + midpoint;
}
 
inline double unipolarToBipolar(double value)
{
    return 2.0*value - 1.0;
}
 
inline double bipolarToUnipolar(double value)
{
    return 0.5*value + 0.5;
}
 
inline double raw2dB(double raw)
{
    return 20.0*log10(raw);
}
 
inline double dB2Raw(double dB)
{
    return pow(10.0, (dB / 20.0));
}
 
inline double peakGainFor_Q(double Q)
{
    // --- no resonance at or below unity
    if (Q <= 0.707) return 1.0;
    return (Q*Q) / (pow((Q*Q - 0.25), 0.5));
}
 
inline double dBPeakGainFor_Q(double Q)
{
    return raw2dB(peakGainFor_Q(Q));
}
 
inline double doWhiteNoise()
{
    float noise = 0.0;
 
#if defined _WINDOWS || defined _WINDLL
    // fNoise is 0 -> 32767.0
    noise = (float)rand();
 
    // normalize and make bipolar
    noise = 2.f*(noise / 32767.f) - 1.f;
#else
    // fNoise is 0 -> ARC4RANDOMMAX
    noise = (float)arc4random();
 
    // normalize and make bipolar
    noise = 2.0*(noise / ARC4RANDOMMAX) - 1.0;
#endif
 
    return noise;
}
 
inline double sgn(double xn)
{
    return (xn > 0) - (xn < 0);
}
 
inline double calcWSGain(double xn, double saturation, double asymmetry)
{
    double g = ((xn >= 0.0 && asymmetry > 0.0) || (xn < 0.0 && asymmetry < 0.0)) ? saturation * (1.0 + 4.0*fabs(asymmetry)) : saturation;
    return g;
}
 
inline double atanWaveShaper(double xn, double saturation)
{
    return atan(saturation*xn) / atan(saturation);
}
 
inline double tanhWaveShaper(double xn, double saturation)
{
    return tanh(saturation*xn) / tanh(saturation);
}
 
inline double softClipWaveShaper(double xn, double saturation)
{
    // --- un-normalized soft clipper from Reiss book
    return sgn(xn)*(1.0 - exp(-fabs(saturation*xn)));
}
 
inline double fuzzExp1WaveShaper(double xn, double saturation, double asymmetry)
{
    // --- setup gain
    double wsGain = calcWSGain(xn, saturation, asymmetry);
    return sgn(xn)*(1.0 - exp(-fabs(wsGain*xn))) / (1.0 - exp(-wsGain));
}
 
 
inline double getMagResponse(double theta, double a0, double a1, double a2, double b1, double b2)
{
    double magSqr = 0.0;
    double num = a1*a1 + (a0 - a2)*(a0 - a2) + 2.0*a1*(a0 + a2)*cos(theta) + 4.0*a0*a2*cos(theta)*cos(theta);
    double denom = b1*b1 + (1.0 - b2)*(1.0 - b2) + 2.0*b1*(1.0 + b2)*cos(theta) + 4.0*b2*cos(theta)*cos(theta);
 
    magSqr = num / denom;
    if (magSqr < 0.0)
        magSqr = 0.0;
 
    double mag = pow(magSqr, 0.5);
 
    return mag;
}
 
struct ComplexNumber
{
    ComplexNumber() {}
    ComplexNumber(double _real, double _imag)
    {
        real = _real;
        imag = _imag;
    }
 
    double real = 0.0; 
    double imag = 0.0; 
};
 
inline ComplexNumber complexMultiply(ComplexNumber c1, ComplexNumber c2)
{
    ComplexNumber complexProduct;
 
    // --- real part
    complexProduct.real = (c1.real*c2.real) - (c1.imag*c2.imag);
    complexProduct.imag = (c1.real*c2.imag) + (c1.imag*c2.real);
 
    return complexProduct;
}
 
inline void calcEdgeFrequencies(double fc, double Q, double& f_Low, double& f_High)
{
    bool arithmeticBW = true;
    double bandwidth = fc / Q;
 
    // --- geometric bw = sqrt[ (fLow)(fHigh) ]
    //     arithmetic bw = fHigh - fLow
    if (arithmeticBW)
    {
        f_Low = fc - bandwidth / 2.0;
        f_High = fc + bandwidth / 2.0;
    }
    else
    {
        ; // TODO --- add geometric (for homework)
    }
 
}
 
enum class brickwallFilter { kBrickLPF, kBrickHPF, kBrickBPF, kBrickBSF };
 
struct BrickwallMagData
{
    BrickwallMagData() {}
 
    brickwallFilter filterType = brickwallFilter::kBrickLPF;
    double* magArray = nullptr;
    unsigned int dftArrayLen = 0;
    double sampleRate = 44100.0;
 
    // --- for LPF, HPF fc = corner frequency
    //     for BPF, BSF fc = center frequency
    double fc = 1000.0;         
    double Q = 0.707;           
    double f_Low = 500.00;      
    double f_High = 1500.00;    
    unsigned int relaxationBins = 0;    
    bool mirrorMag = false;     
};
 
enum class edgeTransition { kFallingEdge, kRisingEdge };
 
struct TransitionBandData
{
    TransitionBandData() {}
 
    edgeTransition edgeType = edgeTransition::kFallingEdge; 
    unsigned int startBin = 0;  
    unsigned int stopBin = 0;   
    double slopeIncrement = 1.0; 
};
 
 
inline int findEdgeTargetBin(double testFreq, double bin1Freq)
{
    return (int)(testFreq / bin1Freq);
}
 
inline bool getTransitionBandData(double testFreq, double bin1Freq, unsigned int relax_Bins, TransitionBandData& transitionData)
{
    double targetF1 = testFreq;// -(2.0*relax_Pct / 100.0)*testFreq;
    double targetF2 = testFreq + relax_Bins*bin1Freq;
 
    // --- for falling edge...
    int nF1 = findEdgeTargetBin(targetF1, bin1Freq);
    int nF2 = findEdgeTargetBin(targetF2, bin1Freq);
 
    nF1 = std::max(0, nF1);
    nF2 = std::max(0, nF2);
 
    int relaxBins = nF2 - nF1;
    if (relaxBins < 1)
        return false;
 
    // --- force even to make relax band symmetrical around edge
    //if (relaxBins % 2 != 0)
    //  relaxBins++;
 
    // --- for double-sided relax
    transitionData.startBin = nF1;
    transitionData.stopBin = relaxBins + nF1;
 
    // --- slope calc
    double run = transitionData.stopBin - transitionData.startBin;
    double rise = 1.0;
    if (transitionData.edgeType == edgeTransition::kFallingEdge)
        rise = -1.0;
    transitionData.slopeIncrement = rise / run;
 
    return true;
}
 
inline bool calculateBrickwallMagArray(BrickwallMagData& magData)
{
    // --- calculate first half of array
    double actualLength = magData.mirrorMag ? (double)magData.dftArrayLen : (double)magData.dftArrayLen * 2.0;
    uint32_t dumpLength = magData.mirrorMag ? magData.dftArrayLen / 2 : magData.dftArrayLen;
 
    // --- first bin in Hz
    double bin1 = magData.sampleRate / actualLength;
 
    // --- zero out array; if filter not supported, this will return a bank of 0's!
    memset(&magData.magArray[0], 0, magData.dftArrayLen * sizeof(double));
 
    // --- preprocess for transition bands
    TransitionBandData fallingEdge;
    fallingEdge.edgeType = edgeTransition::kFallingEdge;
 
    TransitionBandData risingEdge;
    risingEdge.edgeType = edgeTransition::kRisingEdge;
 
    // --- this will populate FL and FH for BPF and BSF
    calcEdgeFrequencies(magData.fc, magData.Q, magData.f_Low, magData.f_High);
 
    bool relaxIt = false;
    if (magData.relaxationBins > 0)
    {
        if(magData.filterType == brickwallFilter::kBrickLPF)
            relaxIt = getTransitionBandData(magData.fc, bin1, magData.relaxationBins, fallingEdge);
        else if (magData.filterType == brickwallFilter::kBrickHPF)
            relaxIt = getTransitionBandData(magData.fc, bin1, magData.relaxationBins, risingEdge);
        else if (magData.filterType == brickwallFilter::kBrickBPF)
        {
            if(getTransitionBandData(magData.f_Low, bin1, magData.relaxationBins, risingEdge))
                relaxIt = getTransitionBandData(magData.f_High, bin1, magData.relaxationBins, fallingEdge);
        }
        else if (magData.filterType == brickwallFilter::kBrickBSF)
        {
            if(getTransitionBandData(magData.f_Low, bin1, magData.relaxationBins, fallingEdge))
                relaxIt = getTransitionBandData(magData.f_High, bin1, magData.relaxationBins, risingEdge);
        }
    }
 
    for (uint32_t i = 0; i < dumpLength; i++)
    {
        double eval_f = i*bin1;
 
        if (magData.filterType == brickwallFilter::kBrickLPF)
        {
            if (!relaxIt)
            {
                if (eval_f <= magData.fc)
                    magData.magArray[i] = 1.0;
            }
            else // relax
            {
                if (i <= fallingEdge.startBin)
                    magData.magArray[i] = 1.0;
                else if(i > fallingEdge.startBin && i < fallingEdge.stopBin)
                    magData.magArray[i] = 1.0 + (i - fallingEdge.startBin)*fallingEdge.slopeIncrement;
            }
        }
        else if (magData.filterType == brickwallFilter::kBrickHPF)
        {
            if (!relaxIt)
            {
                if (eval_f >= magData.fc)
                    magData.magArray[i] = 1.0;
            }
            else // relax
            {
                if (i >= risingEdge.stopBin)
                    magData.magArray[i] = 1.0;
                else if (i > risingEdge.startBin && i < risingEdge.stopBin)
                    magData.magArray[i] = 0.0 + (i - risingEdge.startBin)*risingEdge.slopeIncrement;
            }
        }
        else if (magData.filterType == brickwallFilter::kBrickBPF)
        {
            if (!relaxIt)
            {
                if (eval_f >= magData.f_Low && eval_f <= magData.f_High)
                    magData.magArray[i] = 1.0;
            }
            else // --- frankie says relax
            {
                if (i >= risingEdge.stopBin && i <= fallingEdge.startBin)
                    magData.magArray[i] = 1.0;
                else if (i > risingEdge.startBin && i < risingEdge.stopBin)
                    magData.magArray[i] = 0.0 + (i - risingEdge.startBin)*risingEdge.slopeIncrement;
                else if (i > fallingEdge.startBin && i < fallingEdge.stopBin)
                    magData.magArray[i] = 1.0 + (i - fallingEdge.startBin)*fallingEdge.slopeIncrement;
 
            }
        }
        else if (magData.filterType == brickwallFilter::kBrickBSF)
        {
            if (!relaxIt && eval_f >= magData.f_Low && eval_f <= magData.f_High)
                magData.magArray[i] = 0.0;
            else if((!relaxIt && eval_f < magData.f_Low) || eval_f > magData.f_High)
                magData.magArray[i] = 1.0;
            else
            {
                // --- TODO Fill this in...
            }
        }
    }
 
    // -- make sure have legal first half...
    if (!magData.mirrorMag)
        return true;
 
    // --- now mirror the other half
    int index = magData.dftArrayLen / 2 - 1;
    for (unsigned int i = magData.dftArrayLen / 2; i <magData.dftArrayLen; i++)
    {
        magData.magArray[i] = magData.magArray[index--];
    }
 
    return true;
}
 
enum class analogFilter { kLPF1, kHPF1, kLPF2, kHPF2, kBPF2, kBSF2 };
 
struct AnalogMagData
{
    AnalogMagData() {}
 
    analogFilter filterType = analogFilter::kLPF2;
    double* magArray = nullptr;
    unsigned int dftArrayLen = 0;
    double sampleRate = 44100.0;
 
    // --- for LPF, HPF fc = corner frequency
    //     for BPF, BSF fc = center frequency
    double fc = 1000.0;
    double Q = 0.707;
    bool mirrorMag = true;
};
 
inline bool calculateAnalogMagArray(AnalogMagData& magData)
{
    // --- calculate first half of array
    double actualLength = magData.mirrorMag ? (double)magData.dftArrayLen : (double)magData.dftArrayLen * 2.0;
    uint32_t dumpLength = magData.mirrorMag ? magData.dftArrayLen / 2 : magData.dftArrayLen;
 
    double bin1 = magData.sampleRate / actualLength;// (double)magData.dftArrayLen;
    double zeta = 1.0 / (2.0*magData.Q);
    double w_c = 2.0*kPi*magData.fc;
 
    // --- zero out array; if filter not supported, this will return a bank of 0's!
    memset(&magData.magArray[0], 0, magData.dftArrayLen * sizeof(double));
 
    for (uint32_t i = 0; i < dumpLength; i++)
    {
        double eval_w = 2.0*kPi*i*bin1;
        double w_o = eval_w / w_c;
 
        if (magData.filterType == analogFilter::kLPF1)
        {
            double denXSq = 1.0 + (w_o*w_o);
            magData.magArray[i] = 1.0 / (pow(denXSq, 0.5));
        }
        else if (magData.filterType == analogFilter::kHPF1)
        {
            double denXSq = 1.0 + (w_o*w_o);
            magData.magArray[i] = w_o / (pow(denXSq, 0.5));
        }
        else if (magData.filterType == analogFilter::kLPF2)
        {
            double denXSq = (1.0 - (w_o*w_o))*(1.0 - (w_o*w_o)) + 4.0*zeta*zeta*w_o*w_o;
            magData.magArray[i] = 1.0 / (pow(denXSq, 0.5));
        }
        else if (magData.filterType == analogFilter::kHPF2)
        {
            double denXSq = (1.0 - (w_o*w_o))*(1.0 - (w_o*w_o)) + 4.0*zeta*zeta*w_o*w_o;
            magData.magArray[i] = (w_o*w_o) / (pow(denXSq, 0.5));
        }
        else if (magData.filterType == analogFilter::kBPF2)
        {
            double denXSq = (1.0 - (w_o*w_o))*(1.0 - (w_o*w_o)) + 4.0*zeta*zeta*w_o*w_o;
            magData.magArray[i] = 2.0*w_o*zeta / (pow(denXSq, 0.5));
        }
        else if (magData.filterType == analogFilter::kBSF2)
        {
            double numXSq = (1.0 - (w_o*w_o))*(1.0 - (w_o*w_o));
            double denXSq = (1.0 - (w_o*w_o))*(1.0 - (w_o*w_o)) + 4.0*zeta*zeta*w_o*w_o;
            magData.magArray[i] = (pow(numXSq, 0.5)) / (pow(denXSq, 0.5));
        }
    }
 
    // -- make sure have legal first half...
    if (!magData.mirrorMag)
        return true;
 
    // --- now mirror the other half
    int index = magData.dftArrayLen / 2 - 1;
    for (unsigned int i = magData.dftArrayLen / 2; i <magData.dftArrayLen; i++)
    {
        magData.magArray[i] = magData.magArray[index--];
    }
 
    return true;
}
 
inline void freqSample(int N, double A[], double h[], int symm)
{
    int n, k;
    double x, val, M;
 
    M = (N - 1.0) / 2.0;
    if (symm == POSITIVE)
    {
        if (N % 2)
        {
            for (n = 0; n<N; n++)
            {
                val = A[0];
                x = kTwoPi * (n - M) / N;
                for (k = 1; k <= M; k++)
                    val += 2.0 * A[k] * cos(x*k);
                h[n] = val / N;
            }
        }
        else
        {
            for (n = 0; n<N; n++)
            {
                val = A[0];
                x = kTwoPi * (n - M) / N;
                for (k = 1; k <= (N / 2 - 1); k++)
                    val += 2.0 * A[k] * cos(x*k);
                h[n] = val / N;
            }
        }
    }
    else
    {
        if (N % 2)
        {
            for (n = 0; n<N; n++)
            {
                val = 0;
                x = kTwoPi * (n - M) / N;
                for (k = 1; k <= M; k++)
                    val += 2.0 * A[k] * sin(x*k);
                h[n] = val / N;
            }
        }
        else
        {
            for (n = 0; n<N; n++)
            {
                val = A[N / 2] * sin(kPi * (n - M));
                x = kTwoPi * (n - M) / N;
                for (k = 1; k <= (N / 2 - 1); k++)
                    val += 2.0 * A[k] * sin(x*k);
                h[n] = val / N;
            }
        }
    }
}
 
inline double getMagnitude(double re, double im)
{
    return sqrt((re*re) + (im*im));
}
 
inline double getPhase(double re, double im)
{
    return atan2(im, re);
}
 
inline double principalArg(double phaseIn)
{
    if (phaseIn >= 0)
        return fmod(phaseIn + kPi, kTwoPi) - kPi;
    else
        return fmod(phaseIn + kPi, -kTwoPi) + kPi;
}
 
enum class interpolation {kLinear, kLagrange4};
 
inline bool resample(double* input, double* output, uint32_t inLength, uint32_t outLength,
                     interpolation interpType = interpolation::kLinear,
                     double scalar = 1.0, double* outWindow = nullptr)
{
    if (inLength <= 1 || outLength <= 1) return false;
    if (!input || !output) return false;
 
    double x[4] = { 0.0, 0.0, 0.0, 0.0 };
    double y[4] = { 0.0, 0.0, 0.0, 0.0 };
 
    // --- inc
    double inc = (double)(inLength - 1) / (double)(outLength - 1);
 
    // --- first point
    if (outWindow)
        output[0] = outWindow[0] * scalar * input[0];
    else
        output[0] = scalar * input[0];
 
    if (interpType == interpolation::kLagrange4)
    {
        for (unsigned int i = 1; i < outLength; i++)
        {
            // --- find interpolation location
            double xInterp = i*inc;
            uint32_t x1 = (uint32_t)xInterp; // floor?
 
            if (xInterp > 1.0 && x1 < inLength - 2)
            {
                x[0] = x1 - 1;
                y[0] = input[(int)x[0]];
 
                x[1] = x1;
                y[1] = input[(int)x[1]];
 
                x[2] = x1 + 1;
                y[2] = input[(int)x[2]];
 
                x[3] = x1 + 2;
                y[3] = input[(int)x[3]];
 
                if (outWindow)
                    output[i] = outWindow[i] * scalar * doLagrangeInterpolation(x, y, 4, xInterp);
                else
                    output[i] = scalar * doLagrangeInterpolation(x, y, 4, xInterp);
            }
            else // --- linear for outer 2 end pts
            {
                uint32_t x2 = x1 + 1;
                if (x2 >= outLength)
                    x2 = x1;
                double y1 = input[x1];
                double y2 = input[x2];
 
                if (outWindow)
                    output[i] = outWindow[i] * scalar * doLinearInterpolation(y1, y2, xInterp - x1);
                else
                    output[i] = scalar * doLinearInterpolation(y1, y2, xInterp - x1);
            }
        }
    }
    else // must be linear
    {
        // --- LINEAR INTERP
        for (uint32_t i = 1; i < outLength; i++)
        {
            double xInterp = i*inc;
            uint32_t x1 = (uint32_t)xInterp; // floor?
            uint32_t x2 = x1 + 1;
            if (x2 >= outLength)
                x2 = x1;
            double y1 = input[x1];
            double y2 = input[x2];
 
            if (outWindow)
                output[i] = outWindow[i] * scalar * doLinearInterpolation(y1, y2, xInterp - x1);
            else
                output[i] = scalar * doLinearInterpolation(y1, y2, xInterp - x1);
        }
    }
 
    return true;
}
 
// ------------------------------------------------------------------ //
// --- INTERFACES --------------------------------------------------- //
// ------------------------------------------------------------------ //
 
class IAudioSignalProcessor
{
public:
    // --- pure virtual, derived classes must implement or will not compile
    //     also means this is a pure abstract base class and is incomplete,
    //     so it can only be used as a base class
    //
    virtual bool reset(double _sampleRate) = 0;
 
    virtual double processAudioSample(double xn) = 0;
 
    virtual bool canProcessAudioFrame() = 0;
 
    virtual void setSampleRate(double _sampleRate) {}
 
    virtual void enableAuxInput(bool enableAuxInput) {}
 
    virtual double processAuxInputAudioSample(double xn)
    {
        // --- do nothing
        return xn;
    }
 
    virtual bool processAudioFrame(const float* inputFrame,     /* ptr to one frame of data: pInputFrame[0] = left, pInputFrame[1] = right, etc...*/
                                   float* outputFrame,
                                   uint32_t inputChannels,
                                   uint32_t outputChannels)
    {
        // --- do nothing
        return false; // NOT handled
    }
};
 
// --- structure to send output data from signal gen; you can add more outputs here
struct SignalGenData
{
    SignalGenData() {}
 
    double normalOutput = 0.0;          
    double invertedOutput = 0.0;        
    double quadPhaseOutput_pos = 0.0;   
    double quadPhaseOutput_neg = 0.0;   
};
 
class IAudioSignalGenerator
{
public:
    // --- pure virtual, derived classes must implement or will not compile
    //     also means this is a pure abstract base class and is incomplete,
    //     so it can only be used as a base class
    //
    virtual bool reset(double _sampleRate) = 0;
 
    virtual const SignalGenData renderAudioOutput() = 0;
};
 
 
 
// ------------------------------------------------------------------ //
// --- OBJECTS ------------------------------------------------------ //
// ------------------------------------------------------------------ //
/*
Class Declarations :
 
class name : public IAudioSignalProcessor
    - IAudioSignalProcessor functions
    - member functions that may be called externally
    - mutators & accessors
    - helper functions(may be private / protected if needed)
    - protected member functions
*/
 
enum filterCoeff { a0, a1, a2, b1, b2, c0, d0, numCoeffs };
 
// --- state array index values
//     z^-1 registers;
//        Direct Forms: we will allow max of 2 for X (feedforward) and 2 for Y (feedback) data
//        Transpose Forms: we will use ONLY the x_z1 and x_z2 registers for the 2 required delays
enum stateReg { x_z1, x_z2, y_z1, y_z2, numStates };
 
// --- type of calculation (algorithm)
enum class biquadAlgorithm { kDirect, kCanonical, kTransposeDirect, kTransposeCanonical }; //  4 types of biquad calculations, constants (k)
 
 
struct BiquadParameters
{
    BiquadParameters () {}
 
    BiquadParameters& operator=(const BiquadParameters& params)
    {
        if (this == &params)
            return *this;
 
        biquadCalcType = params.biquadCalcType;
        return *this;
    }
 
    biquadAlgorithm biquadCalcType = biquadAlgorithm::kDirect; 
};
 
class Biquad : public IAudioSignalProcessor
{
public:
    Biquad() {}     /* C-TOR */
    ~Biquad() {}    /* D-TOR */
 
    // --- IAudioSignalProcessor FUNCTIONS --- //
    //
    virtual bool reset(double _sampleRate)
    {
        memset(&stateArray[0], 0, sizeof(double)*numStates);
        return true;  // handled = true
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn);
 
    BiquadParameters getParameters() { return parameters ; }
 
    void setParameters(const BiquadParameters& _parameters){ parameters = _parameters; }
 
    // --- MUTATORS & ACCESSORS --- //
    void setCoefficients(double* coeffs){
        // --- fast block memory copy:
        memcpy(&coeffArray[0], &coeffs[0], sizeof(double)*numCoeffs);
    }
 
    double* getCoefficients()
    {
        // --- read/write access to the array (not used)
        return &coeffArray[0];
    }
 
    double* getStateArray()
    {
        // --- read/write access to the array (used only in direct form oscillator)
        return &stateArray[0];
    }
 
    double getG_value() { return coeffArray[a0]; }
 
    double getS_value();// { return storageComponent; }
 
protected:
    double coeffArray[numCoeffs] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 
    double stateArray[numStates] = { 0.0, 0.0, 0.0, 0.0 };
 
    BiquadParameters parameters;
 
    double storageComponent = 0.0;
};
 
 
enum class filterAlgorithm {
    kLPF1P, kLPF1, kHPF1, kLPF2, kHPF2, kBPF2, kBSF2, kButterLPF2, kButterHPF2, kButterBPF2,
    kButterBSF2, kMMALPF2, kMMALPF2B, kLowShelf, kHiShelf, kNCQParaEQ, kCQParaEQ, kLWRLPF2, kLWRHPF2,
    kAPF1, kAPF2, kResonA, kResonB, kMatchLP2A, kMatchLP2B, kMatchBP2A, kMatchBP2B,
    kImpInvLP1, kImpInvLP2
}; // --- you will add more here...
 
 
struct AudioFilterParameters
{
    AudioFilterParameters(){}
    AudioFilterParameters& operator=(const AudioFilterParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
        algorithm = params.algorithm;
        fc = params.fc;
        Q = params.Q;
        boostCut_dB = params.boostCut_dB;
 
        return *this;
    }
 
    // --- individual parameters
    filterAlgorithm algorithm = filterAlgorithm::kLPF1; 
    double fc = 100.0; 
    double Q = 0.707; 
    double boostCut_dB = 0.0; 
};
 
class AudioFilter : public IAudioSignalProcessor
{
public:
    AudioFilter() {}        /* C-TOR */
    ~AudioFilter() {}       /* D-TOR */
 
    // --- IAudioSignalProcessor
    virtual bool reset(double _sampleRate)
    {
        BiquadParameters bqp = biquad.getParameters();
 
        // --- you can try both forms - do you hear a difference?
        bqp.biquadCalcType = biquadAlgorithm::kTransposeCanonical; //<- this is the default operation
    //  bqp.biquadCalcType = biquadAlgorithm::kDirect;
        biquad.setParameters(bqp);
 
        sampleRate = _sampleRate;
        return biquad.reset(_sampleRate);
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn);
 
    virtual void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        calculateFilterCoeffs();
    }
 
    AudioFilterParameters getParameters() { return audioFilterParameters; }
 
    void setParameters(const AudioFilterParameters& parameters)
    {
        if (audioFilterParameters.algorithm != parameters.algorithm ||
            audioFilterParameters.boostCut_dB != parameters.boostCut_dB ||
            audioFilterParameters.fc != parameters.fc ||
            audioFilterParameters.Q != parameters.Q)
        {
            // --- save new params
            audioFilterParameters = parameters;
        }
        else
            return;
 
        // --- don't allow 0 or (-) values for Q
        if (audioFilterParameters.Q <= 0)
            audioFilterParameters.Q = 0.707;
 
        // --- update coeffs
        calculateFilterCoeffs();
    }
 
    double getG_value() { return biquad.getG_value(); }
 
    double getS_value() { return biquad.getS_value(); }
 
protected:
    // --- our calculator
    Biquad biquad; 
 
    // --- array to hold coeffs (we need them too)
    double coeffArray[numCoeffs] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; 
 
    // --- object parameters
    AudioFilterParameters audioFilterParameters; 
    double sampleRate = 44100.0; 
 
    bool calculateFilterCoeffs();
};
 
 
// --- output for filter bank requires multiple channels (bands)
struct FilterBankOutput
{
    FilterBankOutput() {}
 
    // --- band-split filter output
    double LFOut = 0.0; 
    double HFOut = 0.0; 
 
    // --- add more filter channels here; or use an array[]
};
 
 
struct LRFilterBankParameters
{
    LRFilterBankParameters() {}
    LRFilterBankParameters& operator=(const LRFilterBankParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
        splitFrequency = params.splitFrequency;
        return *this;
    }
 
    // --- individual parameters
    double splitFrequency = 1000.0; 
};
 
 
class LRFilterBank : public IAudioSignalProcessor
{
public:
    LRFilterBank()      /* C-TOR */
    {
        // --- set filters as Linkwitz-Riley 2nd order
        AudioFilterParameters params = lpFilter.getParameters();
        params.algorithm = filterAlgorithm::kLWRLPF2;
        lpFilter.setParameters(params);
 
        params = hpFilter.getParameters();
        params.algorithm = filterAlgorithm::kLWRHPF2;
        hpFilter.setParameters(params);
    }
 
    ~LRFilterBank() {}  /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        lpFilter.reset(_sampleRate);
        hpFilter.reset(_sampleRate);
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        return xn;
    }
 
    FilterBankOutput processFilterBank(double xn)
    {
        FilterBankOutput output;
 
        // --- process the LPF
        output.LFOut = lpFilter.processAudioSample(xn);
 
        // --- invert the HP filter output so that recombination will
        //     result in the correct phase and magnitude responses
        output.HFOut = -hpFilter.processAudioSample(xn);
 
        return output;
    }
 
    LRFilterBankParameters getParameters()
    {
        return parameters;
    }
 
    void setParameters(const LRFilterBankParameters& _parameters)
    {
        // --- update structure
        parameters = _parameters;
 
        // --- update member objects
        AudioFilterParameters params = lpFilter.getParameters();
        params.fc = parameters.splitFrequency;
        lpFilter.setParameters(params);
 
        params = hpFilter.getParameters();
        params.fc = parameters.splitFrequency;
        hpFilter.setParameters(params);
    }
 
protected:
    AudioFilter lpFilter; 
    AudioFilter hpFilter; 
 
    // --- object parameters
    LRFilterBankParameters parameters; 
};
 
// --- constants
const unsigned int TLD_AUDIO_DETECT_MODE_PEAK = 0;
const unsigned int TLD_AUDIO_DETECT_MODE_MS = 1;
const unsigned int TLD_AUDIO_DETECT_MODE_RMS = 2;
const double TLD_AUDIO_ENVELOPE_ANALOG_TC = -0.99967234081320612357829304641019; // ln(36.7%)
 
struct AudioDetectorParameters
{
    AudioDetectorParameters() {}
    AudioDetectorParameters& operator=(const AudioDetectorParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
        attackTime_mSec = params.attackTime_mSec;
        releaseTime_mSec = params.releaseTime_mSec;
        detectMode = params.detectMode;
        detect_dB = params.detect_dB;
        clampToUnityMax = params.clampToUnityMax;
        return *this;
    }
 
    // --- individual parameters
    double attackTime_mSec = 0.0; 
    double releaseTime_mSec = 0.0;
    unsigned int  detectMode = 0;
    bool detect_dB = false; 
    bool clampToUnityMax = true;
};
 
class AudioDetector : public IAudioSignalProcessor
{
public:
    AudioDetector() {}  /* C-TOR */
    ~AudioDetector() {} /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        setSampleRate(_sampleRate);
        lastEnvelope = 0.0;
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    // --- process audio: detect the log envelope and return it in dB
    virtual double processAudioSample(double xn)
    {
        // --- all modes do Full Wave Rectification
        double input = fabs(xn);
 
        // --- square it for MS and RMS
        if (audioDetectorParameters.detectMode == TLD_AUDIO_DETECT_MODE_MS ||
            audioDetectorParameters.detectMode == TLD_AUDIO_DETECT_MODE_RMS)
            input *= input;
 
        // --- to store current
        double currEnvelope = 0.0;
 
        // --- do the detection with attack or release applied
        if (input > lastEnvelope)
            currEnvelope = attackTime * (lastEnvelope - input) + input;
        else
            currEnvelope = releaseTime * (lastEnvelope - input) + input;
 
        // --- we are recursive so need to check underflow
        checkFloatUnderflow(currEnvelope);
 
        // --- bound them; can happen when using pre-detector gains of more than 1.0
        if (audioDetectorParameters.clampToUnityMax)
            currEnvelope = fmin(currEnvelope, 1.0);
 
        // --- can not be (-)
        currEnvelope = fmax(currEnvelope, 0.0);
 
        // --- store envelope prior to sqrt for RMS version
        lastEnvelope = currEnvelope;
 
        // --- if RMS, do the SQRT
        if (audioDetectorParameters.detectMode == TLD_AUDIO_DETECT_MODE_RMS)
            currEnvelope = pow(currEnvelope, 0.5);
 
        // --- if not dB, we are done
        if (!audioDetectorParameters.detect_dB)
            return currEnvelope;
 
        // --- setup for log( )
        if (currEnvelope <= 0)
        {
            return -96.0;
        }
 
        // --- true log output in dB, can go above 0dBFS!
        return 20.0*log10(currEnvelope);
    }
 
    AudioDetectorParameters getParameters()
    {
        return audioDetectorParameters;
    }
 
    void setParameters(const AudioDetectorParameters& parameters)
    {
        audioDetectorParameters = parameters;
 
        // --- update structure
        setAttackTime(audioDetectorParameters.attackTime_mSec, true);
        setReleaseTime(audioDetectorParameters.releaseTime_mSec, true);
 
    }
 
    virtual void setSampleRate(double _sampleRate)
    {
        if (sampleRate == _sampleRate)
            return;
 
        sampleRate = _sampleRate;
 
        // --- recalculate RC time-constants
        setAttackTime(audioDetectorParameters.attackTime_mSec, true);
        setReleaseTime(audioDetectorParameters.releaseTime_mSec, true);
    }
 
protected:
    AudioDetectorParameters audioDetectorParameters; 
    double attackTime = 0.0;    
    double releaseTime = 0.0;   
    double sampleRate = 44100;  
    double lastEnvelope = 0.0;  
 
    void setAttackTime(double attack_in_ms, bool forceCalc = false);
 
    void setReleaseTime(double release_in_ms, bool forceCalc = false);
};
 
 
// --- processorType
enum class dynamicsProcessorType { kCompressor, kDownwardExpander };
 
 
struct DynamicsProcessorParameters
{
    DynamicsProcessorParameters() {}
    DynamicsProcessorParameters& operator=(const DynamicsProcessorParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        ratio = params.ratio;
        threshold_dB = params.threshold_dB;
        kneeWidth_dB = params.kneeWidth_dB;
        hardLimitGate = params.hardLimitGate;
        softKnee = params.softKnee;
        enableSidechain = params.enableSidechain;
        calculation = params.calculation;
        attackTime_mSec = params.attackTime_mSec;
        releaseTime_mSec = params.releaseTime_mSec;
        outputGain_dB = params.outputGain_dB;
        // --- NOTE: do not set outbound variables??
        gainReduction = params.gainReduction;
        gainReduction_dB = params.gainReduction_dB;
        return *this;
    }
 
    // --- individual parameters
    double ratio = 50.0;                
    double threshold_dB = -10.0;        
    double kneeWidth_dB = 10.0;         
    bool hardLimitGate = false;         
    bool softKnee = true;               
    bool enableSidechain = false;       
    dynamicsProcessorType calculation = dynamicsProcessorType::kCompressor; 
    double attackTime_mSec = 0.0;       
    double releaseTime_mSec = 0.0;      
    double outputGain_dB = 0.0;         
 
    // --- outbound values, for owner to use gain-reduction metering
    double gainReduction = 1.0;         
    double gainReduction_dB = 0.0;      
};
 
class DynamicsProcessor : public IAudioSignalProcessor
{
public:
    DynamicsProcessor() {}  /* C-TOR */
    ~DynamicsProcessor() {} /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        sidechainInputSample = 0.0;
        detector.reset(_sampleRate);
        AudioDetectorParameters detectorParams = detector.getParameters();
        detectorParams.clampToUnityMax = false;
        detectorParams.detect_dB = true;
        detector.setParameters(detectorParams);
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual void enableAuxInput(bool enableAuxInput){ parameters.enableSidechain = enableAuxInput; }
 
    virtual double processAuxInputAudioSample(double xn)
    {
        sidechainInputSample = xn;
        return sidechainInputSample;
    }
 
    DynamicsProcessorParameters getParameters(){ return parameters; }
 
    void setParameters(const DynamicsProcessorParameters& _parameters)
    {
        parameters = _parameters;
 
        AudioDetectorParameters detectorParams = detector.getParameters();
        detectorParams.attackTime_mSec = parameters.attackTime_mSec;
        detectorParams.releaseTime_mSec = parameters.releaseTime_mSec;
        detector.setParameters(detectorParams);
    }
 
    /*
        1. detect input signal
        2. calculate gain
        3. apply to input sample
    */
    virtual double processAudioSample(double xn)
    {
        // --- detect input
        double detect_dB = 0.0;
 
        // --- if using the sidechain, process the aux input
        if(parameters.enableSidechain)
            detect_dB = detector.processAudioSample(sidechainInputSample);
        else
            detect_dB = detector.processAudioSample(xn);
 
        // --- compute gain
        double gr = computeGain(detect_dB);
 
        // --- makeup gain
        double makeupGain = pow(10.0, parameters.outputGain_dB / 20.0);
 
        // --- do DCA + makeup gain
        return xn * gr * makeupGain;
    }
 
protected:
    DynamicsProcessorParameters parameters; 
    AudioDetector detector; 
 
    // --- storage for sidechain audio input (mono only)
    double sidechainInputSample = 0.0; 
 
    inline double computeGain(double detect_dB)
    {
        double output_dB = 0.0;
 
        if (parameters.calculation == dynamicsProcessorType::kCompressor)
        {
            // --- hard knee
            if (!parameters.softKnee)
            {
                // --- below threshold, unity
                if (detect_dB <= parameters.threshold_dB)
                    output_dB = detect_dB;
                else// --- above threshold, compress
                {
                    if (parameters.hardLimitGate) // is limiter?
                        output_dB = parameters.threshold_dB;
                    else
                        output_dB = parameters.threshold_dB + (detect_dB - parameters.threshold_dB) / parameters.ratio;
                }
            }
            else // --- calc gain with knee
            {
                // --- left side of knee, outside of width, unity gain zone
                if (2.0*(detect_dB - parameters.threshold_dB) < -parameters.kneeWidth_dB)
                    output_dB = detect_dB;
                // --- else inside the knee,
                else if (2.0*(fabs(detect_dB - parameters.threshold_dB)) <= parameters.kneeWidth_dB)
                {
                    if (parameters.hardLimitGate)   // --- is limiter?
                        output_dB = detect_dB - pow((detect_dB - parameters.threshold_dB + (parameters.kneeWidth_dB / 2.0)), 2.0) / (2.0*parameters.kneeWidth_dB);
                    else // --- 2nd order poly
                        output_dB = detect_dB + (((1.0 / parameters.ratio) - 1.0) * pow((detect_dB - parameters.threshold_dB + (parameters.kneeWidth_dB / 2.0)), 2.0)) / (2.0*parameters.kneeWidth_dB);
                }
                // --- right of knee, compression zone
                else if (2.0*(detect_dB - parameters.threshold_dB) > parameters.kneeWidth_dB)
                {
                    if (parameters.hardLimitGate) // --- is limiter?
                        output_dB = parameters.threshold_dB;
                    else
                        output_dB = parameters.threshold_dB + (detect_dB - parameters.threshold_dB) / parameters.ratio;
                }
            }
        }
        else if (parameters.calculation == dynamicsProcessorType::kDownwardExpander)
        {
            // --- hard knee
            // --- NOTE: soft knee is not technically possible with a gate because there
            //           is no "left side" of the knee
            if (!parameters.softKnee || parameters.hardLimitGate)
            {
                // --- above threshold, unity gain
                if (detect_dB >= parameters.threshold_dB)
                    output_dB = detect_dB;
                else
                {
                    if (parameters.hardLimitGate) // --- gate: -inf(dB)
                        output_dB = -1.0e34;
                    else
                        output_dB = parameters.threshold_dB + (detect_dB - parameters.threshold_dB) * parameters.ratio;
                }
            }
            else // --- calc gain with knee
            {
                // --- right side of knee, unity gain zone
                if (2.0*(detect_dB - parameters.threshold_dB) > parameters.kneeWidth_dB)
                    output_dB = detect_dB;
                // --- in the knee
                else if (2.0*(fabs(detect_dB - parameters.threshold_dB)) > -parameters.kneeWidth_dB)
                    output_dB = ((parameters.ratio - 1.0) * pow((detect_dB - parameters.threshold_dB - (parameters.kneeWidth_dB / 2.0)), 2.0)) / (2.0*parameters.kneeWidth_dB);
                // --- left side of knee, downward expander zone
                else if (2.0*(detect_dB - parameters.threshold_dB) <= -parameters.kneeWidth_dB)
                    output_dB = parameters.threshold_dB + (detect_dB - parameters.threshold_dB) * parameters.ratio;
            }
        }
 
        // --- convert gain; store values for user meters
        parameters.gainReduction_dB = output_dB - detect_dB;
        parameters.gainReduction = pow(10.0, (parameters.gainReduction_dB) / 20.0);
 
        // --- the current gain coefficient value
        return parameters.gainReduction;
    }
};
 
template <typename T>
class LinearBuffer
{
public:
    LinearBuffer() {}   /* C-TOR */
    ~LinearBuffer() {}  /* D-TOR */
 
    void flushBuffer() { memset(&buffer[0], 0, bufferLength * sizeof(T)); }
 
    void createLinearBuffer(unsigned int _bufferLength)
    {
        // --- find nearest power of 2 for buffer, save it as bufferLength
        bufferLength = _bufferLength;
 
        // --- create new buffer
        buffer.reset(new T[bufferLength]);
 
        // --- flush buffer
        flushBuffer();
    }
 
    void writeBuffer(unsigned int index, T input)
    {
        if (index >= bufferLength) return;
 
        // --- write and increment index counter
        buffer[index] = input;
    }
 
    T readBuffer(unsigned int index)//, bool readBeforeWrite = true)
    {
        if (index >= bufferLength) return 0.0;
 
        // --- read it
        return buffer[index];
    }
 
private:
    std::unique_ptr<T[]> buffer = nullptr;  
    unsigned int bufferLength = 1024; 
};
 
 
template <typename T>
class CircularBuffer
{
public:
    CircularBuffer() {}     /* C-TOR */
    ~CircularBuffer() {}    /* D-TOR */
 
    void flushBuffer(){ memset(&buffer[0], 0, bufferLength * sizeof(T)); }
 
    void createCircularBuffer(unsigned int _bufferLength)
    {
        // --- find nearest power of 2 for buffer, and create
        createCircularBufferPowerOfTwo((unsigned int)(pow(2, ceil(log(_bufferLength) / log(2)))));
    }
 
    void createCircularBufferPowerOfTwo(unsigned int _bufferLengthPowerOfTwo)
    {
        // --- reset to top
        writeIndex = 0;
 
        // --- find nearest power of 2 for buffer, save it as bufferLength
        bufferLength = _bufferLengthPowerOfTwo;
 
        // --- save (bufferLength - 1) for use as wrapping mask
        wrapMask = bufferLength - 1;
 
        // --- create new buffer
        buffer.reset(new T[bufferLength]);
 
        // --- flush buffer
        flushBuffer();
    }
 
    void writeBuffer(T input)
    {
        // --- write and increment index counter
        buffer[writeIndex++] = input;
 
        // --- wrap if index > bufferlength - 1
        writeIndex &= wrapMask;
    }
 
    T readBuffer(int delayInSamples)//, bool readBeforeWrite = true)
    {
        // --- subtract to make read index
        //     note: -1 here is because we read-before-write,
        //           so the *last* write location is what we use for the calculation
        int readIndex = (writeIndex - 1) - delayInSamples;
 
        // --- autowrap index
        readIndex &= wrapMask;
 
        // --- read it
        return buffer[readIndex];
    }
 
    T readBuffer(double delayInFractionalSamples)
    {
        // --- truncate delayInFractionalSamples and read the int part
        T y1 = readBuffer((int)delayInFractionalSamples);
 
        // --- if no interpolation, just return value
        if (!interpolate) return y1;
 
        // --- else do interpolation
        //
        // --- read the sample at n+1 (one sample OLDER)
        T y2 = readBuffer((int)delayInFractionalSamples + 1);
 
        // --- get fractional part
        double fraction = delayInFractionalSamples - (int)delayInFractionalSamples;
 
        // --- do the interpolation (you could try different types here)
        return doLinearInterpolation(y1, y2, fraction);
    }
 
    void setInterpolate(bool b) { interpolate = b; }
 
private:
    std::unique_ptr<T[]> buffer = nullptr;  
    unsigned int writeIndex = 0;        
    unsigned int bufferLength = 1024;   
    unsigned int wrapMask = 1023;       
    bool interpolate = true;            
};
 
 
class ImpulseConvolver : public IAudioSignalProcessor
{
public:
    ImpulseConvolver() {
        init(512);
    }       /* C-TOR */
    ~ImpulseConvolver() {}      /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        // --- flush signal buffer; IR buffer is static
        signalBuffer.flushBuffer();
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        double output = 0.0;
 
        // --- write buffer; x(n) overwrites oldest value
        //     this is the only time we do not read before write!
        signalBuffer.writeBuffer(xn);
 
        // --- do the convolution
        for (unsigned int i = 0; i < length; i++)
        {
            // --- y(n) += x(n)h(n)
            //     for signalBuffer.readBuffer(0) -> x(n)
            //         signalBuffer.readBuffer(n-D)-> x(n-D)
            double signal = signalBuffer.readBuffer((int)i);
            double irrrrr = irBuffer.readBuffer((int)i);
            output += signal*irrrrr;
 
            //output += signalBuffer.readBuffer((int)i) * irBuffer.readBuffer((int)i);
        }
 
        return output;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    void init(unsigned int lengthPowerOfTwo)
    {
        length = lengthPowerOfTwo;
        // --- create (and clear out) the buffers
        signalBuffer.createCircularBufferPowerOfTwo(lengthPowerOfTwo);
        irBuffer.createLinearBuffer(lengthPowerOfTwo);
    }
 
    void setImpulseResponse(double* irArray, unsigned int lengthPowerOfTwo)
    {
        if (lengthPowerOfTwo != length)
        {
            length = lengthPowerOfTwo;
            // --- create (and clear out) the buffers
            signalBuffer.createCircularBufferPowerOfTwo(lengthPowerOfTwo);
            irBuffer.createLinearBuffer(lengthPowerOfTwo);
        }
 
        // --- load up the IR buffer
        for (unsigned int i = 0; i < length; i++)
        {
            irBuffer.writeBuffer(i, irArray[i]);
        }
    }
 
protected:
    // --- delay buffer of doubles
    CircularBuffer<double> signalBuffer; 
    LinearBuffer<double> irBuffer;  
 
    unsigned int length = 0;    
 
};
 
const unsigned int IR_LEN = 512;
struct AnalogFIRFilterParameters
{
    AnalogFIRFilterParameters() {}
    AnalogFIRFilterParameters& operator=(const AnalogFIRFilterParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        filterType = params.filterType;
        fc = params.fc;
        Q = params.Q;
 
        return *this;
    }
 
    // --- individual parameters
    analogFilter filterType = analogFilter::kLPF1; 
    double fc = 0.0;    
    double Q = 0.0;     
};
 
class AnalogFIRFilter : public IAudioSignalProcessor
{
public:
    AnalogFIRFilter() {}    /* C-TOR */
    ~AnalogFIRFilter() {}   /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        convolver.reset(_sampleRate);
        convolver.init(IR_LEN);
 
        memset(&analogMagArray[0], 0, sizeof(double) * IR_LEN); 
        memset(&irArray[0], 0, sizeof(double) * IR_LEN);    
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        // --- do the linear convolution
        return convolver.processAudioSample(xn);
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    AnalogFIRFilterParameters getParameters() { return parameters; }
 
    void setParameters(AnalogFIRFilterParameters _parameters)
    {
        if (_parameters.fc != parameters.fc ||
            _parameters.Q != parameters.Q ||
            _parameters.filterType != parameters.filterType)
        {
            // --- set the filter IR for the convolver
            AnalogMagData analogFilterData;
            analogFilterData.sampleRate = sampleRate;
            analogFilterData.magArray = &analogMagArray[0];
            analogFilterData.dftArrayLen = IR_LEN;
            analogFilterData.mirrorMag = false;
 
            analogFilterData.filterType = _parameters.filterType;
            analogFilterData.fc = _parameters.fc; // 1000.0;
            analogFilterData.Q = _parameters.Q;
 
            // --- calculate the analog mag array
            calculateAnalogMagArray(analogFilterData);
 
            // --- frequency sample the mag array
            freqSample(IR_LEN, analogMagArray, irArray, POSITIVE);
 
            // --- update new frequency response
            convolver.setImpulseResponse(irArray, IR_LEN);
        }
 
        parameters = _parameters;
    }
 
private:
    AnalogFIRFilterParameters parameters; 
    ImpulseConvolver convolver; 
    double analogMagArray[IR_LEN]; 
    double irArray[IR_LEN]; 
    double sampleRate = 0.0; 
};
 
enum class delayAlgorithm { kNormal, kPingPong };
 
enum class delayUpdateType { kLeftAndRight, kLeftPlusRatio };
 
 
struct AudioDelayParameters
{
    AudioDelayParameters() {}
    AudioDelayParameters& operator=(const AudioDelayParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        algorithm = params.algorithm;
        wetLevel_dB = params.wetLevel_dB;
        dryLevel_dB = params.dryLevel_dB;
        feedback_Pct = params.feedback_Pct;
 
        updateType = params.updateType;
        leftDelay_mSec = params.leftDelay_mSec;
        rightDelay_mSec = params.rightDelay_mSec;
        delayRatio_Pct = params.delayRatio_Pct;
 
        return *this;
    }
 
    // --- individual parameters
    delayAlgorithm algorithm = delayAlgorithm::kNormal; 
    double wetLevel_dB = -3.0;  
    double dryLevel_dB = -3.0;  
    double feedback_Pct = 0.0;  
 
    delayUpdateType updateType = delayUpdateType::kLeftAndRight;
    double leftDelay_mSec = 0.0;    
    double rightDelay_mSec = 0.0;   
    double delayRatio_Pct = 100.0;  
};
 
class AudioDelay : public IAudioSignalProcessor
{
public:
    AudioDelay() {}     /* C-TOR */
    ~AudioDelay() {}    /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- if sample rate did not change
        if (sampleRate == _sampleRate)
        {
            // --- just flush buffer and return
            delayBuffer_L.flushBuffer();
            delayBuffer_R.flushBuffer();
            return true;
        }
 
        // --- create new buffer, will store sample rate and length(mSec)
        createDelayBuffers(_sampleRate, bufferLength_mSec);
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        // --- read delay
        double yn = delayBuffer_L.readBuffer(delayInSamples_L);
 
        // --- create input for delay buffer
        double dn = xn + (parameters.feedback_Pct / 100.0) * yn;
 
        // --- write to delay buffer
        delayBuffer_L.writeBuffer(dn);
 
        // --- form mixture out = dry*xn + wet*yn
        double output = dryMix*xn + wetMix*yn;
 
        return output;
    }
 
    virtual bool canProcessAudioFrame() { return true; }
 
    virtual bool processAudioFrame(const float* inputFrame,     /* ptr to one frame of data: pInputFrame[0] = left, pInputFrame[1] = right, etc...*/
        float* outputFrame,
        uint32_t inputChannels,
        uint32_t outputChannels)
    {
        // --- make sure we have input and outputs
        if (inputChannels == 0 || outputChannels == 0)
            return false;
 
        // --- make sure we support this delay algorithm
        if (parameters.algorithm != delayAlgorithm::kNormal &&
            parameters.algorithm != delayAlgorithm::kPingPong)
            return false;
 
        // --- if only one output channel, revert to mono operation
        if (outputChannels == 1)
        {
            // --- process left channel only
            outputFrame[0] = (float)processAudioSample(inputFrame[0]);
            return true;
        }
 
        // --- if we get here we know we have 2 output channels
        //
        // --- pick up inputs
        //
        // --- LEFT channel
        double xnL = inputFrame[0];
 
        // --- RIGHT channel (duplicate left input if mono-in)
        double xnR = inputChannels > 1 ? inputFrame[1] : xnL;
 
        // --- read delay LEFT
        double ynL = delayBuffer_L.readBuffer(delayInSamples_L);
 
        // --- read delay RIGHT
        double ynR = delayBuffer_R.readBuffer(delayInSamples_R);
 
        // --- create input for delay buffer with LEFT channel info
        double dnL = xnL + (parameters.feedback_Pct / 100.0) * ynL;
 
        // --- create input for delay buffer with RIGHT channel info
        double dnR = xnR + (parameters.feedback_Pct / 100.0) * ynR;
 
        // --- decode
        if (parameters.algorithm == delayAlgorithm::kNormal)
        {
            // --- write to LEFT delay buffer with LEFT channel info
            delayBuffer_L.writeBuffer(dnL);
 
            // --- write to RIGHT delay buffer with RIGHT channel info
            delayBuffer_R.writeBuffer(dnR);
        }
        else if (parameters.algorithm == delayAlgorithm::kPingPong)
        {
            // --- write to LEFT delay buffer with RIGHT channel info
            delayBuffer_L.writeBuffer(dnR);
 
            // --- write to RIGHT delay buffer with LEFT channel info
            delayBuffer_R.writeBuffer(dnL);
        }
 
        // --- form mixture out = dry*xn + wet*yn
        double outputL = dryMix*xnL + wetMix*ynL;
 
        // --- form mixture out = dry*xn + wet*yn
        double outputR = dryMix*xnR + wetMix*ynR;
 
        // --- set left channel
        outputFrame[0] = (float)outputL;
 
        // --- set right channel
        outputFrame[1] = (float)outputR;
 
        return true;
    }
 
    AudioDelayParameters getParameters() { return parameters; }
 
    void setParameters(AudioDelayParameters _parameters)
    {
        // --- check mix in dB for calc
        if (_parameters.dryLevel_dB != parameters.dryLevel_dB)
            dryMix = pow(10.0, _parameters.dryLevel_dB / 20.0);
        if (_parameters.wetLevel_dB != parameters.wetLevel_dB)
            wetMix = pow(10.0, _parameters.wetLevel_dB / 20.0);
 
        // --- save; rest of updates are cheap on CPU
        parameters = _parameters;
 
        // --- check update type first:
        if (parameters.updateType == delayUpdateType::kLeftAndRight)
        {
            // --- set left and right delay times
            // --- calculate total delay time in samples + fraction
            double newDelayInSamples_L = parameters.leftDelay_mSec*(samplesPerMSec);
            double newDelayInSamples_R = parameters.rightDelay_mSec*(samplesPerMSec);
 
            // --- new delay time with fraction
            delayInSamples_L = newDelayInSamples_L;
            delayInSamples_R = newDelayInSamples_R;
        }
        else if (parameters.updateType == delayUpdateType::kLeftPlusRatio)
        {
            // --- get and validate ratio
            double delayRatio = parameters.delayRatio_Pct / 100.0;
            boundValue(delayRatio, 0.0, 1.0);
 
            // --- calculate total delay time in samples + fraction
            double newDelayInSamples = parameters.leftDelay_mSec*(samplesPerMSec);
 
            // --- new delay time with fraction
            delayInSamples_L = newDelayInSamples;
            delayInSamples_R = delayInSamples_L*delayRatio;
        }
    }
 
    void createDelayBuffers(double _sampleRate, double _bufferLength_mSec)
    {
        // --- store for math
        bufferLength_mSec = _bufferLength_mSec;
        sampleRate = _sampleRate;
        samplesPerMSec = sampleRate / 1000.0;
 
        // --- total buffer length including fractional part
        bufferLength = (unsigned int)(bufferLength_mSec*(samplesPerMSec)) + 1; // +1 for fractional part
 
                                                                               // --- create new buffer
        delayBuffer_L.createCircularBuffer(bufferLength);
        delayBuffer_R.createCircularBuffer(bufferLength);
    }
 
private:
    AudioDelayParameters parameters; 
 
    double sampleRate = 0.0;        
    double samplesPerMSec = 0.0;    
    double delayInSamples_L = 0.0;  
    double delayInSamples_R = 0.0;  
    double bufferLength_mSec = 0.0; 
    unsigned int bufferLength = 0;  
    double wetMix = 0.707; 
    double dryMix = 0.707; 
 
    // --- delay buffer of doubles
    CircularBuffer<double> delayBuffer_L;   
    CircularBuffer<double> delayBuffer_R;   
};
 
 
enum class generatorWaveform { kTriangle, kSin, kSaw };
 
struct OscillatorParameters
{
    OscillatorParameters() {}
    OscillatorParameters& operator=(const OscillatorParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        waveform = params.waveform;
        frequency_Hz = params.frequency_Hz;
        return *this;
    }
 
    // --- individual parameters
    generatorWaveform waveform = generatorWaveform::kTriangle; 
    double frequency_Hz = 0.0;  
};
 
class LFO : public IAudioSignalGenerator
{
public:
    LFO() { srand((uint32_t)time(NULL)); }  /* C-TOR */
    virtual ~LFO() {}               /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        phaseInc = lfoParameters.frequency_Hz / sampleRate;
 
        // --- timebase variables
        modCounter = 0.0;           
        modCounterQP = 0.25;        
 
        return true;
    }
 
    OscillatorParameters getParameters(){ return lfoParameters; }
 
    void setParameters(const OscillatorParameters& params)
    {
        if(params.frequency_Hz != lfoParameters.frequency_Hz)
            // --- update phase inc based on osc freq and fs
            phaseInc = params.frequency_Hz / sampleRate;
 
        lfoParameters = params;
    }
 
    virtual const SignalGenData renderAudioOutput();
 
protected:
    // --- parameters
    OscillatorParameters lfoParameters; 
 
    // --- sample rate
    double sampleRate = 0.0;            
 
    // --- timebase variables
    double modCounter = 0.0;            
    double phaseInc = 0.0;              
    double modCounterQP = 0.25;         
 
    inline bool checkAndWrapModulo(double& moduloCounter, double phaseInc)
    {
        // --- for positive frequencies
        if (phaseInc > 0 && moduloCounter >= 1.0)
        {
            moduloCounter -= 1.0;
            return true;
        }
 
        // --- for negative frequencies
        if (phaseInc < 0 && moduloCounter <= 0.0)
        {
            moduloCounter += 1.0;
            return true;
        }
 
        return false;
    }
 
    inline bool advanceAndCheckWrapModulo(double& moduloCounter, double phaseInc)
    {
        // --- advance counter
        moduloCounter += phaseInc;
 
        // --- for positive frequencies
        if (phaseInc > 0 && moduloCounter >= 1.0)
        {
            moduloCounter -= 1.0;
            return true;
        }
 
        // --- for negative frequencies
        if (phaseInc < 0 && moduloCounter <= 0.0)
        {
            moduloCounter += 1.0;
            return true;
        }
 
        return false;
    }
 
    inline void advanceModulo(double& moduloCounter, double phaseInc) { moduloCounter += phaseInc; }
 
    const double B = 4.0 / kPi;
    const double C = -4.0 / (kPi* kPi);
    const double P = 0.225;
    inline double parabolicSine(double angle)
    {
        double y = B * angle + C * angle * fabs(angle);
        y = P * (y * fabs(y) - y) + y;
        return y;
    }
};
 
enum DFOscillatorCoeffs { df_b1, df_b2, numDFOCoeffs };
 
enum DFOscillatorStates { df_yz1, df_yz2, numDFOStates };
 
 
class DFOscillator : public IAudioSignalGenerator
{
public:
    DFOscillator() { }  /* C-TOR */
    virtual ~DFOscillator() {}              /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        memset(&stateArray[0], 0, sizeof(double)*numDFOStates);
        updateDFO();
        return true;
    }
 
    OscillatorParameters getParameters()
    {
        return parameters;
    }
 
    void setParameters(const OscillatorParameters& params)
    {
        if (parameters.frequency_Hz != params.frequency_Hz)
        {
            parameters = params;
            updateDFO();
        }
    }
 
    virtual const SignalGenData renderAudioOutput()
    {
        // --- calculates normal and inverted outputs; quadphase are not used
        SignalGenData output;
 
        // -- do difference equation y(n) = -b1y(n-2) - b2y(n-2)
        output.normalOutput = (-coeffArray[df_b1]*stateArray[df_yz1] - coeffArray[df_b2]*stateArray[df_yz2]);
        output.invertedOutput = -output.normalOutput;
 
        // --- update states
        stateArray[df_yz2] = stateArray[df_yz1];
        stateArray[df_yz1] = output.normalOutput;
 
        return output;
    }
 
    void updateDFO()
    {
        // --- Oscillation Rate = theta = wT = w/fs
        double wT = (kTwoPi*parameters.frequency_Hz) / sampleRate;
 
        // --- coefficients to place poles right on unit circle
        coeffArray[df_b1] = -2.0*cos(wT);   // <--- set angle a = -2Rcod(theta)
        coeffArray[df_b2] = 1.0;            // <--- R^2 = 1, so R = 1
 
        // --- now update states to reflect the new frequency
        //     re calculate the new initial conditions
        //     arcsine of y(n-1) gives us wnT
        double wnT1 = asin(stateArray[df_yz1]);
 
        // find n by dividing wnT by wT
        double n = wnT1 / wT;
 
        // --- re calculate the new initial conditions
        //     asin returns values from -pi/2 to +pi/2 where the sinusoid
        //     moves from -1 to +1 -- the leading (rising) edge of the
        //     sinewave. If we are on that leading edge (increasing)
        //     then we use the value 1T behind.
        //
        //     If we are on the falling edge, we use the value 1T ahead
        //     because it mimics the value that would be 1T behind
        if (stateArray[df_yz1] > stateArray[df_yz2])
            n -= 1;
        else
            n += 1;
 
        // ---  calculate the new (old) sample
        stateArray[df_yz2] = sin((n)*wT);
    }
 
 
protected:
    // --- parameters
    OscillatorParameters parameters; 
 
    // --- implementation of half a biquad - this object is extremely specific
    double stateArray[numDFOStates] = { 0.0, 0.0 };
    double coeffArray[numDFOCoeffs] = { 0.0, 0.0 };
 
    // --- sample rate
    double sampleRate = 0.0;            
};
 
 
enum class modDelaylgorithm { kFlanger, kChorus, kVibrato };
 
 
struct ModulatedDelayParameters
{
    ModulatedDelayParameters() {}
    ModulatedDelayParameters& operator=(const ModulatedDelayParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        algorithm = params.algorithm;
        lfoRate_Hz = params.lfoRate_Hz;
        lfoDepth_Pct = params.lfoDepth_Pct;
        feedback_Pct = params.feedback_Pct;
        return *this;
    }
 
    // --- individual parameters
    modDelaylgorithm algorithm = modDelaylgorithm::kFlanger; 
    double lfoRate_Hz = 0.0;    
    double lfoDepth_Pct = 0.0;  
    double feedback_Pct = 0.0;  
};
 
class ModulatedDelay : public IAudioSignalProcessor
{
public:
    ModulatedDelay() {
    }       /* C-TOR */
    ~ModulatedDelay() {}    /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- create new buffer, 100mSec long
        delay.reset(_sampleRate);
        delay.createDelayBuffers(_sampleRate, 100.0);
 
        // --- lfo
        lfo.reset(_sampleRate);
        OscillatorParameters params = lfo.getParameters();
        params.waveform = generatorWaveform::kTriangle;
        lfo.setParameters(params);
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        float input = (float)xn;
        float output = 0.0;
        processAudioFrame(&input, &output, 1, 1);
        return output;
    }
 
    virtual bool canProcessAudioFrame() { return true; }
 
    virtual bool processAudioFrame(const float* inputFrame,     /* ptr to one frame of data: pInputFrame[0] = left, pInputFrame[1] = right, etc...*/
        float* outputFrame,
        uint32_t inputChannels,
        uint32_t outputChannels)
    {
        // --- make sure we have input and outputs
        if (inputChannels == 0 || outputChannels == 0)
            return false;
 
        // --- render LFO
        SignalGenData lfoOutput = lfo.renderAudioOutput();
 
        // --- setup delay modulation
        AudioDelayParameters params = delay.getParameters();
        double minDelay_mSec = 0.0;
        double maxDepth_mSec = 0.0;
 
        // --- set delay times, wet/dry and feedback
        if (parameters.algorithm == modDelaylgorithm::kFlanger)
        {
            minDelay_mSec = 0.1;
            maxDepth_mSec = 7.0;
            params.wetLevel_dB = -3.0;
            params.dryLevel_dB = -3.0;
        }
        if (parameters.algorithm == modDelaylgorithm::kChorus)
        {
            minDelay_mSec = 10.0;
            maxDepth_mSec = 30.0;
            params.wetLevel_dB = -3.0;
            params.dryLevel_dB = -0.0;
            params.feedback_Pct = 0.0;
        }
        if (parameters.algorithm == modDelaylgorithm::kVibrato)
        {
            minDelay_mSec = 0.0;
            maxDepth_mSec = 7.0;
            params.wetLevel_dB = 0.0;
            params.dryLevel_dB = -96.0;
            params.feedback_Pct = 0.0;
        }
 
        // --- calc modulated delay times
        double depth = parameters.lfoDepth_Pct / 100.0;
        double modulationMin = minDelay_mSec;
        double modulationMax = minDelay_mSec + maxDepth_mSec;
 
        // --- flanger - unipolar
        if (parameters.algorithm == modDelaylgorithm::kFlanger)
            params.leftDelay_mSec = doUnipolarModulationFromMin(bipolarToUnipolar(depth * lfoOutput.normalOutput),
                                                                 modulationMin, modulationMax);
        else
            params.leftDelay_mSec = doBipolarModulation(depth * lfoOutput.normalOutput, modulationMin, modulationMax);
 
 
        // --- set right delay to match (*Hint Homework!)
        params.rightDelay_mSec = params.leftDelay_mSec;
 
        // --- modulate the delay
        delay.setParameters(params);
 
        // --- just call the function and pass our info in/out
        return delay.processAudioFrame(inputFrame, outputFrame, inputChannels, outputChannels);
    }
 
    ModulatedDelayParameters getParameters() { return parameters; }
 
    void setParameters(ModulatedDelayParameters _parameters)
    {
        // --- bulk copy
        parameters = _parameters;
 
        OscillatorParameters lfoParams = lfo.getParameters();
        lfoParams.frequency_Hz = parameters.lfoRate_Hz;
        if (parameters.algorithm == modDelaylgorithm::kVibrato)
            lfoParams.waveform = generatorWaveform::kSin;
        else
            lfoParams.waveform = generatorWaveform::kTriangle;
 
        lfo.setParameters(lfoParams);
 
        AudioDelayParameters adParams = delay.getParameters();
        adParams.feedback_Pct = parameters.feedback_Pct;
        delay.setParameters(adParams);
    }
 
private:
    ModulatedDelayParameters parameters; 
    AudioDelay delay;   
    LFO lfo;            
};
 
struct PhaseShifterParameters
{
    PhaseShifterParameters() {}
    PhaseShifterParameters& operator=(const PhaseShifterParameters& params)
    {
        if (this == &params)
            return *this;
 
        lfoRate_Hz = params.lfoRate_Hz;
        lfoDepth_Pct = params.lfoDepth_Pct;
        intensity_Pct = params.intensity_Pct;
        quadPhaseLFO = params.quadPhaseLFO;
        return *this;
    }
 
    // --- individual parameters
    double lfoRate_Hz = 0.0;    
    double lfoDepth_Pct = 0.0;  
    double intensity_Pct = 0.0; 
    bool quadPhaseLFO = false;  
};
 
// --- constants for Phaser
const unsigned int PHASER_STAGES = 6;
 
// --- these are the ideal band definitions
//const double apf0_minF = 16.0;
//const double apf0_maxF = 1600.0;
//
//const double apf1_minF = 33.0;
//const double apf1_maxF = 3300.0;
//
//const double apf2_minF = 48.0;
//const double apf2_maxF = 4800.0;
//
//const double apf3_minF = 98.0;
//const double apf3_maxF = 9800.0;
//
//const double apf4_minF = 160.0;
//const double apf4_maxF = 16000.0;
//
//const double apf5_minF = 260.0;
//const double apf5_maxF = 20480.0;
 
// --- these are the exact values from the National Semiconductor Phaser design
const double apf0_minF = 32.0;
const double apf0_maxF = 1500.0;
 
const double apf1_minF = 68.0;
const double apf1_maxF = 3400.0;
 
const double apf2_minF = 96.0;
const double apf2_maxF = 4800.0;
 
const double apf3_minF = 212.0;
const double apf3_maxF = 10000.0;
 
const double apf4_minF = 320.0;
const double apf4_maxF = 16000.0;
 
const double apf5_minF = 636.0;
const double apf5_maxF = 20480.0;
 
class PhaseShifter : public IAudioSignalProcessor
{
public:
    PhaseShifter(void) {
        OscillatorParameters lfoparams = lfo.getParameters();
        lfoparams.waveform = generatorWaveform::kTriangle;  // kTriangle LFO for phaser
    //  lfoparams.waveform = generatorWaveform::kSin;       // kTriangle LFO for phaser
        lfo.setParameters(lfoparams);
 
        AudioFilterParameters params = apf[0].getParameters();
        params.algorithm = filterAlgorithm::kAPF1; // can also use 2nd order
        // params.Q = 0.001; use low Q if using 2nd order APFs
 
        for (uint32_t i = 0; i < PHASER_STAGES; i++)
        {
            apf[i].setParameters(params);
        }
    }   /* C-TOR */
 
    ~PhaseShifter(void) {}  /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- reset LFO
        lfo.reset(_sampleRate);
 
        // --- reset APFs
        for (uint32_t i = 0; i < PHASER_STAGES; i++){
            apf[i].reset(_sampleRate);
        }
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        SignalGenData lfoData = lfo.renderAudioOutput();
 
        // --- create the bipolar modulator value
        double lfoValue = lfoData.normalOutput;
        if (parameters.quadPhaseLFO)
            lfoValue = lfoData.quadPhaseOutput_pos;
 
        double depth = parameters.lfoDepth_Pct / 100.0;
        double modulatorValue = lfoValue*depth;
 
        // --- calculate modulated values for each APF; note they have different ranges
        AudioFilterParameters params = apf[0].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf0_minF, apf0_maxF);
        apf[0].setParameters(params);
 
        params = apf[1].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf1_minF, apf1_maxF);
        apf[1].setParameters(params);
 
        params = apf[2].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf2_minF, apf2_maxF);
        apf[2].setParameters(params);
 
        params = apf[3].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf3_minF, apf3_maxF);
        apf[3].setParameters(params);
 
        params = apf[4].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf4_minF, apf4_maxF);
        apf[4].setParameters(params);
 
        params = apf[5].getParameters();
        params.fc = doBipolarModulation(modulatorValue, apf5_minF, apf5_maxF);
        apf[5].setParameters(params);
 
        // --- calculate gamma values
        double gamma1 = apf[5].getG_value();
        double gamma2 = apf[4].getG_value() * gamma1;
        double gamma3 = apf[3].getG_value() * gamma2;
        double gamma4 = apf[2].getG_value() * gamma3;
        double gamma5 = apf[1].getG_value() * gamma4;
        double gamma6 = apf[0].getG_value() * gamma5;
 
        // --- set the alpha0 value
        double K = parameters.intensity_Pct / 100.0;
        double alpha0 = 1.0 / (1.0 + K*gamma6);
 
        // --- create combined feedback
        double Sn = gamma5*apf[0].getS_value() + gamma4*apf[1].getS_value() + gamma3*apf[2].getS_value() + gamma2*apf[3].getS_value() + gamma1*apf[4].getS_value() + apf[5].getS_value();
 
        // --- form input to first APF
        double u = alpha0*(xn + K*Sn);
 
        // --- cascade of APFs (could also nest these in one massive line of code)
        double APF1 = apf[0].processAudioSample(u);
        double APF2 = apf[1].processAudioSample(APF1);
        double APF3 = apf[2].processAudioSample(APF2);
        double APF4 = apf[3].processAudioSample(APF3);
        double APF5 = apf[4].processAudioSample(APF4);
        double APF6 = apf[5].processAudioSample(APF5);
 
        // --- sum with -3dB coefficients
        //  double output = 0.707*xn + 0.707*APF6;
 
        // --- sum with National Semiconductor design ratio:
        //     dry = 0.5, wet = 5.0
        // double output = 0.5*xn + 5.0*APF6;
        // double output = 0.25*xn + 2.5*APF6;
        double output = 0.125*xn + 1.25*APF6;
 
        return output;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    PhaseShifterParameters getParameters() { return parameters; }
 
    void setParameters(const PhaseShifterParameters& params)
    {
        // --- update LFO rate
        if (params.lfoRate_Hz != parameters.lfoRate_Hz)
        {
            OscillatorParameters lfoparams = lfo.getParameters();
            lfoparams.frequency_Hz = params.lfoRate_Hz;
            lfo.setParameters(lfoparams);
        }
 
        // --- save new
        parameters = params;
    }
protected:
    PhaseShifterParameters parameters;  
    AudioFilter apf[PHASER_STAGES];     
    LFO lfo;                            
};
 
struct SimpleLPFParameters
{
    SimpleLPFParameters() {}
    SimpleLPFParameters& operator=(const SimpleLPFParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        g = params.g;
        return *this;
    }
 
    // --- individual parameters
    double g = 0.0; 
};
 
class SimpleLPF : public IAudioSignalProcessor
{
public:
    SimpleLPF(void) {}  /* C-TOR */
    ~SimpleLPF(void) {} /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        state = 0.0;
        return true;
    }
 
    SimpleLPFParameters getParameters()
    {
        return simpleLPFParameters;
    }
 
    void setParameters(const SimpleLPFParameters& params)
    {
        simpleLPFParameters = params;
    }
 
    virtual double processAudioSample(double xn)
    {
        double g = simpleLPFParameters.g;
        double yn = (1.0 - g)*xn + g*state;
        state = yn;
        return yn;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
private:
    SimpleLPFParameters simpleLPFParameters;    
    double state = 0.0;                         
};
 
struct SimpleDelayParameters
{
    SimpleDelayParameters() {}
    SimpleDelayParameters& operator=(const SimpleDelayParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        delayTime_mSec = params.delayTime_mSec;
        interpolate = params.interpolate;
        delay_Samples = params.delay_Samples;
        return *this;
    }
 
    // --- individual parameters
    double delayTime_mSec = 0.0;    
    bool interpolate = false;       
 
    // --- outbound parameters
    double delay_Samples = 0.0;     
};
 
class SimpleDelay : public IAudioSignalProcessor
{
public:
    SimpleDelay(void) {}    /* C-TOR */
    ~SimpleDelay(void) {}   /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- if sample rate did not change
        if (sampleRate == _sampleRate)
        {
            // --- just flush buffer and return
            delayBuffer.flushBuffer();
            return true;
        }
 
        // --- create new buffer, will store sample rate and length(mSec)
        createDelayBuffer(_sampleRate, bufferLength_mSec);
 
        return true;
    }
 
    SimpleDelayParameters getParameters()
    {
        return simpleDelayParameters;
    }
 
    void setParameters(const SimpleDelayParameters& params)
    {
        simpleDelayParameters = params;
        simpleDelayParameters.delay_Samples = simpleDelayParameters.delayTime_mSec*(samplesPerMSec);
        delayBuffer.setInterpolate(simpleDelayParameters.interpolate);
    }
 
    virtual double processAudioSample(double xn)
    {
        // --- read delay
        if (simpleDelayParameters.delay_Samples == 0)
            return xn;
 
        double yn = delayBuffer.readBuffer(simpleDelayParameters.delay_Samples);
 
        // --- write to delay buffer
        delayBuffer.writeBuffer(xn);
 
        // --- done
        return yn;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    void createDelayBuffer(double _sampleRate, double _bufferLength_mSec)
    {
        // --- store for math
        bufferLength_mSec = _bufferLength_mSec;
        sampleRate = _sampleRate;
        samplesPerMSec = sampleRate / 1000.0;
 
        // --- total buffer length including fractional part
        bufferLength = (unsigned int)(bufferLength_mSec*(samplesPerMSec)) + 1; // +1 for fractional part
 
        // --- create new buffer
        delayBuffer.createCircularBuffer(bufferLength);
    }
 
    double readDelay()
    {
        // --- simple read
        return delayBuffer.readBuffer(simpleDelayParameters.delay_Samples);
    }
 
    double readDelayAtTime_mSec(double _delay_mSec)
    {
        // --- calculate total delay time in samples + fraction
        double _delay_Samples = _delay_mSec*(samplesPerMSec);
 
        // --- simple read
        return delayBuffer.readBuffer(_delay_Samples);
    }
 
    double readDelayAtPercentage(double delayPercent)
    {
        // --- simple read
        return delayBuffer.readBuffer((delayPercent / 100.0)*simpleDelayParameters.delay_Samples);
    }
 
    void writeDelay(double xn)
    {
        // --- simple write
        delayBuffer.writeBuffer(xn);
    }
 
private:
    SimpleDelayParameters simpleDelayParameters; 
 
    double sampleRate = 0.0;        
    double samplesPerMSec = 0.0;    
    double bufferLength_mSec = 0.0; 
    unsigned int bufferLength = 0;  
 
    // --- delay buffer of doubles
    CircularBuffer<double> delayBuffer; 
};
 
 
struct CombFilterParameters
{
    CombFilterParameters() {}
    CombFilterParameters& operator=(const CombFilterParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        delayTime_mSec = params.delayTime_mSec;
        RT60Time_mSec = params.RT60Time_mSec;
        enableLPF = params.enableLPF;
        lpf_g = params.lpf_g;
        interpolate = params.interpolate;
        return *this;
    }
 
    // --- individual parameters
    double delayTime_mSec = 0.0;    
    double RT60Time_mSec = 0.0;     
    bool enableLPF = false;         
    double lpf_g = 0.0;             
    bool interpolate = false;       
};
 
 
class CombFilter : public IAudioSignalProcessor
{
public:
    CombFilter(void) {}     /* C-TOR */
    ~CombFilter(void) {}    /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- flush
        lpf_state = 0.0;
 
        // --- create new buffer, will store sample rate and length(mSec)
        createDelayBuffer(sampleRate, bufferLength_mSec);
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        double yn = delay.readDelay();
        double input = 0.0;
 
        // --- form input & write
        if (combFilterParameters.enableLPF)
        {
            // --- apply simple 1st order pole LPF
            double g2 = lpf_g*(1.0 - comb_g); // see book for equation 11.27 (old book)
            double filteredSignal = yn + g2*lpf_state;
            input = xn + comb_g*(filteredSignal);
            lpf_state = filteredSignal;
        }
        else
        {
            input = xn + comb_g*yn;
        }
 
        delay.writeDelay(input);
 
        // --- done
        return yn;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    CombFilterParameters getParameters()
    {
        return combFilterParameters;
    }
 
    void setParameters(const CombFilterParameters& params)
    {
        combFilterParameters = params;
 
        // --- update the delay line parameters first
        SimpleDelayParameters delayParams = delay.getParameters();
        delayParams.delayTime_mSec = combFilterParameters.delayTime_mSec;
        delayParams.interpolate = combFilterParameters.interpolate;
        delay.setParameters(delayParams); // this will set the delay time in samples
 
                                          // --- calculate g with RT60 time (requires updated delay above^^)
        double exponent = -3.0*delayParams.delay_Samples*(1.0 / sampleRate);
        double rt60_mSec = combFilterParameters.RT60Time_mSec / 1000.0; // RT is in mSec!
        comb_g = pow(10.0, exponent / rt60_mSec);
 
        // --- set LPF g
        lpf_g = combFilterParameters.lpf_g;
    }
 
    void createDelayBuffer(double _sampleRate, double delay_mSec)
    {
        sampleRate = _sampleRate;
        bufferLength_mSec = delay_mSec;
 
        // --- create new buffer, will store sample rate and length(mSec)
        delay.createDelayBuffer(_sampleRate, delay_mSec);
    }
 
private:
    CombFilterParameters combFilterParameters; 
    double sampleRate = 0.0;    
    double comb_g = 0.0;        
    double bufferLength_mSec = 0.0; 
 
    // --- LPF support
    double lpf_g = 0.0;     
    double lpf_state = 0.0; 
 
    // --- delay buffer of doubles
    SimpleDelay delay;      
};
 
struct DelayAPFParameters
{
    DelayAPFParameters() {}
    DelayAPFParameters& operator=(const DelayAPFParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        delayTime_mSec = params.delayTime_mSec;
        apf_g = params.apf_g;
        enableLPF = params.enableLPF;
        lpf_g = params.lpf_g;
        interpolate = params.interpolate;
        enableLFO = params.enableLFO;
        lfoRate_Hz = params.lfoRate_Hz;
        lfoDepth = params.lfoDepth;
        lfoMaxModulation_mSec = params.lfoMaxModulation_mSec;
        return *this;
    }
 
    // --- individual parameters
    double delayTime_mSec = 0.0;    
    double apf_g = 0.0;             
    bool enableLPF = false;         
    double lpf_g = 0.0;             
    bool interpolate = false;       
    bool enableLFO = false;         
    double lfoRate_Hz = 0.0;        
    double lfoDepth = 0.0;          
    double lfoMaxModulation_mSec = 0.0; 
 
};
 
class DelayAPF : public IAudioSignalProcessor
{
public:
    DelayAPF(void) {}   /* C-TOR */
    ~DelayAPF(void) {}  /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- reset children
        modLFO.reset(_sampleRate);
 
        // --- flush
        lpf_state = 0.0;
 
        // --- create new buffer, will store sample rate and length(mSec)
        createDelayBuffer(sampleRate, bufferLength_mSec);
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        SimpleDelayParameters delayParams = delay.getParameters();
        if (delayParams.delay_Samples == 0)
            return xn;
 
        // --- delay line output
        double wnD = 0.0;
        double apf_g = delayAPFParameters.apf_g;
        double lpf_g = delayAPFParameters.lpf_g;
        double lfoDepth = delayAPFParameters.lfoDepth;
 
        // --- for modulated APFs
        if (delayAPFParameters.enableLFO)
        {
            SignalGenData lfoOutput = modLFO.renderAudioOutput();
            double maxDelay = delayParams.delayTime_mSec;
            double minDelay = maxDelay - delayAPFParameters.lfoMaxModulation_mSec;
            minDelay = fmax(0.0, minDelay); // bound minDelay to 0 as minimum
 
            // --- calc max-down modulated value with unipolar converted LFO output
            //     NOTE: LFO output is scaled by lfoDepth
            double modDelay_mSec = doUnipolarModulationFromMax(bipolarToUnipolar(lfoDepth*lfoOutput.normalOutput),
                minDelay, maxDelay);
 
            // --- read modulated value to get w(n-D);
            wnD = delay.readDelayAtTime_mSec(modDelay_mSec);
        }
        else
            // --- read the delay line to get w(n-D)
            wnD = delay.readDelay();
 
        if (delayAPFParameters.enableLPF)
        {
            // --- apply simple 1st order pole LPF, overwrite wnD
            wnD = wnD*(1.0 - lpf_g) + lpf_g*lpf_state;
            lpf_state = wnD;
        }
 
        // form w(n) = x(n) + gw(n-D)
        double wn = xn + apf_g*wnD;
 
        // form y(n) = -gw(n) + w(n-D)
        double yn = -apf_g*wn + wnD;
 
        // underflow check
        checkFloatUnderflow(yn);
 
        // write delay line
        delay.writeDelay(wn);
 
        return yn;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    DelayAPFParameters getParameters()
    {
        return delayAPFParameters;
    }
 
    void setParameters(const DelayAPFParameters& params)
    {
        delayAPFParameters = params;
 
        // --- update delay line
        SimpleDelayParameters delayParams = delay.getParameters();
        delayParams.delayTime_mSec = delayAPFParameters.delayTime_mSec;
        delay.setParameters(delayParams);
    }
 
    void createDelayBuffer(double _sampleRate, double delay_mSec)
    {
        sampleRate = _sampleRate;
        bufferLength_mSec = delay_mSec;
 
        // --- create new buffer, will store sample rate and length(mSec)
        delay.createDelayBuffer(_sampleRate, delay_mSec);
    }
 
protected:
    // --- component parameters
    DelayAPFParameters delayAPFParameters;  
    double sampleRate = 0.0;                
    double bufferLength_mSec = 0.0;         
 
    // --- delay buffer of doubles
    SimpleDelay delay;                      
 
    // --- optional LFO
    LFO modLFO;                             
 
    // --- LPF support
    double lpf_state = 0.0;                 
};
 
 
struct NestedDelayAPFParameters
{
    NestedDelayAPFParameters() {}
    NestedDelayAPFParameters& operator=(const NestedDelayAPFParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        outerAPFdelayTime_mSec = params.outerAPFdelayTime_mSec;
        innerAPFdelayTime_mSec = params.innerAPFdelayTime_mSec;
        outerAPF_g = params.outerAPF_g;
        innerAPF_g = params.innerAPF_g;
 
        // --- outer LFO
        enableLFO = params.enableLFO;
        lfoRate_Hz = params.lfoRate_Hz;
        lfoDepth = params.lfoDepth;
        lfoMaxModulation_mSec = params.lfoMaxModulation_mSec;
 
        return *this;
    }
 
    // --- individual parameters
    double outerAPFdelayTime_mSec = 0.0;    
    double innerAPFdelayTime_mSec = 0.0;    
    double outerAPF_g = 0.0;                
    double innerAPF_g = 0.0;                
 
    // --- this LFO belongs to the outer APF only
    bool enableLFO = false;                 
    double lfoRate_Hz = 0.0;                
    double lfoDepth = 1.0;                  
    double lfoMaxModulation_mSec = 0.0;     
 
};
 
class NestedDelayAPF : public DelayAPF
{
public:
    NestedDelayAPF(void) { }    /* C-TOR */
    ~NestedDelayAPF(void) { }   /* D-TOR */
 
public:
    virtual bool reset(double _sampleRate)
    {
        // --- call base class reset first
        DelayAPF::reset(_sampleRate);
 
        // --- then do our stuff
        nestedAPF.reset(_sampleRate);
 
        return true;
    }
 
    virtual double processAudioSample(double xn)
    {
        // --- delay line output
        double wnD = 0.0;
 
        SimpleDelayParameters delayParams = delay.getParameters();
        if (delayParams.delay_Samples == 0)
            return xn;
 
        double apf_g = delayAPFParameters.apf_g;
        double lpf_g = delayAPFParameters.lpf_g;
 
        // --- for modulated APFs
        if (delayAPFParameters.enableLFO)
        {
            SignalGenData lfoOutput = modLFO.renderAudioOutput();
            double maxDelay = delayParams.delayTime_mSec;
            double minDelay = maxDelay - delayAPFParameters.lfoMaxModulation_mSec;
            minDelay = fmax(0.0, minDelay); // bound minDelay to 0 as minimum
            double lfoDepth = delayAPFParameters.lfoDepth;
 
            // --- calc max-down modulated value with unipolar converted LFO output
            //     NOTE: LFO output is scaled by lfoDepth
            double modDelay_mSec = doUnipolarModulationFromMax(bipolarToUnipolar(lfoDepth*lfoOutput.normalOutput),
                minDelay, maxDelay);
 
            // --- read modulated value to get w(n-D);
            wnD = delay.readDelayAtTime_mSec(modDelay_mSec);
        }
        else
            // --- read the delay line to get w(n-D)
            wnD = delay.readDelay();
 
        if (delayAPFParameters.enableLPF)
        {
            // --- apply simple 1st order pole LPF, overwrite wnD
            wnD = wnD*(1.0 - lpf_g) + lpf_g*lpf_state;
            lpf_state = wnD;
        }
 
        // --- form w(n) = x(n) + gw(n-D)
        double wn = xn + apf_g*wnD;
 
        // --- process wn through inner APF
        double ynInner = nestedAPF.processAudioSample(wn);
 
        // --- form y(n) = -gw(n) + w(n-D)
        double yn = -apf_g*wn + wnD;
 
        // --- underflow check
        checkFloatUnderflow(yn);
 
        // --- write delay line
        delay.writeDelay(ynInner);
 
        return yn;
    }
 
    NestedDelayAPFParameters getParameters() { return nestedAPFParameters; }
 
    void setParameters(const NestedDelayAPFParameters& params)
    {
        nestedAPFParameters = params;
 
        DelayAPFParameters outerAPFParameters = DelayAPF::getParameters();
        DelayAPFParameters innerAPFParameters = nestedAPF.getParameters();
 
        // --- outer APF
        outerAPFParameters.apf_g = nestedAPFParameters.outerAPF_g;
        outerAPFParameters.delayTime_mSec = nestedAPFParameters.outerAPFdelayTime_mSec;
 
        // --- LFO support
        outerAPFParameters.enableLFO = nestedAPFParameters.enableLFO;
        outerAPFParameters.lfoDepth = nestedAPFParameters.lfoDepth;
        outerAPFParameters.lfoRate_Hz = nestedAPFParameters.lfoRate_Hz;
        outerAPFParameters.lfoMaxModulation_mSec = nestedAPFParameters.lfoMaxModulation_mSec;
 
        // --- inner APF
        innerAPFParameters.apf_g = nestedAPFParameters.innerAPF_g;
        innerAPFParameters.delayTime_mSec = nestedAPFParameters.innerAPFdelayTime_mSec;
 
        DelayAPF::setParameters(outerAPFParameters);
        nestedAPF.setParameters(innerAPFParameters);
    }
 
    void createDelayBuffers(double _sampleRate, double delay_mSec, double nestedAPFDelay_mSec)
    {
        // --- base class
        DelayAPF::createDelayBuffer(_sampleRate, delay_mSec);
 
        // --- then our stuff
        nestedAPF.createDelayBuffer(_sampleRate, nestedAPFDelay_mSec);
    }
 
private:
    NestedDelayAPFParameters nestedAPFParameters; 
    DelayAPF nestedAPF; 
};
 
struct TwoBandShelvingFilterParameters
{
    TwoBandShelvingFilterParameters() {}
    TwoBandShelvingFilterParameters& operator=(const TwoBandShelvingFilterParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        lowShelf_fc = params.lowShelf_fc;
        lowShelfBoostCut_dB = params.lowShelfBoostCut_dB;
        highShelf_fc = params.highShelf_fc;
        highShelfBoostCut_dB = params.highShelfBoostCut_dB;
        return *this;
    }
 
    // --- individual parameters
    double lowShelf_fc = 0.0;           
    double lowShelfBoostCut_dB = 0.0;   
    double highShelf_fc = 0.0;          
    double highShelfBoostCut_dB = 0.0;  
};
 
class TwoBandShelvingFilter : public IAudioSignalProcessor
{
public:
    TwoBandShelvingFilter()
    {
        AudioFilterParameters params = lowShelfFilter.getParameters();
        params.algorithm = filterAlgorithm::kLowShelf;
        lowShelfFilter.setParameters(params);
 
        params = highShelfFilter.getParameters();
        params.algorithm = filterAlgorithm::kHiShelf;
        highShelfFilter.setParameters(params);
    }       /* C-TOR */
 
    ~TwoBandShelvingFilter() {}     /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        lowShelfFilter.reset(_sampleRate);
        highShelfFilter.reset(_sampleRate);
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- all modes do Full Wave Rectification
        double filteredSignal = lowShelfFilter.processAudioSample(xn);
        filteredSignal = highShelfFilter.processAudioSample(filteredSignal);
 
        return filteredSignal;
    }
 
    TwoBandShelvingFilterParameters getParameters()
    {
        return parameters;
    }
 
    void setParameters(const TwoBandShelvingFilterParameters& params)
    {
        parameters = params;
        AudioFilterParameters filterParams = lowShelfFilter.getParameters();
        filterParams.fc = parameters.lowShelf_fc;
        filterParams.boostCut_dB = parameters.lowShelfBoostCut_dB;
        lowShelfFilter.setParameters(filterParams);
 
        filterParams = highShelfFilter.getParameters();
        filterParams.fc = parameters.highShelf_fc;
        filterParams.boostCut_dB = parameters.highShelfBoostCut_dB;
        highShelfFilter.setParameters(filterParams);
    }
 
private:
    TwoBandShelvingFilterParameters parameters; 
    AudioFilter lowShelfFilter;                 
    AudioFilter highShelfFilter;                
};
 
enum class reverbDensity { kThick, kSparse };
 
struct ReverbTankParameters
{
    ReverbTankParameters() {}
    ReverbTankParameters& operator=(const ReverbTankParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        density = params.density;
 
        // --- tweaker variables
        apfDelayMax_mSec = params.apfDelayMax_mSec;
        apfDelayWeight_Pct = params.apfDelayWeight_Pct;
        fixeDelayMax_mSec = params.fixeDelayMax_mSec;
        fixeDelayWeight_Pct = params.fixeDelayWeight_Pct;
        preDelayTime_mSec = params.preDelayTime_mSec;
 
        lpf_g = params.lpf_g;
        kRT = params.kRT;
 
        lowShelf_fc = params.lowShelf_fc;
        lowShelfBoostCut_dB = params.lowShelfBoostCut_dB;
        highShelf_fc = params.highShelf_fc;
        highShelfBoostCut_dB = params.highShelfBoostCut_dB;
 
        wetLevel_dB = params.wetLevel_dB;
        dryLevel_dB = params.dryLevel_dB;
        return *this;
    }
 
    // --- individual parameters
    reverbDensity density = reverbDensity::kThick;  
 
    // --- tweaking parameters - you may not want to expose these
    //     in the final plugin!
    // --- See the book for all the details on how these tweakers work!!
    double apfDelayMax_mSec = 5.0;                  
    double apfDelayWeight_Pct = 100.0;              
    double fixeDelayMax_mSec = 50.0;                
    double fixeDelayWeight_Pct = 100.0;             
 
    // --- direct control parameters
    double preDelayTime_mSec = 0.0;                 
    double lpf_g = 0.0;                             
    double kRT = 0.0;                               
 
    double lowShelf_fc = 0.0;                       
    double lowShelfBoostCut_dB = 0.0;               
    double highShelf_fc = 0.0;                      
    double highShelfBoostCut_dB = 0.0;              
 
    double wetLevel_dB = -3.0;                      
    double dryLevel_dB = -3.0;                      
};
 
// --- constants for reverb tank
const unsigned int NUM_BRANCHES = 4;
const unsigned int NUM_CHANNELS = 2; // stereo
 
class ReverbTank : public IAudioSignalProcessor
{
public:
    ReverbTank() {}     /* C-TOR */
    ~ReverbTank() {}    /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        // ---store
        sampleRate = _sampleRate;
 
        // ---set up preDelay
        preDelay.reset(_sampleRate);
        preDelay.createDelayBuffer(_sampleRate, 100.0);
 
        for (uint32_t i = 0; i < NUM_BRANCHES; i++)
        {
            branchDelays[i].reset(_sampleRate);
            branchDelays[i].createDelayBuffer(_sampleRate, 100.0);
 
            branchNestedAPFs[i].reset(_sampleRate);
            branchNestedAPFs[i].createDelayBuffers(_sampleRate, 100.0, 100.0);
 
            branchLPFs[i].reset(_sampleRate);
        }
        for (uint32_t i = 0; i < NUM_CHANNELS; i++)
        {
            shelvingFilters[i].reset(_sampleRate);
        }
 
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return true; }
 
    virtual double processAudioSample(double xn)
    {
        float inputs[2] = { 0.0, 0.0 };
        float outputs[2] = { 0.0, 0.0 };
        processAudioFrame(inputs, outputs, 1, 1);
        return outputs[0];
    }
 
    virtual bool processAudioFrame(const float* inputFrame,
        float* outputFrame,
        uint32_t inputChannels,
        uint32_t outputChannels)
    {
        // --- global feedback from delay in last branch
        double globFB = branchDelays[NUM_BRANCHES-1].readDelay();
 
        // --- feedback value
        double fb = parameters.kRT*(globFB);
 
        // --- mono-ized input signal
        double xnL = inputFrame[0];
        double xnR = inputChannels > 1 ? inputFrame[1] : 0.0;
        double monoXn = double(1.0 / inputChannels)*xnL + double(1.0 / inputChannels)*xnR;
 
        // --- pre delay output
        double preDelayOut = preDelay.processAudioSample(monoXn);
 
        // --- input to first branch = preDalay + globFB
        double input = preDelayOut + fb;
        for (uint32_t i = 0; i < NUM_BRANCHES; i++)
        {
            double apfOut = branchNestedAPFs[i].processAudioSample(input);
            double lpfOut = branchLPFs[i].processAudioSample(apfOut);
            double delayOut = parameters.kRT*branchDelays[i].processAudioSample(lpfOut);
            input = delayOut + preDelayOut;
        }
        // --- gather outputs
        /*
        There are 25 prime numbers between 1 and 100.
        They are 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
        43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, and 97
 
        we want 16 of them: 23, 29, 31, 37, 41,
        43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, and 97
        */
 
        double weight = 0.707;
 
        double outL= 0.0;
        outL += weight*branchDelays[0].readDelayAtPercentage(23.0);
        outL -= weight*branchDelays[1].readDelayAtPercentage(41.0);
        outL += weight*branchDelays[2].readDelayAtPercentage(59.0);
        outL -= weight*branchDelays[3].readDelayAtPercentage(73.0);
 
        double outR = 0.0;
        outR -= weight*branchDelays[0].readDelayAtPercentage(29.0);
        outR += weight*branchDelays[1].readDelayAtPercentage(43.0);
        outR -= weight*branchDelays[2].readDelayAtPercentage(61.0);
        outR += weight*branchDelays[3].readDelayAtPercentage(79.0);
 
        if (parameters.density == reverbDensity::kThick)
        {
            outL += weight*branchDelays[0].readDelayAtPercentage(31.0);
            outL -= weight*branchDelays[1].readDelayAtPercentage(47.0);
            outL += weight*branchDelays[2].readDelayAtPercentage(67.0);
            outL -= weight*branchDelays[3].readDelayAtPercentage(83.0);
 
            outR -= weight*branchDelays[0].readDelayAtPercentage(37.0);
            outR += weight*branchDelays[1].readDelayAtPercentage(53.0);
            outR -= weight*branchDelays[2].readDelayAtPercentage(71.0);
            outR += weight*branchDelays[3].readDelayAtPercentage(89.0);
        }
 
        // ---  filter
        double tankOutL = shelvingFilters[0].processAudioSample(outL);
        double tankOutR = shelvingFilters[1].processAudioSample(outR);
 
        // --- sum with dry
        double dry = pow(10.0, parameters.dryLevel_dB / 20.0);
        double wet = pow(10.0, parameters.wetLevel_dB / 20.0);
 
        if (outputChannels == 1)
            outputFrame[0] = (float)(dry*xnL + wet*(0.5*tankOutL + 0.5*tankOutR));
        else
        {
            outputFrame[0] = (float)(dry*xnL + wet*tankOutL);
            outputFrame[1] = (float)(dry*xnR + wet*tankOutR);
        }
 
        return true;
    }
 
    ReverbTankParameters getParameters() { return parameters; }
 
    void setParameters(const ReverbTankParameters& params)
    {
        // --- do the updates here, the sub-components will only update themselves if
        //     their parameters changed, so we let those object handle that chore
        TwoBandShelvingFilterParameters filterParams = shelvingFilters[0].getParameters();
        filterParams.highShelf_fc = params.highShelf_fc;
        filterParams.highShelfBoostCut_dB = params.highShelfBoostCut_dB;
        filterParams.lowShelf_fc = params.lowShelf_fc;
        filterParams.lowShelfBoostCut_dB = params.lowShelfBoostCut_dB;
 
        // --- copy to both channels
        shelvingFilters[0].setParameters(filterParams);
        shelvingFilters[1].setParameters(filterParams);
 
        SimpleLPFParameters  lpfParams = branchLPFs[0].getParameters();
        lpfParams.g = params.lpf_g;
 
        for (uint32_t i = 0; i < NUM_BRANCHES; i++)
        {
            branchLPFs[i].setParameters(lpfParams);
        }
 
        // --- update pre delay
        SimpleDelayParameters delayParams = preDelay.getParameters();
        delayParams.delayTime_mSec = params.preDelayTime_mSec;
        preDelay.setParameters(delayParams);
 
        // --- set apf and delay parameters
        int m = 0;
        NestedDelayAPFParameters apfParams = branchNestedAPFs[0].getParameters();
        delayParams = branchDelays[0].getParameters();
 
        // --- global max Delay times
        double globalAPFMaxDelay = (parameters.apfDelayWeight_Pct / 100.0)*parameters.apfDelayMax_mSec;
        double globalFixedMaxDelay = (parameters.fixeDelayWeight_Pct / 100.0)*parameters.fixeDelayMax_mSec;
 
        // --- lfo
        apfParams.enableLFO = true;
        apfParams.lfoMaxModulation_mSec = 0.3;
        apfParams.lfoDepth = 1.0;
 
        for (uint32_t i = 0; i < NUM_BRANCHES; i++)
        {
            // --- setup APFs
            apfParams.outerAPFdelayTime_mSec = globalAPFMaxDelay*apfDelayWeight[m++];
            apfParams.innerAPFdelayTime_mSec = globalAPFMaxDelay*apfDelayWeight[m++];
            apfParams.innerAPF_g = -0.5;
            apfParams.outerAPF_g = 0.5;
            if (i == 0)
                apfParams.lfoRate_Hz = 0.15;
            else if (i == 1)
                apfParams.lfoRate_Hz = 0.33;
            else if (i == 2)
                apfParams.lfoRate_Hz = 0.57;
            else if (i == 3)
                apfParams.lfoRate_Hz = 0.73;
 
            branchNestedAPFs[i].setParameters(apfParams);
 
            // --- fixedDelayWeight
            delayParams.delayTime_mSec = globalFixedMaxDelay*fixedDelayWeight[i];
            branchDelays[i].setParameters(delayParams);
        }
 
        // --- save our copy
        parameters = params;
    }
 
 
private:
    ReverbTankParameters parameters;                
 
    SimpleDelay  preDelay;                          
    SimpleDelay  branchDelays[NUM_BRANCHES];        
    NestedDelayAPF branchNestedAPFs[NUM_BRANCHES];  
    SimpleLPF  branchLPFs[NUM_BRANCHES];            
 
    TwoBandShelvingFilter shelvingFilters[NUM_CHANNELS]; 
 
    // --- weighting values to make various and low-correlated APF delay values easily
    double apfDelayWeight[NUM_BRANCHES * 2] = { 0.317, 0.873, 0.477, 0.291, 0.993, 0.757, 0.179, 0.575 };
    double fixedDelayWeight[NUM_BRANCHES] = { 1.0, 0.873, 0.707, 0.667 };   
    double sampleRate = 0.0;    
};
 
 
class PeakLimiter : public IAudioSignalProcessor
{
public:
    PeakLimiter() { setThreshold_dB(-3.0); }
    ~PeakLimiter() {}
 
    virtual bool reset(double _sampleRate)
    {
        // --- init; true = analog time-constant
        detector.setSampleRate(_sampleRate);
 
        AudioDetectorParameters detectorParams = detector.getParameters();
        detectorParams.detect_dB = true;
        detectorParams.attackTime_mSec = 5.0;
        detectorParams.releaseTime_mSec = 25.0;
        detectorParams.clampToUnityMax = false;
        detectorParams.detectMode = ENVELOPE_DETECT_MODE_PEAK;
        detector.setParameters(detectorParams);
 
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        return dB2Raw(makeUpGain_dB)*xn*computeGain(detector.processAudioSample(xn));
    }
 
    double computeGain(double detect_dB)
    {
        double output_dB = 0.0;
 
        // --- defaults - you can change these here
        bool softknee = true;
        double kneeWidth_dB = 10.0;
 
        // --- hard knee
        if (!softknee)
        {
            // --- below threshold, unity
            if (detect_dB <= threshold_dB)
                output_dB = detect_dB;
            // --- above threshold, compress
            else
                output_dB = threshold_dB;
        }
        else
        {
            // --- calc gain with knee
            // --- left side of knee, outside of width, unity gain zone
            if (2.0*(detect_dB - threshold_dB) < -kneeWidth_dB)
                output_dB = detect_dB;
            // --- inside the knee,
            else if (2.0*(fabs(detect_dB - threshold_dB)) <= kneeWidth_dB)
                output_dB = detect_dB - pow((detect_dB - threshold_dB + (kneeWidth_dB / 2.0)), 2.0) / (2.0*kneeWidth_dB);
            // --- right of knee, compression zone
            else if (2.0*(detect_dB - threshold_dB) > kneeWidth_dB)
                output_dB = threshold_dB;
        }
 
        // --- convert difference between threshold and detected to raw
        return  pow(10.0, (output_dB - detect_dB) / 20.0);
    }
 
    void setThreshold_dB(double _threshold_dB) { threshold_dB = _threshold_dB; }
 
    void setMakeUpGain_dB(double _makeUpGain_dB) { makeUpGain_dB = _makeUpGain_dB; }
 
protected:
    AudioDetector detector;     
    double threshold_dB = 0.0;  
    double makeUpGain_dB = 0.0; 
};
 
 
enum class vaFilterAlgorithm {
    kLPF1, kHPF1, kAPF1, kSVF_LP, kSVF_HP, kSVF_BP, kSVF_BS
}; // --- you will add more here...
 
 
struct ZVAFilterParameters
{
    ZVAFilterParameters() {}
    ZVAFilterParameters& operator=(const ZVAFilterParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        filterAlgorithm = params.filterAlgorithm;
        fc = params.fc;
        Q = params.Q;
        filterOutputGain_dB = params.filterOutputGain_dB;
        enableGainComp = params.enableGainComp;
        matchAnalogNyquistLPF = params.matchAnalogNyquistLPF;
        selfOscillate = params.selfOscillate;
        enableNLP = params.enableNLP;
        return *this;
    }
 
    // --- individual parameters
    vaFilterAlgorithm filterAlgorithm = vaFilterAlgorithm::kSVF_LP; 
    double fc = 1000.0;                     
    double Q = 0.707;                       
    double filterOutputGain_dB = 0.0;       
    bool enableGainComp = false;            
    bool matchAnalogNyquistLPF = false;     
    bool selfOscillate = false;             
    bool enableNLP = false;                 
};
 
 
class ZVAFilter : public IAudioSignalProcessor
{
public:
    ZVAFilter() {}      /* C-TOR */
    ~ZVAFilter() {}     /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        integrator_z[0] = 0.0;
        integrator_z[1] = 0.0;
 
        return true;
    }
 
    ZVAFilterParameters getParameters()
    {
        return zvaFilterParameters;
    }
 
    void setParameters(const ZVAFilterParameters& params)
    {
        if (params.fc != zvaFilterParameters.fc ||
            params.Q != zvaFilterParameters.Q ||
            params.selfOscillate != zvaFilterParameters.selfOscillate ||
            params.matchAnalogNyquistLPF != zvaFilterParameters.matchAnalogNyquistLPF)
        {
                zvaFilterParameters = params;
                calculateFilterCoeffs();
        }
        else
            zvaFilterParameters = params;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- with gain comp enabled, we reduce the input by
        //     half the gain in dB at resonant peak
        //     NOTE: you can change that logic here!
        vaFilterAlgorithm filterAlgorithm = zvaFilterParameters.filterAlgorithm;
        bool matchAnalogNyquistLPF = zvaFilterParameters.matchAnalogNyquistLPF;
 
        if (zvaFilterParameters.enableGainComp)
        {
            double peak_dB = dBPeakGainFor_Q(zvaFilterParameters.Q);
            if (peak_dB > 0.0)
            {
                double halfPeak_dBGain = dB2Raw(-peak_dB / 2.0);
                xn *= halfPeak_dBGain;
            }
        }
 
        // --- for 1st order filters:
        if (filterAlgorithm == vaFilterAlgorithm::kLPF1 ||
            filterAlgorithm == vaFilterAlgorithm::kHPF1 ||
            filterAlgorithm == vaFilterAlgorithm::kAPF1)
        {
            // --- create vn node
            double vn = (xn - integrator_z[0])*alpha;
 
            // --- form LP output
            double lpf = ((xn - integrator_z[0])*alpha) + integrator_z[0];
 
            // double sn = integrator_z[0];
 
            // --- update memory
            integrator_z[0] = vn + lpf;
 
            // --- form the HPF = INPUT = LPF
            double hpf = xn - lpf;
 
            // --- form the APF = LPF - HPF
            double apf = lpf - hpf;
 
            // --- set the outputs
            if (filterAlgorithm == vaFilterAlgorithm::kLPF1)
            {
                // --- this is a very close match as-is at Nyquist!
                if (matchAnalogNyquistLPF)
                    return lpf + alpha*hpf;
                else
                    return lpf;
            }
            else if (filterAlgorithm == vaFilterAlgorithm::kHPF1)
                return hpf;
            else if (filterAlgorithm == vaFilterAlgorithm::kAPF1)
                return apf;
 
            // --- unknown filter
            return xn;
        }
 
        // --- form the HP output first
        double hpf = alpha0*(xn - rho*integrator_z[0] - integrator_z[1]);
 
        // --- BPF Out
        double bpf = alpha*hpf + integrator_z[0];
        if (zvaFilterParameters.enableNLP)
            bpf = softClipWaveShaper(bpf, 1.0);
 
        // --- LPF Out
        double lpf = alpha*bpf + integrator_z[1];
 
        // --- BSF Out
        double bsf = hpf + lpf;
 
        // --- finite gain at Nyquist; slight error at VHF
        double sn = integrator_z[0];
 
        // update memory
        integrator_z[0] = alpha*hpf + bpf;
        integrator_z[1] = alpha*bpf + lpf;
 
        double filterOutputGain = pow(10.0, zvaFilterParameters.filterOutputGain_dB / 20.0);
 
        // return our selected type
        if (filterAlgorithm == vaFilterAlgorithm::kSVF_LP)
        {
            if (matchAnalogNyquistLPF)
                lpf += analogMatchSigma*(sn);
            return filterOutputGain*lpf;
        }
        else if (filterAlgorithm == vaFilterAlgorithm::kSVF_HP)
            return filterOutputGain*hpf;
        else if (filterAlgorithm == vaFilterAlgorithm::kSVF_BP)
            return filterOutputGain*bpf;
        else if (filterAlgorithm == vaFilterAlgorithm::kSVF_BS)
            return filterOutputGain*bsf;
 
        // --- unknown filter
        return filterOutputGain*lpf;
    }
 
    void calculateFilterCoeffs()
    {
        double fc = zvaFilterParameters.fc;
        double Q = zvaFilterParameters.Q;
        vaFilterAlgorithm filterAlgorithm = zvaFilterParameters.filterAlgorithm;
 
        // --- normal Zavalishin SVF calculations here
        //     prewarp the cutoff- these are bilinear-transform filters
        double wd = kTwoPi*fc;
        double T = 1.0 / sampleRate;
        double wa = (2.0 / T)*tan(wd*T / 2.0);
        double g = wa*T / 2.0;
 
        // --- for 1st order filters:
        if (filterAlgorithm == vaFilterAlgorithm::kLPF1 ||
            filterAlgorithm == vaFilterAlgorithm::kHPF1 ||
            filterAlgorithm == vaFilterAlgorithm::kAPF1)
        {
            // --- calculate alpha
            alpha = g / (1.0 + g);
        }
        else // state variable variety
        {
            // --- note R is the traditional analog damping factor zeta
            double R = zvaFilterParameters.selfOscillate ? 0.0 : 1.0 / (2.0*Q);
            alpha0 = 1.0 / (1.0 + 2.0*R*g + g*g);
            alpha = g;
            rho = 2.0*R + g;
 
            // --- sigma for analog matching version
            double f_o = (sampleRate / 2.0) / fc;
            analogMatchSigma = 1.0 / (alpha*f_o*f_o);
        }
    }
 
    void setBeta(double _beta) { beta = _beta; }
 
    double getBeta() { return beta; }
 
protected:
    ZVAFilterParameters zvaFilterParameters;    
    double sampleRate = 44100.0;                
 
    // --- state storage
    double integrator_z[2];                     
 
    // --- filter coefficients
    double alpha0 = 0.0;        
    double alpha = 0.0;         
    double rho = 0.0;           
 
    double beta = 0.0;          
 
    // --- for analog Nyquist matching
    double analogMatchSigma = 0.0; 
 
};
 
struct EnvelopeFollowerParameters
{
    EnvelopeFollowerParameters() {}
    EnvelopeFollowerParameters& operator=(const EnvelopeFollowerParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        fc = params.fc;
        Q = params.Q;
        attackTime_mSec = params.attackTime_mSec;
        releaseTime_mSec = params.releaseTime_mSec;
        threshold_dB = params.threshold_dB;
        sensitivity = params.sensitivity;
 
        return *this;
    }
 
    // --- individual parameters
    double fc = 0.0;                
    double Q = 0.707;               
    double attackTime_mSec = 10.0;  
    double releaseTime_mSec = 10.0; 
    double threshold_dB = 0.0;      
    double sensitivity = 1.0;       
};
 
class EnvelopeFollower : public IAudioSignalProcessor
{
public:
    EnvelopeFollower() {
        // --- setup the filter
        ZVAFilterParameters filterParams;
        filterParams.filterAlgorithm = vaFilterAlgorithm::kSVF_LP;
        filterParams.fc = 1000.0;
        filterParams.enableGainComp = true;
        filterParams.enableNLP = true;
        filterParams.matchAnalogNyquistLPF = true;
        filter.setParameters(filterParams);
 
        // --- setup the detector
        AudioDetectorParameters adParams;
        adParams.attackTime_mSec = -1.0;
        adParams.releaseTime_mSec = -1.0;
        adParams.detectMode = TLD_AUDIO_DETECT_MODE_RMS;
        adParams.detect_dB = true;
        adParams.clampToUnityMax = false;
        detector.setParameters(adParams);
 
    }       /* C-TOR */
    ~EnvelopeFollower() {}      /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        filter.reset(_sampleRate);
        detector.reset(_sampleRate);
        return true;
    }
 
    EnvelopeFollowerParameters getParameters() { return parameters; }
 
    void setParameters(const EnvelopeFollowerParameters& params)
    {
        ZVAFilterParameters filterParams = filter.getParameters();
        AudioDetectorParameters adParams = detector.getParameters();
 
        if (params.fc != parameters.fc || params.Q != parameters.Q)
        {
            filterParams.fc = params.fc;
            filterParams.Q = params.Q;
            filter.setParameters(filterParams);
        }
        if (params.attackTime_mSec != parameters.attackTime_mSec ||
            params.releaseTime_mSec != parameters.releaseTime_mSec)
        {
            adParams.attackTime_mSec = params.attackTime_mSec;
            adParams.releaseTime_mSec = params.releaseTime_mSec;
            detector.setParameters(adParams);
        }
 
        // --- save
        parameters = params;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- calc threshold
        double threshValue = pow(10.0, parameters.threshold_dB / 20.0);
 
        // --- detect the signal
        double detect_dB = detector.processAudioSample(xn);
        double detectValue = pow(10.0, detect_dB / 20.0);
        double deltaValue = detectValue - threshValue;
 
        ZVAFilterParameters filterParams = filter.getParameters();
        filterParams.fc = parameters.fc;
 
        // --- if above the threshold, modulate the filter fc
        if (deltaValue > 0.0)// || delta_dB > 0.0)
        {
            // --- fc Computer
            double modulatorValue = 0.0;
 
            // --- best results are with linear values when detector is in dB mode
            modulatorValue = (deltaValue * parameters.sensitivity);
 
            // --- calculate modulated frequency
            filterParams.fc = doUnipolarModulationFromMin(modulatorValue, parameters.fc, kMaxFilterFrequency);
        }
 
        // --- update with new modulated frequency
        filter.setParameters(filterParams);
 
        // --- perform the filtering operation
        return filter.processAudioSample(xn);
    }
 
protected:
    EnvelopeFollowerParameters parameters; 
 
    // --- 1 filter and 1 detector
    ZVAFilter filter;       
    AudioDetector detector; 
};
 
enum class distortionModel { kSoftClip, kArcTan, kFuzzAsym };
 
struct TriodeClassAParameters
{
    TriodeClassAParameters() {}
    TriodeClassAParameters& operator=(const TriodeClassAParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        waveshaper = params.waveshaper;
        saturation = params.saturation;
        asymmetry = params.asymmetry;
        outputGain = params.outputGain;
 
        invertOutput = params.invertOutput;
        enableHPF = params.enableHPF;
        enableLSF = params.enableLSF;
 
        hpf_Fc = params.hpf_Fc;
        lsf_Fshelf = params.lsf_Fshelf;
        lsf_BoostCut_dB = params.lsf_BoostCut_dB;
 
        return *this;
    }
 
    // --- individual parameters
    distortionModel waveshaper = distortionModel::kSoftClip; 
 
    double saturation = 1.0;    
    double asymmetry = 0.0;     
    double outputGain = 1.0;    
 
    bool invertOutput = true;   
    bool enableHPF = true;      
    bool enableLSF = false;     
 
    double hpf_Fc = 1.0;        
    double lsf_Fshelf = 80.0;   
    double lsf_BoostCut_dB = 0.0;
};
 
class TriodeClassA : public IAudioSignalProcessor
{
public:
    TriodeClassA() {
        AudioFilterParameters params;
        params.algorithm = filterAlgorithm::kHPF1;
        params.fc = parameters.hpf_Fc;
        outputHPF.setParameters(params);
 
        params.algorithm = filterAlgorithm::kLowShelf;
        params.fc = parameters.lsf_Fshelf;
        params.boostCut_dB = parameters.lsf_BoostCut_dB;
        outputLSF.setParameters(params);
    }       /* C-TOR */
    ~TriodeClassA() {}      /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        outputHPF.reset(_sampleRate);
        outputLSF.reset(_sampleRate);
 
        // ---
        return true;
    }
 
    TriodeClassAParameters getParameters() { return parameters; }
 
    void setParameters(const TriodeClassAParameters& params)
    {
        parameters = params;
 
        AudioFilterParameters filterParams;
        filterParams.algorithm = filterAlgorithm::kHPF1;
        filterParams.fc = parameters.hpf_Fc;
        outputHPF.setParameters(filterParams);
 
        filterParams.algorithm = filterAlgorithm::kLowShelf;
        filterParams.fc = parameters.lsf_Fshelf;
        filterParams.boostCut_dB = parameters.lsf_BoostCut_dB;
        outputLSF.setParameters(filterParams);
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- perform waveshaping
        double output = 0.0;
 
        if (parameters.waveshaper == distortionModel::kSoftClip)
            output = softClipWaveShaper(xn, parameters.saturation);
        else if (parameters.waveshaper == distortionModel::kArcTan)
            output = atanWaveShaper(xn, parameters.saturation);
        else if (parameters.waveshaper == distortionModel::kFuzzAsym)
            output = fuzzExp1WaveShaper(xn, parameters.saturation, parameters.asymmetry);
 
        // --- inversion, normal for plate of class A triode
        if (parameters.invertOutput)
            output *= -1.0;
 
        // --- Output (plate) capacitor = HPF, remove DC offset
        if (parameters.enableHPF)
            output = outputHPF.processAudioSample(output);
 
        // --- if cathode resistor bypass, will create low shelf
        if (parameters.enableLSF)
            output = outputLSF.processAudioSample(output);
 
        // --- final resistor divider/potentiometer
        output *= parameters.outputGain;
 
        return output;
    }
 
protected:
    TriodeClassAParameters parameters;  
    AudioFilter outputHPF;              
    AudioFilter outputLSF;              
};
 
const unsigned int NUM_TUBES = 4;
 
struct ClassATubePreParameters
{
    ClassATubePreParameters() {}
    ClassATubePreParameters& operator=(const ClassATubePreParameters& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        inputLevel_dB = params.inputLevel_dB;
        saturation = params.saturation;
        asymmetry = params.asymmetry;
        outputLevel_dB = params.outputLevel_dB;
 
        lowShelf_fc = params.lowShelf_fc;
        lowShelfBoostCut_dB = params.lowShelfBoostCut_dB;
        highShelf_fc = params.highShelf_fc;
        highShelfBoostCut_dB = params.highShelfBoostCut_dB;
 
        return *this;
    }
 
    // --- individual parameters
    double inputLevel_dB = 0.0;     
    double saturation = 0.0;        
    double asymmetry = 0.0;         
    double outputLevel_dB = 0.0;    
 
    // --- shelving filter params
    double lowShelf_fc = 0.0;           
    double lowShelfBoostCut_dB = 0.0;   
    double highShelf_fc = 0.0;          
    double highShelfBoostCut_dB = 0.0;  
 
};
 
class ClassATubePre : public IAudioSignalProcessor
{
public:
    ClassATubePre() {}      /* C-TOR */
    ~ClassATubePre() {}     /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        TriodeClassAParameters tubeParams = triodes[0].getParameters();
        tubeParams.invertOutput = true;
        tubeParams.enableHPF = true; // remove DC offsets
        tubeParams.outputGain = 1.0;
        tubeParams.saturation = 1.0;
        tubeParams.asymmetry = 0.0;
        tubeParams.enableLSF = true;
        tubeParams.lsf_Fshelf = 88.0;
        tubeParams.lsf_BoostCut_dB = -12.0;
        tubeParams.waveshaper = distortionModel::kFuzzAsym;
 
        for (uint32_t i = 0; i < NUM_TUBES; i++)
        {
            triodes[i].reset(_sampleRate);
            triodes[i].setParameters(tubeParams);
        }
 
        shelvingFilter.reset(_sampleRate);
 
        return true;
    }
 
    ClassATubePreParameters getParameters() { return parameters; }
 
    void setParameters(const ClassATubePreParameters& params)
    {
        // --- check for re-calc
        if (params.inputLevel_dB != parameters.inputLevel_dB)
            inputLevel = pow(10.0, params.inputLevel_dB / 20.0);
        if (params.outputLevel_dB != parameters.outputLevel_dB)
            outputLevel = pow(10.0, params.outputLevel_dB / 20.0);
 
        // --- store
        parameters = params;
 
        // --- shelving filter update
        TwoBandShelvingFilterParameters sfParams = shelvingFilter.getParameters();
        sfParams.lowShelf_fc = parameters.lowShelf_fc;
        sfParams.lowShelfBoostCut_dB = parameters.lowShelfBoostCut_dB;
        sfParams.highShelf_fc = parameters.highShelf_fc;
        sfParams.highShelfBoostCut_dB = parameters.highShelfBoostCut_dB;
        shelvingFilter.setParameters(sfParams);
 
        // --- triode updates
        TriodeClassAParameters tubeParams = triodes[0].getParameters();
        tubeParams.saturation = parameters.saturation;
        tubeParams.asymmetry = parameters.asymmetry;
 
        for (uint32_t i = 0; i < NUM_TUBES; i++)
            triodes[i].setParameters(tubeParams);
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        double output1 = triodes[0].processAudioSample(xn*inputLevel);
        double output2 = triodes[1].processAudioSample(output1);
        double output3 = triodes[2].processAudioSample(output2);
 
        // --- filter stage is between 3 and 4
        double outputEQ = shelvingFilter.processAudioSample(output3);
        double output4 = triodes[3].processAudioSample(outputEQ);
 
        return output4*outputLevel;
    }
 
protected:
    ClassATubePreParameters parameters;     
    TriodeClassA triodes[NUM_TUBES];        
    TwoBandShelvingFilter shelvingFilter;   
 
    double inputLevel = 1.0;    
    double outputLevel = 1.0;   
};
 
 
struct BitCrusherParameters
{
    BitCrusherParameters() {}
    BitCrusherParameters& operator=(const BitCrusherParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        quantizedBitDepth = params.quantizedBitDepth;
 
        return *this;
    }
 
    double quantizedBitDepth = 4.0; 
};
 
class BitCrusher : public IAudioSignalProcessor
{
public:
    BitCrusher() {}     /* C-TOR */
    ~BitCrusher() {}        /* D-TOR */
 
    virtual bool reset(double _sampleRate){ return true; }
 
    BitCrusherParameters getParameters() { return parameters; }
 
    void setParameters(const BitCrusherParameters& params)
    {
        // --- calculate and store
        if (params.quantizedBitDepth != parameters.quantizedBitDepth)
            QL = 2.0 / (pow(2.0, params.quantizedBitDepth) - 1.0);
 
        parameters = params;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        return QL*(int(xn / QL));
    }
 
protected:
    BitCrusherParameters parameters; 
    double QL = 1.0;                 
};
 
 
// ------------------------------------------------------------------ //
// --- WDF LIBRARY -------------------------------------------------- //
// ------------------------------------------------------------------ //
 
class IComponentAdaptor
{
public:
    virtual void initialize(double _R1) {}
 
    virtual void initializeAdaptorChain() {}
 
    virtual void setInput(double _in) {}
 
    virtual double getOutput() { return 0.0; }
 
    // --- for adaptors
    virtual void setInput1(double _in1) = 0;
 
    virtual void setInput2(double _in2) = 0;
 
    virtual void setInput3(double _in3) = 0;
 
    virtual double getOutput1() = 0;
 
    virtual double getOutput2() = 0;
 
    virtual double getOutput3() = 0;
 
    virtual void reset(double _sampleRate) {}
 
    virtual double getComponentResistance() { return 0.0; }
 
    virtual double getComponentConductance() { return 0.0; }
 
    virtual void updateComponentResistance() {}
 
    virtual void setComponentValue(double _componentValue) { }
 
    virtual void setComponentValue_LC(double componentValue_L, double componentValue_C) { }
 
    virtual void setComponentValue_RL(double componentValue_R, double componentValue_L) { }
 
    virtual void setComponentValue_RC(double componentValue_R, double componentValue_C) { }
 
    virtual double getComponentValue() { return 0.0; }
};
 
// ------------------------------------------------------------------ //
// --- WDF COMPONENTS & COMMBO COMPONENTS --------------------------- //
// ------------------------------------------------------------------ //
class WdfResistor : public IComponentAdaptor
{
public:
    WdfResistor(double _componentValue) { componentValue = _componentValue; }
    WdfResistor() { }
    virtual ~WdfResistor() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual double getComponentValue() { return componentValue; }
 
    virtual void setComponentValue(double _componentValue)
    {
        componentValue = _componentValue;
        updateComponentResistance();
    }
 
    virtual void updateComponentResistance() { componentResistance = componentValue; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate);  zRegister = 0.0; }
 
    virtual void setInput(double in) {}
 
    virtual double getOutput() { return 0.0; }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister = 0.0;         
    double componentValue = 0.0;    
    double componentResistance = 0.0;
    double sampleRate = 0.0;        
};
 
 
class WdfCapacitor : public IComponentAdaptor
{
public:
    WdfCapacitor(double _componentValue) { componentValue = _componentValue; }
    WdfCapacitor() { }
    virtual ~WdfCapacitor() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual double getComponentValue() { return componentValue; }
 
    virtual void setComponentValue(double _componentValue)
    {
        componentValue = _componentValue;
        updateComponentResistance();
    }
 
    virtual void updateComponentResistance()
    {
        componentResistance = 1.0 / (2.0*componentValue*sampleRate);
    }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister = 0.0; }
 
    virtual void setInput(double in) { zRegister = in; }
 
    virtual double getOutput() { return zRegister; }    // z^-1
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister = 0.0;         
    double componentValue = 0.0;    
    double componentResistance = 0.0;
    double sampleRate = 0.0;        
};
 
class WdfInductor : public IComponentAdaptor
{
public:
    WdfInductor(double _componentValue) { componentValue = _componentValue; }
    WdfInductor() { }
    virtual ~WdfInductor() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual double getComponentValue() { return componentValue; }
 
    virtual void setComponentValue(double _componentValue)
    {
        componentValue = _componentValue;
        updateComponentResistance();
    }
 
    virtual void updateComponentResistance(){ componentResistance = 2.0*componentValue*sampleRate;}
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister = 0.0; }
 
    virtual void setInput(double in) { zRegister = in; }
 
    virtual double getOutput() { return -zRegister; } // -z^-1
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister = 0.0;         
    double componentValue = 0.0;    
    double componentResistance = 0.0;
    double sampleRate = 0.0;        
};
 
 
class WdfSeriesLC : public IComponentAdaptor
{
public:
    WdfSeriesLC() {}
    WdfSeriesLC(double _componentValue_L, double _componentValue_C)
    {
        componentValue_L = _componentValue_L;
        componentValue_C = _componentValue_C;
    }
    virtual ~WdfSeriesLC() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RL = 2.0*componentValue_L*sampleRate;
        RC = 1.0 / (2.0*componentValue_C*sampleRate);
        componentResistance = RL + (1.0 / RC);
    }
 
    virtual void setComponentValue_LC(double _componentValue_L, double _componentValue_C)
    {
        componentValue_L = _componentValue_L;
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_L(double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_C(double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_L() { return componentValue_L; }
 
    virtual double getComponentValue_C() { return componentValue_C; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in)
    {
        double YC = 1.0 / RC;
        double K = (1.0 - RL*YC) / (1.0 + RL*YC);
        double N1 = K*(in - zRegister_L);
        zRegister_L = N1 + zRegister_C;
        zRegister_C = in;
    }
 
    virtual double getOutput(){ return zRegister_L; }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0; 
    double zRegister_C = 0.0; 
 
    double componentValue_L = 0.0; 
    double componentValue_C = 0.0; 
 
    double RL = 0.0; 
    double RC = 0.0; 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
class WdfParallelLC : public IComponentAdaptor
{
public:
    WdfParallelLC() {}
    WdfParallelLC(double _componentValue_L, double _componentValue_C)
    {
        componentValue_L = _componentValue_L;
        componentValue_C = _componentValue_C;
    }
    virtual ~WdfParallelLC() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RL = 2.0*componentValue_L*sampleRate;
        RC = 1.0 / (2.0*componentValue_C*sampleRate);
        componentResistance = (RC + 1.0 / RL);
    }
 
    virtual void setComponentValue_LC(double _componentValue_L, double _componentValue_C)
    {
        componentValue_L = _componentValue_L;
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_L(double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_C(double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_L() { return componentValue_L; }
 
    virtual double getComponentValue_C() { return componentValue_C; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in)
    {
        double YL = 1.0 / RL;
        double K = (YL*RC - 1.0) / (YL*RC + 1.0);
        double N1 = K*(in - zRegister_L);
        zRegister_L = N1 + zRegister_C;
        zRegister_C = in;
    }
 
    virtual double getOutput(){ return -zRegister_L; }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0; 
    double zRegister_C = 0.0; 
 
    double componentValue_L = 0.0; 
    double componentValue_C = 0.0; 
 
    double RL = 0.0; 
    double RC = 0.0; 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
 
class WdfSeriesRL : public IComponentAdaptor
{
public:
    WdfSeriesRL() {}
    WdfSeriesRL(double _componentValue_R, double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        componentValue_R = _componentValue_R;
    }
    virtual ~WdfSeriesRL() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RR = componentValue_R;
        RL = 2.0*componentValue_L*sampleRate;
        componentResistance = RR + RL;
        K = RR / componentResistance;
    }
 
    virtual void setComponentValue_RL(double _componentValue_R, double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_L(double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_R(double _componentValue_R)
    {
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_L() { return componentValue_L; }
 
    virtual double getComponentValue_R() { return componentValue_R; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in){ zRegister_L = in; }
 
    virtual double getOutput()
    {
        double NL = -zRegister_L;
        double out = NL*(1.0 - K) - K*zRegister_C;
        zRegister_C = out;
 
        return out;
    }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0; 
    double zRegister_C = 0.0;
    double K = 0.0;
 
    double componentValue_L = 0.0;
    double componentValue_R = 0.0;
 
    double RL = 0.0; 
    double RC = 0.0; 
    double RR = 0.0; 
 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
class WdfParallelRL : public IComponentAdaptor
{
public:
    WdfParallelRL() {}
    WdfParallelRL(double _componentValue_R, double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        componentValue_R = _componentValue_R;
    }
    virtual ~WdfParallelRL() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RR = componentValue_R;
        RL = 2.0*componentValue_L*sampleRate;
        componentResistance = 1.0 / ((1.0 / RR) + (1.0 / RL));
        K = componentResistance / RR;
    }
 
 
    virtual void setComponentValue_RL(double _componentValue_R, double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_L(double _componentValue_L)
    {
        componentValue_L = _componentValue_L;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_R(double _componentValue_R)
    {
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_L() { return componentValue_L; }
 
    virtual double getComponentValue_R() { return componentValue_R; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in){ zRegister_L = in; }
 
    virtual double getOutput()
    {
        double NL = -zRegister_L;
        double out = NL*(1.0 - K) + K*zRegister_C;
        zRegister_C = out;
        return out;
    }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0;   
    double zRegister_C = 0.0;   
    double K = 0.0;             
 
    double componentValue_L = 0.0;  
    double componentValue_R = 0.0;  
 
    double RL = 0.0;    
    double RC = 0.0;    
    double RR = 0.0;    
 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
class WdfSeriesRC : public IComponentAdaptor
{
public:
    WdfSeriesRC() {}
    WdfSeriesRC(double _componentValue_R, double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        componentValue_R = _componentValue_R;
    }
    virtual ~WdfSeriesRC() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RR = componentValue_R;
        RC = 1.0 / (2.0*componentValue_C*sampleRate);
        componentResistance = RR + RC;
        K = RR / componentResistance;
    }
 
    virtual void setComponentValue_RC(double _componentValue_R, double _componentValue_C)
    {
        componentValue_R = _componentValue_R;
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_R(double _componentValue_R)
    {
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_C(double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_R() { return componentValue_R; }
 
    virtual double getComponentValue_C() { return componentValue_C; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in){ zRegister_L = in; }
 
    virtual double getOutput()
    {
        double NL = zRegister_L;
        double out = NL*(1.0 - K) + K*zRegister_C;
        zRegister_C = out;
        return out;
    }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0; 
    double zRegister_C = 0.0; 
    double K = 0.0;
 
    double componentValue_R = 0.0;
    double componentValue_C = 0.0;
 
    double RL = 0.0;    
    double RC = 0.0;    
    double RR = 0.0;    
 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
class WdfParallelRC : public IComponentAdaptor
{
public:
    WdfParallelRC() {}
    WdfParallelRC(double _componentValue_R, double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        componentValue_R = _componentValue_R;
    }
    virtual ~WdfParallelRC() {}
 
    void setSampleRate(double _sampleRate)
    {
        sampleRate = _sampleRate;
        updateComponentResistance();
    }
 
    virtual double getComponentResistance() { return componentResistance; }
 
    virtual double getComponentConductance() { return 1.0 / componentResistance; }
 
    virtual void updateComponentResistance()
    {
        RR = componentValue_R;
        RC = 1.0 / (2.0*componentValue_C*sampleRate);
        componentResistance = 1.0 / ((1.0 / RR) + (1.0 / RC));
        K = componentResistance / RR;
    }
 
    virtual void setComponentValue_RC(double _componentValue_R, double _componentValue_C)
    {
        componentValue_R = _componentValue_R;
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_R(double _componentValue_R)
    {
        componentValue_R = _componentValue_R;
        updateComponentResistance();
    }
 
    virtual void setComponentValue_C(double _componentValue_C)
    {
        componentValue_C = _componentValue_C;
        updateComponentResistance();
    }
 
    virtual double getComponentValue_R() { return componentValue_R; }
 
    virtual double getComponentValue_C() { return componentValue_C; }
 
    virtual void reset(double _sampleRate) { setSampleRate(_sampleRate); zRegister_L = 0.0; zRegister_C = 0.0; }
 
    virtual void setInput(double in){ zRegister_L = in; }
 
    virtual double getOutput()
    {
        double NL = zRegister_L;
        double out = NL*(1.0 - K) - K*zRegister_C;
        zRegister_C = out;
        return out;
    }
 
    virtual double getOutput1() { return  getOutput(); }
 
    virtual double getOutput2() { return  getOutput(); }
 
    virtual double getOutput3() { return  getOutput(); }
 
    virtual void setInput1(double _in1) {}
 
    virtual void setInput2(double _in2) {}
 
    virtual void setInput3(double _in3) {}
 
protected:
    double zRegister_L = 0.0; 
    double zRegister_C = 0.0; 
    double K = 0.0;
 
    double componentValue_C = 0.0;  
    double componentValue_R = 0.0;  
 
    double RL = 0.0; 
    double RC = 0.0; 
    double RR = 0.0; 
 
    double componentResistance = 0.0; 
    double sampleRate = 0.0; 
};
 
 
// ------------------------------------------------------------------ //
// --- WDF ADAPTORS ------------------------------------------------- //
// ------------------------------------------------------------------ //
 
enum class wdfComponent { R, L, C, seriesLC, parallelLC, seriesRL, parallelRL, seriesRC, parallelRC };
 
struct WdfComponentInfo
{
    WdfComponentInfo() { }
 
    WdfComponentInfo(wdfComponent _componentType, double value1 = 0.0, double value2 = 0.0)
    {
        componentType = _componentType;
        if (componentType == wdfComponent::R)
            R = value1;
        else if (componentType == wdfComponent::L)
            L = value1;
        else if (componentType == wdfComponent::C)
            C = value1;
        else if (componentType == wdfComponent::seriesLC || componentType == wdfComponent::parallelLC)
        {
            L = value1;
            C = value2;
        }
        else if (componentType == wdfComponent::seriesRL || componentType == wdfComponent::parallelRL)
        {
            R = value1;
            L = value2;
        }
        else if (componentType == wdfComponent::seriesRC || componentType == wdfComponent::parallelRC)
        {
            R = value1;
            C = value2;
        }
    }
 
    double R = 0.0; 
    double L = 0.0; 
    double C = 0.0; 
    wdfComponent componentType = wdfComponent::R; 
};
 
 
class WdfAdaptorBase : public IComponentAdaptor
{
public:
    WdfAdaptorBase() {}
    virtual ~WdfAdaptorBase() {}
 
    void setTerminalResistance(double _terminalResistance) { terminalResistance = _terminalResistance; }
 
    void setOpenTerminalResistance(bool _openTerminalResistance = true)
    {
        // --- flag overrides value
        openTerminalResistance = _openTerminalResistance;
        terminalResistance = 1.0e+34; // avoid /0.0
    }
 
    void setSourceResistance(double _sourceResistance) { sourceResistance = _sourceResistance; }
 
    void setPort1_CompAdaptor(IComponentAdaptor* _port1CompAdaptor) { port1CompAdaptor = _port1CompAdaptor; }
 
    void setPort2_CompAdaptor(IComponentAdaptor* _port2CompAdaptor) { port2CompAdaptor = _port2CompAdaptor; }
 
    void setPort3_CompAdaptor(IComponentAdaptor* _port3CompAdaptor) { port3CompAdaptor = _port3CompAdaptor; }
 
    virtual void reset(double _sampleRate)
    {
        if (wdfComponent)
            wdfComponent->reset(_sampleRate);
    }
 
    void setComponent(wdfComponent componentType, double value1 = 0.0, double value2 = 0.0)
    {
        // --- decode and set
        if (componentType == wdfComponent::R)
        {
            wdfComponent = new WdfResistor;
            wdfComponent->setComponentValue(value1);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::L)
        {
            wdfComponent = new WdfInductor;
            wdfComponent->setComponentValue(value1);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::C)
        {
            wdfComponent = new WdfCapacitor;
            wdfComponent->setComponentValue(value1);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::seriesLC)
        {
            wdfComponent = new WdfSeriesLC;
            wdfComponent->setComponentValue_LC(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::parallelLC)
        {
            wdfComponent = new WdfParallelLC;
            wdfComponent->setComponentValue_LC(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::seriesRL)
        {
            wdfComponent = new WdfSeriesRL;
            wdfComponent->setComponentValue_RL(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::parallelRL)
        {
            wdfComponent = new WdfParallelRL;
            wdfComponent->setComponentValue_RL(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::seriesRC)
        {
            wdfComponent = new WdfSeriesRC;
            wdfComponent->setComponentValue_RC(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
        else if (componentType == wdfComponent::parallelRC)
        {
            wdfComponent = new WdfParallelRC;
            wdfComponent->setComponentValue_RC(value1, value2);
            port3CompAdaptor = wdfComponent;
        }
    }
 
    static void connectAdaptors(WdfAdaptorBase* upstreamAdaptor, WdfAdaptorBase* downstreamAdaptor)
    {
        upstreamAdaptor->setPort2_CompAdaptor(downstreamAdaptor);
        downstreamAdaptor->setPort1_CompAdaptor(upstreamAdaptor);
    }
 
    virtual void initializeAdaptorChain()
    {
        initialize(sourceResistance);
    }
 
    virtual void setComponentValue(double _componentValue)
    {
        if (wdfComponent)
            wdfComponent->setComponentValue(_componentValue);
    }
 
    virtual void setComponentValue_LC(double componentValue_L, double componentValue_C)
    {
        if (wdfComponent)
            wdfComponent->setComponentValue_LC(componentValue_L, componentValue_C);
    }
 
    virtual void setComponentValue_RL(double componentValue_R, double componentValue_L)
    {
        if (wdfComponent)
            wdfComponent->setComponentValue_RL(componentValue_R, componentValue_L);
    }
 
    virtual void setComponentValue_RC(double componentValue_R, double componentValue_C)
    {
        if (wdfComponent)
            wdfComponent->setComponentValue_RC(componentValue_R, componentValue_C);
    }
 
    IComponentAdaptor* getPort1_CompAdaptor() { return port1CompAdaptor; }
 
    IComponentAdaptor* getPort2_CompAdaptor() { return port2CompAdaptor; }
 
    IComponentAdaptor* getPort3_CompAdaptor() { return port3CompAdaptor; }
 
protected:
    // --- can in theory connect any port to a component OR adaptor;
    //     though this library is setup with a convention R3 = component
    IComponentAdaptor* port1CompAdaptor = nullptr;  
    IComponentAdaptor* port2CompAdaptor = nullptr;  
    IComponentAdaptor* port3CompAdaptor = nullptr;  
    IComponentAdaptor* wdfComponent = nullptr;      
 
    // --- These hold the input (R1), component (R3) and output (R2) resistances
    double R1 = 0.0; 
    double R2 = 0.0; 
    double R3 = 0.0; 
 
    // --- these are input variables that are stored;
    //     not used in this implementation but may be required for extended versions
    double in1 = 0.0;   
    double in2 = 0.0;   
    double in3 = 0.0;   
 
    // --- these are output variables that are stored;
    //     currently out2 is the only one used as it is y(n) for this library
    //     out1 and out2 are stored; not used in this implementation but may be required for extended versions
    double out1 = 0.0;  
    double out2 = 0.0;  
    double out3 = 0.0;  
 
    // --- terminal impedance
    double terminalResistance = 600.0; 
    bool openTerminalResistance = false; 
 
    // --- source impedance, OK for this to be set to 0.0 for Rs = 0
    double sourceResistance = 600.0; 
};
 
class WdfSeriesAdaptor : public WdfAdaptorBase
{
public:
    WdfSeriesAdaptor() {}
    virtual ~WdfSeriesAdaptor() {}
 
    virtual double getR2()
    {
        double componentResistance = 0.0;
        if (getPort3_CompAdaptor())
            componentResistance = getPort3_CompAdaptor()->getComponentResistance();
 
        R2 = R1 + componentResistance;
        return R2;
    }
 
    virtual void initialize(double _R1)
    {
        // --- R1 is source resistance for this adaptor
        R1 = _R1;
 
        double componentResistance = 0.0;
        if (getPort3_CompAdaptor())
            componentResistance = getPort3_CompAdaptor()->getComponentResistance();
 
        // --- calculate B coeff
        B = R1 / (R1 + componentResistance);
 
        // --- init downstream adaptor
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->initialize(getR2());
 
        // --- not used in this implementation but saving for extended use
        R3 = componentResistance;
    }
 
    virtual void setInput1(double _in1)
    {
        // --- save
        in1 = _in1;
 
        // --- read component value
        N2 = 0.0;
        if (getPort3_CompAdaptor())
            N2 = getPort3_CompAdaptor()->getOutput();
 
        // --- form output
        out2 = -(in1 + N2);
 
        // --- deliver downstream
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->setInput1(out2);
    }
 
    virtual void setInput2(double _in2)
    {
        // --- save
        in2 = _in2;
 
        // --- calc N1
        N1 = -(in1 - B*(in1 + N2 + in2) + in2);
 
        // --- calc out1
        out1 = in1 - B*(N2 + in2);
 
        // --- deliver upstream
        if (getPort1_CompAdaptor())
            getPort1_CompAdaptor()->setInput2(out1);
 
        // --- set component state
        if (getPort3_CompAdaptor())
            getPort3_CompAdaptor()->setInput(N1);
    }
 
    virtual void setInput3(double _in3){ }
 
    virtual double getOutput1() { return out1; }
 
    virtual double getOutput2() { return out2; }
 
    virtual double getOutput3() { return out3; }
 
private:
    double N1 = 0.0;    
    double N2 = 0.0;    
    double B = 0.0;     
};
 
// --- Series terminated adaptor
class WdfSeriesTerminatedAdaptor : public WdfAdaptorBase
{
public:
    WdfSeriesTerminatedAdaptor() {}
    virtual ~WdfSeriesTerminatedAdaptor() {}
 
    virtual double getR2()
    {
        double componentResistance = 0.0;
        if (getPort3_CompAdaptor())
            componentResistance = getPort3_CompAdaptor()->getComponentResistance();
 
        R2 = R1 + componentResistance;
        return R2;
    }
 
    virtual void initialize(double _R1)
    {
        // --- source impedance
        R1 = _R1;
 
        double componentResistance = 0.0;
        if (getPort3_CompAdaptor())
            componentResistance = getPort3_CompAdaptor()->getComponentResistance();
 
        B1 = (2.0*R1) / (R1 + componentResistance + terminalResistance);
        B3 = (2.0*terminalResistance) / (R1 + componentResistance + terminalResistance);
 
        // --- init downstream
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->initialize(getR2());
 
        // --- not used in this implementation but saving for extended use
        R3 = componentResistance;
    }
 
    virtual void setInput1(double _in1)
    {
        // --- save
        in1 = _in1;
 
        N2 = 0.0;
        if (getPort3_CompAdaptor())
            N2 = getPort3_CompAdaptor()->getOutput();
 
        double N3 = in1 + N2;
 
        // --- calc out2 y(n)
        out2 = -B3*N3;
 
        // --- form output1
        out1 = in1 - B1*N3;
 
        // --- form N1
        N1 = -(out1 + out2 + N3);
 
        // --- deliver upstream to input2
        if (getPort1_CompAdaptor())
            getPort1_CompAdaptor()->setInput2(out1);
 
        // --- set component state
        if (getPort3_CompAdaptor())
            getPort3_CompAdaptor()->setInput(N1);
    }
 
    virtual void setInput2(double _in2) { in2 = _in2;}
 
    virtual void setInput3(double _in3) { in3 = _in3;}
 
    virtual double getOutput1() { return out1; }
 
    virtual double getOutput2() { return out2; }
 
    virtual double getOutput3() { return out3; }
 
private:
    double N1 = 0.0;    
    double N2 = 0.0;    
    double B1 = 0.0;    
    double B3 = 0.0;    
};
 
class WdfParallelAdaptor : public WdfAdaptorBase
{
public:
    WdfParallelAdaptor() {}
    virtual ~WdfParallelAdaptor() {}
 
    virtual double getR2()
    {
        double componentConductance = 0.0;
        if (getPort3_CompAdaptor())
            componentConductance = getPort3_CompAdaptor()->getComponentConductance();
 
        // --- 1 / (sum of admittances)
        R2 = 1.0 / ((1.0 / R1) + componentConductance);
        return R2;
    }
 
    virtual void initialize(double _R1)
    {
        // --- save R1
        R1 = _R1;
 
        double G1 = 1.0 / R1;
        double componentConductance = 0.0;
        if (getPort3_CompAdaptor())
            componentConductance = getPort3_CompAdaptor()->getComponentConductance();
 
        // --- calculate B coeff
        A = G1 / (G1 + componentConductance);
 
        // --- now, do we init our downstream??
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->initialize(getR2());
 
        // --- not used in this implementation but saving for extended use
        R3 = 1.0/ componentConductance;
    }
 
    virtual void setInput1(double _in1)
    {
        // --- save
        in1 = _in1;
 
        // --- read component
        N2 = 0.0;
        if (getPort3_CompAdaptor())
            N2 = getPort3_CompAdaptor()->getOutput();
 
        // --- form output
        out2 = N2 - A*(-in1 + N2);
 
        // --- deliver downstream
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->setInput1(out2);
    }
 
    virtual void setInput2(double _in2)
    {
        // --- save
        in2 = _in2;
 
        // --- calc N1
        N1 = in2 - A*(-in1 + N2);
 
        // --- calc out1
        out1 = -in1 + N2 + N1;
 
        // --- deliver upstream
        if (getPort1_CompAdaptor())
            getPort1_CompAdaptor()->setInput2(out1);
 
        // --- set component state
        if (getPort3_CompAdaptor())
            getPort3_CompAdaptor()->setInput(N1);
    }
 
    virtual void setInput3(double _in3) { }
 
    virtual double getOutput1() { return out1; }
 
    virtual double getOutput2() { return out2; }
 
    virtual double getOutput3() { return out3; }
 
private:
    double N1 = 0.0;    
    double N2 = 0.0;    
    double A = 0.0;     
};
 
 
class WdfParallelTerminatedAdaptor : public WdfAdaptorBase
{
public:
    WdfParallelTerminatedAdaptor() {}
    virtual ~WdfParallelTerminatedAdaptor() {}
 
    virtual double getR2()
    {
        double componentConductance = 0.0;
        if (getPort3_CompAdaptor())
            componentConductance = getPort3_CompAdaptor()->getComponentConductance();
 
        // --- 1 / (sum of admittances)
        R2 = 1.0 / ((1.0 / R1) + componentConductance);
        return R2;
    }
 
    virtual void initialize(double _R1)
    {
        // --- save R1
        R1 = _R1;
 
        double G1 = 1.0 / R1;
        if (terminalResistance <= 0.0)
            terminalResistance = 1e-15;
 
        double G2 = 1.0 / terminalResistance;
        double componentConductance = 0.0;
        if (getPort3_CompAdaptor())
            componentConductance = getPort3_CompAdaptor()->getComponentConductance();
 
        A1 = 2.0*G1 / (G1 + componentConductance + G2);
        A3 = openTerminalResistance ? 0.0 : 2.0*G2 / (G1 + componentConductance + G2);
 
        // --- init downstream
        if (getPort2_CompAdaptor())
            getPort2_CompAdaptor()->initialize(getR2());
 
        // --- not used in this implementation but saving for extended use
        R3 = 1.0 / componentConductance;
    }
 
    virtual void setInput1(double _in1)
    {
        // --- save
        in1 = _in1;
 
        N2 = 0.0;
        if (getPort3_CompAdaptor())
            N2 = getPort3_CompAdaptor()->getOutput();
 
        // --- form N1
        N1 = -A1*(-in1 + N2) + N2 - A3*N2;
 
        // --- form output1
        out1 = -in1 + N2 + N1;
 
        // --- deliver upstream to input2
        if (getPort1_CompAdaptor())
            getPort1_CompAdaptor()->setInput2(out1);
 
        // --- calc out2 y(n)
        out2 = N2 + N1;
 
        // --- set component state
        if (getPort3_CompAdaptor())
            getPort3_CompAdaptor()->setInput(N1);
    }
 
    virtual void setInput2(double _in2){ in2 = _in2;}
 
    virtual void setInput3(double _in3) { }
 
    virtual double getOutput1() { return out1; }
 
    virtual double getOutput2() { return out2; }
 
    virtual double getOutput3() { return out3; }
 
private:
    double N1 = 0.0;    
    double N2 = 0.0;    
    double A1 = 0.0;    
    double A3 = 0.0;    
};
 
// ------------------------------------------------------------------------------ //
// --- WDF Ladder Filter Design  Examples --------------------------------------- //
// ------------------------------------------------------------------------------ //
//
// --- 3rd order Butterworth LPF designed with Elsie www.TonneSoftware.comm
//
/*
    3rd Order Inductor-Leading LPF
 
    Rs = Rload = 600 ohms
 
    Series(L1) -> Parallel(C1) -> Series(L2)
 
    --L1-- | --L2--
           C1
           |
 
    fc = 1kHz
        L1 = 95.49e-3;
        C1 = 0.5305e-6;
        L2 = 95.49e-3;
 
    fc = 10kHz
        L1 = 9.549e-3;
        C1 = 0.05305e-6;
        L2 = 9.549e-3;
*/
 
class WDFButterLPF3 : public IAudioSignalProcessor
{
public:
    WDFButterLPF3(void) { createWDF(); }    /* C-TOR */
    ~WDFButterLPF3(void) {} /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        // --- rest WDF components (flush state registers)
        seriesAdaptor_L1.reset(_sampleRate);
        parallelAdaptor_C1.reset(_sampleRate);
        seriesTerminatedAdaptor_L2.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_L1.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_L1.setInput1(xn);
 
        // --- output is at terminated L2's output2
        return seriesTerminatedAdaptor_L2.getOutput2();
    }
 
    void createWDF()
    {
        // --- actual component values fc = 1kHz
        double L1_value = 95.49e-3;     // 95.5 mH
        double C1_value = 0.5305e-6;    // 0.53 uF
        double L2_value = 95.49e-3;     // 95.5 mH
 
                                        // --- set adapter components
        seriesAdaptor_L1.setComponent(wdfComponent::L, L1_value);
        parallelAdaptor_C1.setComponent(wdfComponent::C, C1_value);
        seriesTerminatedAdaptor_L2.setComponent(wdfComponent::L, L2_value);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L1, &parallelAdaptor_C1);
        WdfAdaptorBase::connectAdaptors(&parallelAdaptor_C1, &seriesTerminatedAdaptor_L2);
 
        // --- set source resistance
        seriesAdaptor_L1.setSourceResistance(600.0); // --- Rs = 600
 
        // --- set terminal resistance
        seriesTerminatedAdaptor_L2.setTerminalResistance(600.0); // --- Rload = 600
    }
 
protected:
    // --- three adapters
    WdfSeriesAdaptor seriesAdaptor_L1;          
    WdfParallelAdaptor parallelAdaptor_C1;      
    WdfSeriesTerminatedAdaptor seriesTerminatedAdaptor_L2;  
};
 
class WDFTunableButterLPF3 : public IAudioSignalProcessor
{
public:
    WDFTunableButterLPF3(void) { createWDF(); } /* C-TOR */
    ~WDFTunableButterLPF3(void) {}  /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        // --- rest WDF components (flush state registers)
        seriesAdaptor_L1.reset(_sampleRate);
        parallelAdaptor_C1.reset(_sampleRate);
        seriesTerminatedAdaptor_L2.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_L1.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_L1.setInput1(xn);
 
        // --- output is at terminated L2's output2
        return seriesTerminatedAdaptor_L2.getOutput2();
    }
 
    void createWDF()
    {
        // --- create components, init to noramlized values fc = 1Hz
        seriesAdaptor_L1.setComponent(wdfComponent::L, L1_norm);
        parallelAdaptor_C1.setComponent(wdfComponent::C, C1_norm);
        seriesTerminatedAdaptor_L2.setComponent(wdfComponent::L, L2_norm);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L1, &parallelAdaptor_C1);
        WdfAdaptorBase::connectAdaptors(&parallelAdaptor_C1, &seriesTerminatedAdaptor_L2);
 
        // --- set source resistance
        seriesAdaptor_L1.setSourceResistance(600.0); // --- Rs = 600
 
        // --- set terminal resistance
        seriesTerminatedAdaptor_L2.setTerminalResistance(600.0); // --- Rload = 600
    }
 
    void setUsePostWarping(bool b) { useFrequencyWarping = b; }
 
    void setFilterFc(double fc_Hz)
    {
        if (useFrequencyWarping)
        {
            double arg = (kPi*fc_Hz) / sampleRate;
            fc_Hz = fc_Hz*(tan(arg) / arg);
        }
 
        seriesAdaptor_L1.setComponentValue(L1_norm / fc_Hz);
        parallelAdaptor_C1.setComponentValue(C1_norm / fc_Hz);
        seriesTerminatedAdaptor_L2.setComponentValue(L2_norm / fc_Hz);
    }
 
protected:
    // --- three adapters
    WdfSeriesAdaptor seriesAdaptor_L1;      
    WdfParallelAdaptor parallelAdaptor_C1;  
    WdfSeriesTerminatedAdaptor seriesTerminatedAdaptor_L2;  
 
    double L1_norm = 95.493;        // 95.5 mH
    double C1_norm = 530.516e-6;    // 0.53 uF
    double L2_norm = 95.493;        // 95.5 mH
 
    bool useFrequencyWarping = false;   
    double sampleRate = 1.0;            
};
 
class WDFBesselBSF3 : public IAudioSignalProcessor
{
public:
    WDFBesselBSF3(void) { createWDF(); }    /* C-TOR */
    ~WDFBesselBSF3(void) {} /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        // --- rest WDF components (flush state registers)
        seriesAdaptor_L1C1.reset(_sampleRate);
        parallelAdaptor_L2C2.reset(_sampleRate);
        seriesTerminatedAdaptor_L3C3.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_L1C1.initializeAdaptorChain();
 
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_L1C1.setInput1(xn);
 
        // --- output is at terminated L2's output2
        return seriesTerminatedAdaptor_L3C3.getOutput2();
    }
 
    void createWDF()
    {
        // --- set component values
        // --- fo = 5kHz
        //     BW = 2kHz or Q = 2.5
        seriesAdaptor_L1C1.setComponent(wdfComponent::parallelLC, 16.8327e-3, 0.060193e-6); /* L, C */
        parallelAdaptor_L2C2.setComponent(wdfComponent::seriesLC, 49.1978e-3, 0.02059e-6);  /* L, C */
        seriesTerminatedAdaptor_L3C3.setComponent(wdfComponent::parallelLC, 2.57755e-3, 0.393092e-6);   /* L, C */
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L1C1, &parallelAdaptor_L2C2);
        WdfAdaptorBase::connectAdaptors(&parallelAdaptor_L2C2, &seriesTerminatedAdaptor_L3C3);
 
        // --- set source resistance
        seriesAdaptor_L1C1.setSourceResistance(600.0); // Ro = 600
 
        // --- set terminal resistance
        seriesTerminatedAdaptor_L3C3.setTerminalResistance(600.0);
    }
 
protected:
    // --- three adapters
    WdfSeriesAdaptor seriesAdaptor_L1C1;        
    WdfParallelAdaptor parallelAdaptor_L2C2;    
    WdfSeriesTerminatedAdaptor seriesTerminatedAdaptor_L3C3;    
};
 
 
class WDFConstKBPF6 : public IAudioSignalProcessor
{
public:
    WDFConstKBPF6(void) { createWDF(); }    /* C-TOR */
    ~WDFConstKBPF6(void) {} /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        // --- rest WDF components (flush state registers)
        seriesAdaptor_L1C1.reset(_sampleRate);
        parallelAdaptor_L2C2.reset(_sampleRate);
 
        seriesAdaptor_L3C3.reset(_sampleRate);
        parallelAdaptor_L4C4.reset(_sampleRate);
 
        seriesAdaptor_L5C5.reset(_sampleRate);
        parallelTerminatedAdaptor_L6C6.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_L1C1.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_L1C1.setInput1(xn);
 
        // --- output is at terminated L6C6 output2
        double output = parallelTerminatedAdaptor_L6C6.getOutput2();
 
        return output;
    }
 
    void createWDF()
    {
        // --- fo = 5kHz
        //     BW = 2kHz or Q = 2.5
        seriesAdaptor_L1C1.setComponent(wdfComponent::seriesLC, 47.7465e-3, 0.02122e-6);
        parallelAdaptor_L2C2.setComponent(wdfComponent::parallelLC, 3.81972e-3, 0.265258e-6);
 
        seriesAdaptor_L3C3.setComponent(wdfComponent::seriesLC, 95.493e-3, 0.01061e-6);
        parallelAdaptor_L4C4.setComponent(wdfComponent::parallelLC, 3.81972e-3, 0.265258e-6);
 
        seriesAdaptor_L5C5.setComponent(wdfComponent::seriesLC, 95.493e-3, 0.01061e-6);
        parallelTerminatedAdaptor_L6C6.setComponent(wdfComponent::parallelLC, 7.63944e-3, 0.132629e-6);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L1C1, &parallelAdaptor_L2C2);
        WdfAdaptorBase::connectAdaptors(&parallelAdaptor_L2C2, &seriesAdaptor_L3C3);
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L3C3, &parallelAdaptor_L4C4);
        WdfAdaptorBase::connectAdaptors(&parallelAdaptor_L4C4, &seriesAdaptor_L5C5);
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_L5C5, &parallelTerminatedAdaptor_L6C6);
 
        // --- set source resistance
        seriesAdaptor_L1C1.setSourceResistance(600.0); // Ro = 600
 
        // --- set terminal resistance
        parallelTerminatedAdaptor_L6C6.setTerminalResistance(600.0);
    }
 
protected:
    // --- six adapters
    WdfSeriesAdaptor seriesAdaptor_L1C1;        
    WdfParallelAdaptor parallelAdaptor_L2C2;    
 
    WdfSeriesAdaptor seriesAdaptor_L3C3;        
    WdfParallelAdaptor parallelAdaptor_L4C4;    
 
    WdfSeriesAdaptor seriesAdaptor_L5C5;        
    WdfParallelTerminatedAdaptor parallelTerminatedAdaptor_L6C6;
};
 
 
struct WDFParameters
{
    WDFParameters() {}
    WDFParameters& operator=(const WDFParameters& params)
    {
        if (this == &params)
            return *this;
 
        fc = params.fc;
        Q = params.Q;
        boostCut_dB = params.boostCut_dB;
        frequencyWarping = params.frequencyWarping;
        return *this;
    }
 
    // --- individual parameters
    double fc = 100.0;              
    double Q = 0.707;               
    double boostCut_dB = 0.0;       
    bool frequencyWarping = true;   
};
 
class WDFIdealRLCLPF : public IAudioSignalProcessor
{
public:
    WDFIdealRLCLPF(void) { createWDF(); }   /* C-TOR */
    ~WDFIdealRLCLPF(void) {}    /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
 
        // --- rest WDF components (flush state registers)
        seriesAdaptor_RL.reset(_sampleRate);
        parallelTerminatedAdaptor_C.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_RL.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_RL.setInput1(xn);
 
        // --- output is at terminated L2's output2
        //     note compensation scaling by -6dB = 0.5
        //     because of WDF assumption about Rs and Rload
        return 0.5*parallelTerminatedAdaptor_C.getOutput2();
    }
 
    void createWDF()
    {
        // --- create components, init to noramlized values fc =
        //     initial values for fc = 1kHz Q = 0.707
        //     Holding C Constant at 1e-6
        //             L = 2.533e-2
        //             R = 2.251131 e2
        seriesAdaptor_RL.setComponent(wdfComponent::seriesRL, 2.251131e2, 2.533e-2);
        parallelTerminatedAdaptor_C.setComponent(wdfComponent::C, 1.0e-6);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_RL, &parallelTerminatedAdaptor_C);
 
        // --- set source resistance
        seriesAdaptor_RL.setSourceResistance(0.0); // --- Rs = 600
 
        // --- set open ckt termination
        parallelTerminatedAdaptor_C.setOpenTerminalResistance(true);
    }
 
    WDFParameters getParameters() { return wdfParameters; }
 
    void setParameters(const WDFParameters& _wdfParameters)
    {
        if (_wdfParameters.fc != wdfParameters.fc ||
            _wdfParameters.Q != wdfParameters.Q ||
            _wdfParameters.boostCut_dB != wdfParameters.boostCut_dB ||
            _wdfParameters.frequencyWarping != wdfParameters.frequencyWarping)
        {
            wdfParameters = _wdfParameters;
            double fc_Hz = wdfParameters.fc;
 
            if (wdfParameters.frequencyWarping)
            {
                double arg = (kPi*fc_Hz) / sampleRate;
                fc_Hz = fc_Hz*(tan(arg) / arg);
            }
 
            double inductorValue = 1.0 / (1.0e-6 * pow((2.0*kPi*fc_Hz), 2.0));
            double resistorValue = (1.0 / wdfParameters.Q)*(pow(inductorValue / 1.0e-6, 0.5));
 
            seriesAdaptor_RL.setComponentValue_RL(resistorValue, inductorValue);
            seriesAdaptor_RL.initializeAdaptorChain();
        }
    }
 
protected:
    WDFParameters wdfParameters;    
 
    // --- adapters
    WdfSeriesAdaptor                seriesAdaptor_RL;               
    WdfParallelTerminatedAdaptor    parallelTerminatedAdaptor_C;    
 
    double sampleRate = 1.0;
 
};
 
class WDFIdealRLCHPF : public IAudioSignalProcessor
{
public:
    WDFIdealRLCHPF(void) { createWDF(); }   /* C-TOR */
    ~WDFIdealRLCHPF(void) {}    /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        // --- rest WDF components (flush state registers)
        seriesAdaptor_RC.reset(_sampleRate);
        parallelTerminatedAdaptor_L.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_RC.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_RC.setInput1(xn);
 
        // --- output is at terminated L2's output2
        //     note compensation scaling by -6dB = 0.5
        //     because of WDF assumption about Rs and Rload
        return 0.5*parallelTerminatedAdaptor_L.getOutput2();
    }
 
    void createWDF()
    {
        // --- create components, init to noramlized values fc =
        //     initial values for fc = 1kHz Q = 0.707
        //     Holding C Constant at 1e-6
        //             L = 2.533e-2
        //             R = 2.251131 e2
        seriesAdaptor_RC.setComponent(wdfComponent::seriesRC, 2.251131e2, 1.0e-6);
        parallelTerminatedAdaptor_L.setComponent(wdfComponent::L, 2.533e-2);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_RC, &parallelTerminatedAdaptor_L);
 
        // --- set source resistance
        seriesAdaptor_RC.setSourceResistance(0.0); // --- Rs = 600
 
        // --- set open ckt termination
        parallelTerminatedAdaptor_L.setOpenTerminalResistance(true);
    }
 
    WDFParameters getParameters() { return wdfParameters; }
 
    void setParameters(const WDFParameters& _wdfParameters)
    {
        if (_wdfParameters.fc != wdfParameters.fc ||
            _wdfParameters.Q != wdfParameters.Q ||
            _wdfParameters.boostCut_dB != wdfParameters.boostCut_dB ||
            _wdfParameters.frequencyWarping != wdfParameters.frequencyWarping)
        {
            wdfParameters = _wdfParameters;
            double fc_Hz = wdfParameters.fc;
 
            if (wdfParameters.frequencyWarping)
            {
                double arg = (kPi*fc_Hz) / sampleRate;
                fc_Hz = fc_Hz*(tan(arg) / arg);
            }
 
            double inductorValue = 1.0 / (1.0e-6 * pow((2.0*kPi*fc_Hz), 2.0));
            double resistorValue = (1.0 / wdfParameters.Q)*(pow(inductorValue / 1.0e-6, 0.5));
 
            seriesAdaptor_RC.setComponentValue_RC(resistorValue, 1.0e-6);
            parallelTerminatedAdaptor_L.setComponentValue(inductorValue);
            seriesAdaptor_RC.initializeAdaptorChain();
        }
    }
 
 
protected:
    WDFParameters wdfParameters;    
 
    // --- three
    WdfSeriesAdaptor                seriesAdaptor_RC;               
    WdfParallelTerminatedAdaptor    parallelTerminatedAdaptor_L;    
 
    double sampleRate = 1.0;    
};
 
class WDFIdealRLCBPF : public IAudioSignalProcessor
{
public:
    WDFIdealRLCBPF(void) { createWDF(); }   /* C-TOR */
    ~WDFIdealRLCBPF(void) {}    /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        // --- rest WDF components (flush state registers)
        seriesAdaptor_LC.reset(_sampleRate);
        parallelTerminatedAdaptor_R.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_LC.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_LC.setInput1(xn);
 
        // --- output is at terminated L2's output2
        //     note compensation scaling by -6dB = 0.5
        //     because of WDF assumption about Rs and Rload
        return 0.5*parallelTerminatedAdaptor_R.getOutput2();
    }
 
    void createWDF()
    {
        // --- create components, init to noramlized values fc =
        //     initial values for fc = 1kHz Q = 0.707
        //     Holding C Constant at 1e-6
        //             L = 2.533e-2
        //             R = 2.251131 e2
        seriesAdaptor_LC.setComponent(wdfComponent::seriesLC, 2.533e-2, 1.0e-6);
        parallelTerminatedAdaptor_R.setComponent(wdfComponent::R, 2.251131e2);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_LC, &parallelTerminatedAdaptor_R);
 
        // --- set source resistance
        seriesAdaptor_LC.setSourceResistance(0.0); // --- Rs = 600
 
        // --- set open ckt termination
        parallelTerminatedAdaptor_R.setOpenTerminalResistance(true);
    }
 
    WDFParameters getParameters() { return wdfParameters; }
 
    void setParameters(const WDFParameters& _wdfParameters)
    {
        if (_wdfParameters.fc != wdfParameters.fc ||
            _wdfParameters.Q != wdfParameters.Q ||
            _wdfParameters.boostCut_dB != wdfParameters.boostCut_dB ||
            _wdfParameters.frequencyWarping != wdfParameters.frequencyWarping)
        {
            wdfParameters = _wdfParameters;
            double fc_Hz = wdfParameters.fc;
 
            if (wdfParameters.frequencyWarping)
            {
                double arg = (kPi*fc_Hz) / sampleRate;
                fc_Hz = fc_Hz*(tan(arg) / arg);
            }
 
            double inductorValue = 1.0 / (1.0e-6 * pow((2.0*kPi*fc_Hz), 2.0));
            double resistorValue = (1.0 / wdfParameters.Q)*(pow(inductorValue / 1.0e-6, 0.5));
 
            seriesAdaptor_LC.setComponentValue_LC(inductorValue, 1.0e-6);
            parallelTerminatedAdaptor_R.setComponentValue(resistorValue);
            seriesAdaptor_LC.initializeAdaptorChain();
        }
    }
 
protected:
    WDFParameters wdfParameters;    
 
    // --- adapters
    WdfSeriesAdaptor                seriesAdaptor_LC; 
    WdfParallelTerminatedAdaptor    parallelTerminatedAdaptor_R; 
 
    double sampleRate = 1.0;
};
 
 
class WDFIdealRLCBSF : public IAudioSignalProcessor
{
public:
    WDFIdealRLCBSF(void) { createWDF(); }   /* C-TOR */
    ~WDFIdealRLCBSF(void) {}    /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        sampleRate = _sampleRate;
        // --- rest WDF components (flush state registers)
        seriesAdaptor_R.reset(_sampleRate);
        parallelTerminatedAdaptor_LC.reset(_sampleRate);
 
        // --- intialize the chain of adapters
        seriesAdaptor_R.initializeAdaptorChain();
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    virtual double processAudioSample(double xn)
    {
        // --- push audio sample into series L1
        seriesAdaptor_R.setInput1(xn);
 
        // --- output is at terminated L2's output2
        //     note compensation scaling by -6dB = 0.5
        //     because of WDF assumption about Rs and Rload
        return 0.5*parallelTerminatedAdaptor_LC.getOutput2();
    }
 
    void createWDF()
    {
        // --- create components, init to noramlized values fc =
        //     initial values for fc = 1kHz Q = 0.707
        //     Holding C Constant at 1e-6
        //             L = 2.533e-2
        //             R = 2.251131 e2
        seriesAdaptor_R.setComponent(wdfComponent::R, 2.533e-2);
        parallelTerminatedAdaptor_LC.setComponent(wdfComponent::seriesLC, 2.533e-2, 1.0e-6);
 
        // --- connect adapters
        WdfAdaptorBase::connectAdaptors(&seriesAdaptor_R, &parallelTerminatedAdaptor_LC);
 
        // --- set source resistance
        seriesAdaptor_R.setSourceResistance(0.0); // --- Rs = 600
 
        // --- set open ckt termination
        parallelTerminatedAdaptor_LC.setOpenTerminalResistance(true);
    }
 
    WDFParameters getParameters() { return wdfParameters; }
 
    void setParameters(const WDFParameters& _wdfParameters)
    {
        if (_wdfParameters.fc != wdfParameters.fc ||
            _wdfParameters.Q != wdfParameters.Q ||
            _wdfParameters.boostCut_dB != wdfParameters.boostCut_dB ||
            _wdfParameters.frequencyWarping != wdfParameters.frequencyWarping)
        {
            wdfParameters = _wdfParameters;
            double fc_Hz = wdfParameters.fc;
 
            if (wdfParameters.frequencyWarping)
            {
                double arg = (kPi*fc_Hz) / sampleRate;
                fc_Hz = fc_Hz*(tan(arg) / arg);
            }
 
            double inductorValue = 1.0 / (1.0e-6 * pow((2.0*kPi*fc_Hz), 2.0));
            double resistorValue = (1.0 / wdfParameters.Q)*(pow(inductorValue / 1.0e-6, 0.5));
 
            seriesAdaptor_R.setComponentValue(resistorValue);
            parallelTerminatedAdaptor_LC.setComponentValue_LC(inductorValue, 1.0e-6);
            seriesAdaptor_R.initializeAdaptorChain();
        }
    }
 
protected:
    WDFParameters wdfParameters;    
 
    // --- adapters
    WdfSeriesAdaptor                seriesAdaptor_R; 
    WdfParallelTerminatedAdaptor    parallelTerminatedAdaptor_LC; 
 
    double sampleRate = 1.0; 
};
 
 
// ------------------------------------------------------------------ //
// --- OBJECTS REQUIRING FFTW --------------------------------------- //
// ------------------------------------------------------------------ //
 
enum class windowType {kNoWindow, kRectWindow, kHannWindow, kBlackmanHarrisWindow, kHammingWindow };
 
inline std::unique_ptr<double[]> makeWindow(unsigned int windowLength, unsigned int hopSize, windowType window, double& gainCorrectionValue)
{
    std::unique_ptr<double[]> windowBuffer;
    windowBuffer.reset(new double[windowLength]);
 
    if (!windowBuffer) return nullptr;
 
    double overlap = hopSize > 0.0 ? 1.0 - (double)hopSize / (double)windowLength : 0.0;
    gainCorrectionValue = 0.0;
 
    for (uint32_t n = 0; n < windowLength; n++)
    {
        if (window == windowType::kRectWindow)
        {
            if (n >= 1 && n <= windowLength - 1)
                windowBuffer[n] = 1.0;
        }
        else if (window == windowType::kHammingWindow)
        {
            windowBuffer[n] = 0.54 - 0.46*cos((n*2.0*kPi) / (windowLength));
        }
        else if (window == windowType::kHannWindow)
        {
            windowBuffer[n] = 0.5 * (1 - cos((n*2.0*kPi) / (windowLength)));
        }
        else if (window == windowType::kBlackmanHarrisWindow)
        {
            windowBuffer[n] = (0.42323 - (0.49755*cos((n*2.0*kPi) / (windowLength))) + 0.07922*cos((2 * n*2.0*kPi) / (windowLength)));
        }
        else if (window == windowType::kNoWindow)
        {
            windowBuffer[n] = 1.0;
        }
 
        gainCorrectionValue += windowBuffer[n];
    }
 
    // --- calculate gain correction factor
    if (window != windowType::kNoWindow)
        gainCorrectionValue = (1.0 - overlap) / gainCorrectionValue;
    else
        gainCorrectionValue = 1.0 / gainCorrectionValue;
 
    return windowBuffer;
}
 
// --- FFTW --- to enable, add the statement #define HAVE_FFTW 1 to the top of the file
#ifdef HAVE_FFTW
#include "fftw3.h"
 
class FastFFT
{
public:
    FastFFT() {}        /* C-TOR */
    ~FastFFT() {
        if (windowBuffer) delete[] windowBuffer;
        destroyFFTW();
    }   /* D-TOR */
 
    void initialize(unsigned int _frameLength, windowType _window);
 
    void destroyFFTW();
 
    fftw_complex* doFFT(double* inputReal, double* inputImag = nullptr);
 
    fftw_complex* doInverseFFT(double* inputReal, double* inputImag);
 
    unsigned int getFrameLength() { return frameLength; }
 
protected:
    // --- setup FFTW
    fftw_complex*   fft_input = nullptr;        
    fftw_complex*   fft_result = nullptr;       
    fftw_complex*   ifft_input = nullptr;       
    fftw_complex*   ifft_result = nullptr;      
    fftw_plan       plan_forward = nullptr;     
    fftw_plan       plan_backward = nullptr;    
 
    double* windowBuffer = nullptr;             
    double windowGainCorrection = 1.0;          
    windowType window = windowType::kHannWindow; 
    unsigned int frameLength = 0;               
};
 
 
class PhaseVocoder
{
public:
    PhaseVocoder() {}       /* C-TOR */
    ~PhaseVocoder() {
        if (inputBuffer) delete[] inputBuffer;
        if (outputBuffer) delete[] outputBuffer;
        if (windowBuffer) delete[] windowBuffer;
        destroyFFTW();
    }   /* D-TOR */
 
    void initialize(unsigned int _frameLength, unsigned int _hopSize, windowType _window);
 
    void destroyFFTW();
 
    double processAudioSample(double input, bool& fftReady);
 
    bool addZeroPad(unsigned int count);
 
    bool advanceAndCheckFFT();
 
    fftw_complex* getFFTData() { return fft_result; }
 
    fftw_complex* getIFFTData() { return ifft_result; }
 
    void doInverseFFT();
 
    void doOverlapAdd(double* outputData = nullptr, int length = 0);
 
    unsigned int getFrameLength() { return frameLength; }
 
    unsigned int getHopSize() { return hopSize; }
 
    double getOverlap() { return overlap; }
 
    // --- for fast convolution and other overlap-add algorithms
    //     that are not hop-size dependent
    void setOverlapAddOnly(bool b){ bool overlapAddOnly = b; }
 
protected:
    // --- setup FFTW
    fftw_complex*   fft_input = nullptr;        
    fftw_complex*   fft_result = nullptr;       
    fftw_complex*   ifft_result = nullptr;      
    fftw_plan       plan_forward = nullptr;     
    fftw_plan       plan_backward = nullptr;    
 
    // --- linear buffer for window
    double*         windowBuffer = nullptr;     
 
    // --- circular buffers for input and output
    double*         inputBuffer = nullptr;      
    double*         outputBuffer = nullptr;     
 
    // --- index and wrap masks for input and output buffers
    unsigned int inputWriteIndex = 0;           
    unsigned int outputWriteIndex = 0;          
    unsigned int inputReadIndex = 0;            
    unsigned int outputReadIndex = 0;           
    unsigned int wrapMask = 0;                  
    unsigned int wrapMaskOut = 0;               
 
    // --- amplitude correction factor, aking into account both hopsize (overlap)
    //     and the window power itself
    double windowHopCorrection = 1.0;           
 
    // --- these allow a more robust combination of user interaction
    bool needInverseFFT = false;                
    bool needOverlapAdd = false;                
 
    // --- our window type; you can add more windows if you like
    windowType window = windowType::kHannWindow;
 
    // --- counters
    unsigned int frameLength = 0;               
    unsigned int fftCounter = 0;                
 
    // --- hop-size and overlap (mathematically related)
    unsigned int hopSize = 0;                   
    double overlap = 1.0;                       
 
    // --- flag for overlap-add algorithms that do not involve hop-size, other
    //     than setting the overlap
    bool overlapAddOnly = false;                
 
};
 
class FastConvolver
{
public:
    FastConvolver() {
        vocoder.setOverlapAddOnly(true);
    }       /* C-TOR */
    ~FastConvolver() {
        if (filterIR)
            delete[] filterIR;
 
        if (filterFFT)
            fftw_free(filterFFT);
    }   /* D-TOR */
 
    void initialize(unsigned int _filterImpulseLength)
    {
        if (filterImpulseLength == _filterImpulseLength)
            return;
 
        // --- setup a specialized vocoder with 50% hop size
        filterImpulseLength = _filterImpulseLength;
        vocoder.initialize(filterImpulseLength * 2, filterImpulseLength, windowType::kNoWindow);
 
        // --- initialize the FFT object for capturing the filter FFT
        filterFastFFT.initialize(filterImpulseLength * 2, windowType::kNoWindow);
 
        // --- array to hold the filter IR; this could be localized to the particular function that uses it
        if (filterIR)
            delete [] filterIR;
        filterIR = new double[filterImpulseLength * 2];
        memset(&filterIR[0], 0, filterImpulseLength * 2 * sizeof(double));
 
        // --- allocate the filter FFT arrays
        if(filterFFT)
            fftw_free(filterFFT);
 
         filterFFT = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * filterImpulseLength * 2);
 
         // --- reset
         inputCount = 0;
    }
 
    void setFilterIR(double* irBuffer)
    {
        if (!irBuffer) return;
 
        memset(&filterIR[0], 0, filterImpulseLength * 2 * sizeof(double));
 
        // --- copy over first half; filterIR len = filterImpulseLength * 2
        int m = 0;
        for (unsigned int i = 0; i < filterImpulseLength; i++)
        {
            filterIR[i] = irBuffer[i];
        }
 
        // --- take FFT of the h(n)
        fftw_complex* fftOfFilter = filterFastFFT.doFFT(&filterIR[0]);
 
        // --- copy the FFT into our local buffer for storage; also
        //     we never want to hold a pointer to a FFT output
        //     for more than one local function's worth
        //     could replace with memcpy( )
        for (uint32_t i = 0; i < 2; i++)
        {
            for (unsigned int j = 0; j < filterImpulseLength * 2; j++)
            {
                filterFFT[j][i] = fftOfFilter[j][i];
            }
        }
    }
 
    double processAudioSample(double input)
    {
        bool fftReady = false;
        double output = 0.0;
 
        if (inputCount == filterImpulseLength)
        {
            fftReady = vocoder.addZeroPad(filterImpulseLength);
 
            if (fftReady) // should happen on time
            {
                // --- multiply our filter IR with the vocoder FFT
                fftw_complex* signalFFT = vocoder.getFFTData();
                if (signalFFT)
                {
                    unsigned int fff = vocoder.getFrameLength();
 
                    // --- complex multiply with FFT of IR
                    for (unsigned int i = 0; i < filterImpulseLength * 2; i++)
                    {
                        // --- get real/imag parts of each FFT
                        ComplexNumber signal(signalFFT[i][0], signalFFT[i][1]);
                        ComplexNumber filter(filterFFT[i][0], filterFFT[i][1]);
 
                        // --- use complex multiply function; this convolves in the time domain
                        ComplexNumber product = complexMultiply(signal, filter);
 
                        // --- overwrite the FFT bins
                        signalFFT[i][0] = product.real;
                        signalFFT[i][1] = product.imag;
                    }
                }
            }
 
            // --- reset counter
            inputCount = 0;
        }
 
        // --- process next sample
        output = vocoder.processAudioSample(input, fftReady);
        inputCount++;
 
        return output;
    }
 
    unsigned int getFrameLength() { return vocoder.getFrameLength(); }
 
    unsigned int getFilterIRLength() { return filterImpulseLength; }
 
protected:
    PhaseVocoder vocoder;               
    FastFFT filterFastFFT;              
    fftw_complex* filterFFT = nullptr;  
    double* filterIR = nullptr;         
    unsigned int inputCount = 0;        
    unsigned int filterImpulseLength = 0;
};
 
// --- PSM Vocoder
const unsigned int PSM_FFT_LEN = 4096;
 
struct BinData
{
    BinData() {}
    BinData& operator=(const BinData& params)   // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        isPeak = params.isPeak;
        magnitude = params.magnitude;
        phi = params.phi;
 
        psi = params.psi;
        localPeakBin = params.localPeakBin;
        previousPeakBin = params.previousPeakBin;
        updatedPhase = params.updatedPhase;
 
        return *this;
    }
 
    void reset()
    {
        isPeak = false;
        magnitude = 0.0;
        phi = 0.0;
 
        psi = 0.0;
        localPeakBin = 0;
        previousPeakBin = -1; // -1 is flag
        updatedPhase = 0.0;
    }
 
    bool isPeak = false;    
    double magnitude = 0.0; 
    double phi = 0.0;       
    double psi = 0.0;       
    unsigned int localPeakBin = 0; 
    int previousPeakBin = -1; 
    double updatedPhase = 0.0; 
};
 
struct PSMVocoderParameters
{
    PSMVocoderParameters() {}
    PSMVocoderParameters& operator=(const PSMVocoderParameters& params) // need this override for collections to work
    {
        if (this == &params)
            return *this;
 
        pitchShiftSemitones = params.pitchShiftSemitones;
        enablePeakPhaseLocking = params.enablePeakPhaseLocking;
        enablePeakTracking = params.enablePeakTracking;
 
        return *this;
    }
 
    // --- params
    double pitchShiftSemitones = 0.0;   
    bool enablePeakPhaseLocking = false;
    bool enablePeakTracking = false;    
};
 
class PSMVocoder : public IAudioSignalProcessor
{
public:
    PSMVocoder() {
        vocoder.initialize(PSM_FFT_LEN, PSM_FFT_LEN/4, windowType::kHannWindow);  // 75% overlap
    }       /* C-TOR */
    ~PSMVocoder() {
        if (windowBuff) delete[] windowBuff;
        if (outputBuff) delete[] outputBuff;
 
    }   /* D-TOR */
 
    virtual bool reset(double _sampleRate)
    {
        memset(&phi[0], 0, sizeof(double)*PSM_FFT_LEN);
        memset(&psi[0], 0, sizeof(double)* PSM_FFT_LEN);
        if(outputBuff)
            memset(outputBuff, 0, sizeof(double)*outputBufferLength);
 
        for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
        {
            binData[i].reset();
            binDataPrevious[i].reset();
 
            peakBins[i] = -1;
            peakBinsPrevious[i] = -1;
        }
 
        return true;
    }
 
    virtual bool canProcessAudioFrame() { return false; }
 
    void setPitchShift(double semitones)
    {
        // --- this is costly so only update when things changed
        double newAlpha = pow(2.0, semitones / 12.0);
        double newOutputBufferLength = round((1.0/newAlpha)*(double)PSM_FFT_LEN);
 
        // --- check for change
        if (newOutputBufferLength == outputBufferLength)
            return;
 
        // --- new stuff
        alphaStretchRatio = newAlpha;
        ha = hs / alphaStretchRatio;
 
        // --- set output resample buffer
        outputBufferLength = newOutputBufferLength;
 
        // --- create Hann window
        if (windowBuff) delete[] windowBuff;
        windowBuff = new double[outputBufferLength];
        windowCorrection = 0.0;
        for (unsigned int i = 0; i < outputBufferLength; i++)
        {
            windowBuff[i] = 0.5 * (1.0 - cos((i*2.0*kPi) / (outputBufferLength)));
            windowCorrection += windowBuff[i];
        }
        windowCorrection = 1.0 / windowCorrection;
 
        // --- create output buffer
        if (outputBuff) delete[] outputBuff;
        outputBuff = new double[outputBufferLength];
        memset(outputBuff, 0, sizeof(double)*outputBufferLength);
    }
 
    int findPreviousNearestPeak(int peakIndex)
    {
        if (peakBinsPrevious[0] == -1) // first run, there is no peak
            return -1;
 
        int delta = -1;
        int previousPeak = -1;
        for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
        {
            if (peakBinsPrevious[i] < 0)
                break;
 
            int dist = abs(peakIndex - peakBinsPrevious[i]);
            if (dist > PSM_FFT_LEN/4)
                break;
 
            if (i == 0)
            {
                previousPeak = i;
                delta = dist;
            }
            else if (dist < delta)
            {
                previousPeak = i;
                delta = dist;
            }
        }
 
        return previousPeak;
    }
 
    void findPeaksAndRegionsOfInfluence()
    {
        // --- FIND PEAKS --- //
        //
        // --- find local maxima in 4-sample window
        double localWindow[4] = { 0.0, 0.0, 0.0, 0.0 };
        int m = 0;
        for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
        {
            if (i == 0)
            {
                localWindow[0] = 0.0;
                localWindow[1] = 0.0;
                localWindow[2] = binData[i + 1].magnitude;
                localWindow[3] = binData[i + 2].magnitude;
            }
            else  if (i == 1)
            {
                localWindow[0] = 0.0;
                localWindow[1] = binData[i - 1].magnitude;
                localWindow[2] = binData[i + 1].magnitude;
                localWindow[3] = binData[i + 2].magnitude;
            }
            else  if (i == PSM_FFT_LEN - 1)
            {
                localWindow[0] = binData[i - 2].magnitude;
                localWindow[1] = binData[i - 1].magnitude;
                localWindow[2] = 0.0;
                localWindow[3] = 0.0;
            }
            else  if (i == PSM_FFT_LEN - 2)
            {
                localWindow[0] = binData[i - 2].magnitude;
                localWindow[1] = binData[i - 1].magnitude;
                localWindow[2] = binData[i + 1].magnitude;
                localWindow[3] = 0.0;
            }
            else
            {
                localWindow[0] = binData[i - 2].magnitude;
                localWindow[1] = binData[i - 1].magnitude;
                localWindow[2] = binData[i + 1].magnitude;
                localWindow[3] = binData[i + 2].magnitude;
            }
 
            // --- found peak bin!
            if (binData[i].magnitude > 0.00001 &&
                binData[i].magnitude > localWindow[0]
                && binData[i].magnitude > localWindow[1]
                && binData[i].magnitude > localWindow[2]
                && binData[i].magnitude > localWindow[3])
            {
                binData[i].isPeak = true;
                peakBins[m++] = i;
 
                // --- for peak bins, assume that it is part of a previous, moving peak
                if (parameters.enablePeakTracking)
                    binData[i].previousPeakBin = findPreviousNearestPeak(i);
                else
                    binData[i].previousPeakBin = -1;
            }
        }
 
        // --- assign peak bosses
        if (m > 0)
        {
            int n = 0;
            int bossPeakBin = peakBins[n];
            double nextPeak = peakBins[++n];
            int midBoundary = (nextPeak - (double)bossPeakBin) / 2.0 + bossPeakBin;
 
            if (nextPeak >= 0)
            {
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    if (i <= bossPeakBin)
                    {
                        binData[i].localPeakBin = bossPeakBin;
                    }
                    else if (i < midBoundary)
                    {
                        binData[i].localPeakBin = bossPeakBin;
                    }
                    else // > boundary, calc next set
                    {
                        bossPeakBin = nextPeak;
                        nextPeak = peakBins[++n];
                        if (nextPeak > bossPeakBin)
                            midBoundary = (nextPeak - (double)bossPeakBin) / 2.0 + bossPeakBin;
                        else // nextPeak == -1
                            midBoundary = PSM_FFT_LEN;
 
                        binData[i].localPeakBin = bossPeakBin;
                    }
                }
            }
        }
    }
 
    virtual double processAudioSample(double input)
    {
            bool fftReady = false;
            double output = 0.0;
 
            // --- normal processing
            output = vocoder.processAudioSample(input, fftReady);
 
            // --- if FFT is here, GO!
            if (fftReady)
            {
            // --- get the FFT data
            fftw_complex* fftData = vocoder.getFFTData();
 
            if (parameters.enablePeakPhaseLocking)
            {
                // --- get the magnitudes for searching
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    binData[i].reset();
                    peakBins[i] = -1;
 
                    // --- store mag and phase
                    binData[i].magnitude = getMagnitude(fftData[i][0], fftData[i][1]);
                    binData[i].phi = getPhase(fftData[i][0], fftData[i][1]);
                }
 
                findPeaksAndRegionsOfInfluence();
 
                // --- each bin data should now know its local boss-peak
                //
                // --- now propagate phases accordingly
                //
                //     FIRST: set PSI angles of bosses
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    double mag_k = binData[i].magnitude;
                    double phi_k = binData[i].phi;
 
                    // --- horizontal phase propagation
                    //
                    // --- omega_k = bin frequency(k)
                    double omega_k = kTwoPi*i / PSM_FFT_LEN;
 
                    // --- phase deviation is actual - expected phase
                    //     = phi_k -(phi(last frame) + wk*ha
                    double phaseDev = phi_k - phi[i] - omega_k*ha;
 
                    // --- unwrapped phase increment
                    double deltaPhi = omega_k*ha + principalArg(phaseDev);
 
                    // --- save for next frame
                    phi[i] = phi_k;
 
                    // --- if peak, assume it could have hopped from a different bin
                    if (binData[i].isPeak)
                    {
                        // --- calculate new phase based on stretch factor; save phase for next time
                        if(binData[i].previousPeakBin < 0)
                            psi[i] = principalArg(psi[i] + deltaPhi * alphaStretchRatio);
                        else
                            psi[i] = principalArg(psi[binDataPrevious[i].previousPeakBin] + deltaPhi * alphaStretchRatio);
                    }
 
                    // --- save peak PSI (new angle)
                    binData[i].psi = psi[i];
 
                    // --- for IFFT
                    binData[i].updatedPhase = binData[i].psi;
                }
 
                // --- now set non-peaks
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    if (!binData[i].isPeak)
                    {
                        int myPeakBin = binData[i].localPeakBin;
 
                        double PSI_kp = binData[myPeakBin].psi;
                        double phi_kp = binData[myPeakBin].phi;
 
                        // --- save for next frame
                        // phi[i] = binData[myPeakBin].phi;
 
                        // --- calculate new phase, locked to boss peak
                        psi[i] = principalArg(PSI_kp - phi_kp - binData[i].phi);
                        binData[i].updatedPhase = psi[i];// principalArg(PSI_kp - phi_kp - binData[i].phi);
                    }
                }
 
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    double mag_k = binData[i].magnitude;
 
                    // --- convert back
                    fftData[i][0] = mag_k*cos(binData[i].updatedPhase);
                    fftData[i][1] = mag_k*sin(binData[i].updatedPhase);
 
                    // --- save for next frame
                    binDataPrevious[i] = binData[i];
                    peakBinsPrevious[i] = peakBins[i];
 
                }
            }// end if peak locking
 
            else // ---> old school
            {
                for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                {
                    double mag_k = getMagnitude(fftData[i][0], fftData[i][1]);
                    double phi_k = getPhase(fftData[i][0], fftData[i][1]);
 
                    // --- horizontal phase propagation
                    //
                    // --- omega_k = bin frequency(k)
                    double omega_k = kTwoPi*i / PSM_FFT_LEN;
 
                    // --- phase deviation is actual - expected phase
                    //     = phi_k -(phi(last frame) + wk*ha
                    double phaseDev = phi_k - phi[i] - omega_k*ha;
 
                    // --- unwrapped phase increment
                    double deltaPhi = omega_k*ha + principalArg(phaseDev);
 
                    // --- save for next frame
                    phi[i] = phi_k;
 
                    // --- calculate new phase based on stretch factor; save phase for next time
                    psi[i] = principalArg(psi[i] + deltaPhi * alphaStretchRatio);
 
                    // --- convert back
                    fftData[i][0] = mag_k*cos(psi[i]);
                    fftData[i][1] = mag_k*sin(psi[i]);
                }
            }
 
 
            // --- manually so the IFFT (OPTIONAL)
            vocoder.doInverseFFT();
 
            // --- can get the iFFT buffers
            fftw_complex* inv_fftData = vocoder.getIFFTData();
 
            // --- make copy (can speed this up)
            double ifft[PSM_FFT_LEN] = { 0.0 };
            for (uint32_t i = 0; i < PSM_FFT_LEN; i++)
                ifft[i] = inv_fftData[i][0];
 
            // --- resample the audio as if it were stretched
            resample(&ifft[0], outputBuff, PSM_FFT_LEN, outputBufferLength, interpolation::kLinear, windowCorrection, windowBuff);
 
            // --- overlap-add the interpolated buffer to complete the operation
            vocoder.doOverlapAdd(&outputBuff[0], outputBufferLength);
            }
 
            return output;
    }
 
    PSMVocoderParameters getParameters()
    {
        return parameters;
    }
 
    void setParameters(const PSMVocoderParameters& params)
    {
        if (params.pitchShiftSemitones != parameters.pitchShiftSemitones)
        {
            setPitchShift(params.pitchShiftSemitones);
        }
 
        // --- save
        parameters = params;
    }
 
protected:
    PSMVocoderParameters parameters;    
    PhaseVocoder vocoder;               
    double alphaStretchRatio = 1.0;     
 
    // --- FFT is 4096 with 75% overlap
    const double hs = PSM_FFT_LEN / 4;  
    double ha = PSM_FFT_LEN / 4;        
    double phi[PSM_FFT_LEN] = { 0.0 };  
    double psi[PSM_FFT_LEN] = { 0.0 };  
 
    // --- for peak-locking
    BinData binData[PSM_FFT_LEN];           
    BinData binDataPrevious[PSM_FFT_LEN];   
 
    int peakBins[PSM_FFT_LEN] = { -1 };     
    int peakBinsPrevious[PSM_FFT_LEN] = { -1 }; 
 
    double* windowBuff = nullptr;           
    double* outputBuff = nullptr;           
    double windowCorrection = 0.0;          
    unsigned int outputBufferLength = 0;    
};
 
// --- sample rate conversion
//
// --- supported conversion ratios - you can EASILY add more to this
enum class rateConversionRatio { k2x, k4x };
const unsigned int maxSamplingRatio = 4;
 
inline unsigned int countForRatio(rateConversionRatio ratio)
{
    if (ratio == rateConversionRatio::k2x)
        return 2;
    else if (ratio == rateConversionRatio::k4x || ratio == rateConversionRatio::k4x)
        return 4;
 
    return 0;
}
 
// --- get table pointer for built-in anti-aliasing LPFs
inline double* getFilterIRTable(unsigned int FIRLength, rateConversionRatio ratio, unsigned int sampleRate)
{
    // --- we only have built in filters for 44.1 and 48 kHz
    if (sampleRate != 44100 && sampleRate != 48000) return nullptr;
 
    // --- choose 2xtable
    if (ratio == rateConversionRatio::k2x)
    {
        if (sampleRate == 44100)
        {
            if (FIRLength == 128)
                return &LPF128_882[0];
            else if (FIRLength == 256)
                return &LPF256_882[0];
            else if (FIRLength == 512)
                return &LPF512_882[0];
            else if (FIRLength == 1024)
                return &LPF1024_882[0];
        }
        if (sampleRate == 48000)
        {
            if (FIRLength == 128)
                return &LPF128_96[0];
            else if (FIRLength == 256)
                return &LPF256_96[0];
            else if (FIRLength == 512)
                return &LPF512_96[0];
            else if (FIRLength == 1024)
                return &LPF1024_96[0];
        }
    }
 
    // --- choose 4xtable
    if (ratio == rateConversionRatio::k4x)
    {
        if (sampleRate == 44100)
        {
            if (FIRLength == 128)
                return &LPF128_1764[0];
            else if (FIRLength == 256)
                return &LPF256_1764[0];
            else if (FIRLength == 512)
                return &LPF512_1764[0];
            else if (FIRLength == 1024)
                return &LPF1024_1764[0];
        }
        if (sampleRate == 48000)
        {
            if (FIRLength == 128)
                return &LPF128_192[0];
            else if (FIRLength == 256)
                return &LPF256_192[0];
            else if (FIRLength == 512)
                return &LPF512_192[0];
            else if (FIRLength == 1024)
                return &LPF1024_192[0];
        }
    }
    return nullptr;
}
 
// --- get table pointer for built-in anti-aliasing LPFs
inline double** decomposeFilter(double* filterIR, unsigned int FIRLength, unsigned int ratio)
{
    unsigned int subBandLength = FIRLength / ratio;
    double ** polyFilterSet = new double*[ratio];
    for (unsigned int i = 0; i < ratio; i++)
    {
        double* polyFilter = new double[subBandLength];
        polyFilterSet[i] = polyFilter;
    }
 
    int m = 0;
    for (uint32_t i = 0; i < subBandLength; i++)
    {
        for (int j = ratio - 1; j >= 0; j--)
        {
            double* polyFilter = polyFilterSet[j];
            polyFilter[i] = filterIR[m++];
        }
    }
 
    return polyFilterSet;
}
 
struct InterpolatorOutput
{
    InterpolatorOutput() {}
    double audioData[maxSamplingRatio] = { 0.0, 0.0, 0.0, 0.0 };    
    unsigned int count = maxSamplingRatio;          
};
 
 
class Interpolator
{
public:
    Interpolator() { }      /* C-TOR */
    ~Interpolator() { }     /* D-TOR */
 
    inline void initialize(unsigned int _FIRLength, rateConversionRatio _ratio, unsigned int _sampleRate, bool _polyphase = true)
    {
        polyphase = _polyphase;
        sampleRate = _sampleRate;
        FIRLength = _FIRLength;
        ratio = _ratio;
        unsigned int count = countForRatio(ratio);
        unsigned int subBandLength = FIRLength / count;
 
        // --- straight SRC, no polyphase
        convolver.initialize(FIRLength);
 
        // --- set filterIR from built-in set - user can always override this!
        double* filterTable = getFilterIRTable(FIRLength, ratio, sampleRate);
        if (!filterTable) return;
        convolver.setFilterIR(filterTable);
 
        if (!polyphase) return;
 
        // --- decompose filter
        double** polyPhaseFilters = decomposeFilter(filterTable, FIRLength, count);
        if (!polyPhaseFilters)
        {
            polyphase = false;
            return;
        }
 
        // --- set the individual polyphase filter IRs on the convolvers
        for (unsigned int i = 0; i < count; i++)
        {
            polyPhaseConvolvers[i].initialize(subBandLength);
            polyPhaseConvolvers[i].setFilterIR(polyPhaseFilters[i]);
            delete[] polyPhaseFilters[i];
        }
 
        delete[] polyPhaseFilters;
    }
 
    inline InterpolatorOutput interpolateAudio(double xn)
    {
        unsigned int count = countForRatio(ratio);
 
        // --- setup output
        InterpolatorOutput output;
        output.count = count;
 
        // --- interpolators need the amp correction
        double ampCorrection = double(count);
 
        // --- polyphase uses "backwards" indexing for interpolator; see book
        int m = count-1;
        for (unsigned int i = 0; i < count; i++)
        {
            if (!polyphase)
                output.audioData[i] = i == 0 ? ampCorrection*convolver.processAudioSample(xn) : ampCorrection*convolver.processAudioSample(0.0);
            else
                output.audioData[i] = ampCorrection*polyPhaseConvolvers[m--].processAudioSample(xn);
        }
        return output;
    }
 
protected:
    // --- for straight, non-polyphase
    FastConvolver convolver; 
 
    // --- we save these for future expansion, currently only sparsely used
    unsigned int sampleRate = 44100;    
    unsigned int FIRLength = 256;       
    rateConversionRatio ratio = rateConversionRatio::k2x; 
 
    // --- polyphase: 4x is max right now
    bool polyphase = true;                                  
    FastConvolver polyPhaseConvolvers[maxSamplingRatio];    
};
 
struct DecimatorInput
{
    DecimatorInput() {}
    double audioData[maxSamplingRatio] = { 0.0, 0.0, 0.0, 0.0 };    
    unsigned int count = maxSamplingRatio;          
};
 
class Decimator
{
public:
    Decimator() { }     /* C-TOR */
    ~Decimator() { }    /* D-TOR */
 
    inline void initialize(unsigned int _FIRLength, rateConversionRatio _ratio, unsigned int _sampleRate, bool _polyphase = true)
    {
        polyphase = _polyphase;
        sampleRate = _sampleRate;
        FIRLength = _FIRLength;
        ratio = _ratio;
        unsigned int count = countForRatio(ratio);
        unsigned int subBandLength = FIRLength / count;
 
        // --- straight SRC, no polyphase
        convolver.initialize(FIRLength);
 
        // --- set filterIR from built-in set - user can always override this!
        double* filterTable = getFilterIRTable(FIRLength, ratio, sampleRate);
        if (!filterTable) return;
        convolver.setFilterIR(filterTable);
 
        if (!polyphase) return;
 
        // --- decompose filter
        double** polyPhaseFilters = decomposeFilter(filterTable, FIRLength, count);
        if (!polyPhaseFilters)
        {
            polyphase = false;
            return;
        }
 
        // --- set the individual polyphase filter IRs on the convolvers
        for (unsigned int i = 0; i < count; i++)
        {
            polyPhaseConvolvers[i].initialize(subBandLength);
            polyPhaseConvolvers[i].setFilterIR(polyPhaseFilters[i]);
            delete[] polyPhaseFilters[i];
        }
 
        delete[] polyPhaseFilters;
    }
 
    inline double decimateAudio(DecimatorInput data)
    {
        unsigned int count = countForRatio(ratio);
 
        // --- setup output
        double output = 0.0;
 
        // --- polyphase uses "forwards" indexing for decimator; see book
        for (unsigned int i = 0; i < count; i++)
        {
            if (!polyphase) // overwrites output; only the last output is saved
                output = convolver.processAudioSample(data.audioData[i]);
            else
                output += polyPhaseConvolvers[i].processAudioSample(data.audioData[i]);
        }
        return output;
    }
 
protected:
    // --- for straight, non-polyphase
    FastConvolver convolver;         
 
    // --- we save these for future expansion, currently only sparsely used
    unsigned int sampleRate = 44100;    
    unsigned int FIRLength = 256;       
    rateConversionRatio ratio = rateConversionRatio::k2x; 
 
    // --- polyphase: 4x is max right now
    bool polyphase = true;                                  
    FastConvolver polyPhaseConvolvers[maxSamplingRatio];    
};
 
#endif