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 CSL_FILTER_FREQUENCY 4
#define CSL_FILTER_AMOUNT 5


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


#define LOAD_FILTER_CONTROLS                        \
    Controllable :: pullInput(freqPort, numFrames);     \
    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); ///< also specify bandwidth/radius/resonance etc.
    FrequencyAmount(UnitGenerator & frequency, UnitGenerator & amount); ///< also specify bandwidth/radius/resonance etc.
*/  ~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, sample * bCoeffs, sample * aCoeffs, unsigned num_b, unsigned num_a);
    ~Filter();

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

    void setupCoeffs(sample * bCoeffs, sample * 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 (int type, float cutoff);
    Butter (int 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;


};

// Moog VCF class

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

---