FIR.h

Go to the documentation of this file.

///
/// FIR.h -- CSL filter specification and FIR filter classes
/// See the copyright notice and acknowledgment of authors in the file COPYRIGHT
///
/// The FilterSpecification uses the Parks-McClellan/Remez iterative algorithm
// It is provided under GPL by Jake Janovetz (janovetz@uiuc.edu)
///
/// The FIR implementation is based on a minimal version written for the MAT 240B course;
/// it does not use the CSL RingBuffer helper class.

#ifndef CSL_FIR_H
#define CSL_FIR_H

#include "CSL_Core.h"

namespace csl {


class FIR;  ///< forward declaration

///
/// FilterSpecification class for designing multi-band-pass FIR filter impulse responses
///

class FilterSpecification {
public:

    friend class FIR;  ///< Allow the FIR to access private members of this class.

                    // Constructors
    FilterSpecification(unsigned numTaps = 0, unsigned numBands = 0, double *freqs = NULL, double *resps = NULL, double *weights = NULL);
    ~FilterSpecification();
    
                    // Accessors
    void setFrequencies(double *frequencies);
    void setResponses(double *responses);
    void setWeights(double *weights);
    void setNumTaps(unsigned numTaps);
    
    void planFilter();      // method to plan the filter (execute the search/iterate algorithm) 
    double *mTapData;       ///< the FIR tap weights (created by the planFilter method)

protected:
    unsigned mNumTaps;      ///< number of taps desired
    unsigned mNumBands;     ///< length of specification
    double *mFrequencies;   ///< band edge frequencies (2 * mNumBands)
    double *mResponses; ///< band responses (mNumBands)
    double *mWeights;       ///< band error weights (mNumBands)

};

/* Examples
    -- Simple LPF (2 bands) at 0.2 Fs with 0.05-width transition bands
    responses = {    1       x        0 };
    freqs =     { 0    0.2   0.25    0.5 };
    weights =   {   10               20 };
    
    -- basic BPF (3 bands) between 0.2 and 0.3 Fs with 0.05-width transition bands
    responses = {    0.5        x      1      x         0.8 };
    freqs =     { 0    0.15   0.2   0.3   0.35    0.5 };
    weights =   {   20               5                20 };
    
    -- Fancier dual-BPF
    responses = {    0        x      1       x         0        x      1        x       0 };
    freqs =     { 0   0.05   0.1   0.15   0.18   0.25   0.3   0.36   0.41   0.5 };
    weights =   {   10               1                  3                1                20 };
*/

///
/// FIR Filter class
///

class FIR : public Effect {

public:                     /// Various constructors
                            /// Takes a UGen, and optionally the number of taps and the tap IR array.
    FIR (UnitGenerator & in, unsigned numTaps = 2,  float * tapDelay = NULL);
//  FIR (char * file_name);                                 ///< read data from a file
    FIR (FilterSpecification & fs);                         ///< give it a filter specification object
    FIR (UnitGenerator & in, char * fileName);
    FIR (UnitGenerator & in, FilterSpecification & fs);
    ~FIR ();
    
    void setTaps(unsigned numTaps,  float *tapDelays);
    void readTaps(char *fileName);
                    // The work method...
    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:
    FilterSpecification *mFilterSpec;
    unsigned mOffset;       // offset "pointer" for loop counting
                            // Here are the sample buffers (dynamically allocated)
    sample *mDLine;     // mNumTaps length delay line
    
    void resetDLine();      // zero-out mDline and reallocate memory if necessary;
    
                            // Parks-McClellan/Remez FIR filter design algorithm
    void remez(double h[], int numtaps, int numband, double bands[], double des[], double weight[], int type);

};

}

#endif