Filters.h

Go to the documentation of this file.

#ifndef CSL_Filters_H
#define CSL_Filters_H

#define FILTER_MAX_COEFFICIENTS (16)            // seems reasonable?

#include "CSL_Core.h"

namespace csl {

#ifdef CSL_ENUMS

typedef enum {
    BW_LOW_PASS = 0,
    BW_HIGH_PASS,
    BW_BAND_PASS,
    BW_BAND_STOP
} ButterworthType;
#else
    #define BW_LOW_PASS 0
    #define BW_HIGH_PASS 1
    #define BW_BAND_PASS 2
    #define BW_BAND_STOP 3
    typedef int ButterworthType;
#endif


#define DECLARE_FILTER_CONTROLS                                     \
    Port * freqPort = mInputs[CSL_FILTER_FREQUENCY];                \
    Port * bwPort = mInputs[CSL_FILTER_AMOUNT]


#define LOAD_FILTER_CONTROLS                                        \
    if (freqPort) Controllable::pullInput(freqPort, numFrames);     \
    if (bwPort) Controllable::pullInput(bwPort, numFrames)


class FrequencyAmount : public virtual Controllable {
public:     
    FrequencyAmount();                              
/*  FrequencyAmount(float frequency, float amount = 1.f);       ///< also specify bandwidth/radius/resonance etc.
    FrequencyAmount(UnitGenerator & frequency, float amount = 1.f); 
    FrequencyAmount(UnitGenerator & frequency, UnitGenerator & amount);
*/  ~FrequencyAmount();                             
    
                                                    // accessors
    void setFrequency(UnitGenerator & frequency);   
    void setFrequency(float frequency);

    void setAmount(UnitGenerator & amount);         
    void setAmount(float amount);
};


class Filter : public Effect, public Scalable, public FrequencyAmount {
    
public:
    Filter();
    Filter(unsigned num_b, unsigned num_a = 1);
    Filter(UnitGenerator & in, unsigned num_b = 1, unsigned num_a = 1);
    Filter(UnitGenerator & in, SampleBuffer bCoeffs, SampleBuffer aCoeffs, unsigned num_b, unsigned num_a);
    ~Filter();

    void clear(void);                               
    virtual void setupCoeffs() { };                 

    void setupCoeffs(SampleBuffer bCoeffs, SampleBuffer aCoeffs, unsigned num_b, unsigned num_a );
    
    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
    
    void dump();                                    
    
protected:
    void     init(unsigned a, unsigned b);          

    float mBCoeff[FILTER_MAX_COEFFICIENTS];         
    float mACoeff[FILTER_MAX_COEFFICIENTS];         
    unsigned mBNum;                                 
    unsigned mANum;                                 
    Buffer *    mPrevInputs;                        
    Buffer *    mPrevOutputs;
    float mFrame;                                   
};


class Butter : public Filter {
    
public:
                // constructors / destructor
    Butter ();
    Butter (ButterworthType type, float cutoff);
    Butter (ButterworthType type, float center, float bandwidth);
    Butter (UnitGenerator & in, ButterworthType type, float cutoff);
    Butter (UnitGenerator & in, ButterworthType type, UnitGenerator & cutoff);
    Butter (UnitGenerator & in, ButterworthType type, float center, float bandwidth);
    Butter (UnitGenerator & in, ButterworthType type, UnitGenerator & center, UnitGenerator & bandwidth);
                // Filtering
    void setupCoeffs ();

protected:
    int mFilterType;                // flag as to what kind of filter I am

};


class Formant : public Filter {
    
public:
    Formant (UnitGenerator & in, float center_freq, float radius);
    Formant (UnitGenerator & in, UnitGenerator & center_freq, float radius);
    ~Formant(void) { };
    
    void setupCoeffs();
    void setNormalize(bool normalize);

protected:
    bool                mNormalize;
};


class Notch : public Filter {
    
public:
    Notch (UnitGenerator & in, float center_freq, float radius);
    Notch (UnitGenerator & in, UnitGenerator & center_freq, float radius);
    ~Notch(void) { };
                // Filtering
    void setupCoeffs ();

};


class Allpass : public Filter {

public:
                // constructors / destructor
    Allpass (UnitGenerator & in, float coeff);
    Allpass (UnitGenerator & in, UnitGenerator & coeff);
    ~Allpass(void) { };
                // Filtering
    void setupCoeffs();
    
protected:
    UnitGenerator *     mCoeffUGen;
    float               mCoeff;
    Buffer              mCoeffBuffer;
};


class Moog : public Filter {

public:
                // constructors / destructor
    Moog (UnitGenerator & in);
    Moog (UnitGenerator & in, UnitGenerator & cutoff);
    Moog (UnitGenerator & in, UnitGenerator & cutoff, UnitGenerator & resonance);
    Moog (UnitGenerator & in, float cutoff);
    Moog (UnitGenerator & in, float cutoff, float resonance);
    ~Moog (void) { };
                // Filtering
    void setupCoeffs ();
    
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);  

protected:
    float               k, p, r;    // coefficients
    float               x, oldx;
    float               y1, y2, y3, y4, oldy1, oldy2, oldy3;
    bool                debugging;
};

}

#endif