Freeverb.h

Go to the documentation of this file.

//
// Reverb.h -- The CSL port of the public domain Freeverb reverberator
//  Freeverb was written by Jezar at Dreampoint, June 2000 -- http://www.dreampoint.co.uk
//  See the copyright notice and acknowledgment of authors in the file COPYRIGHT
// 

#ifndef CSL_Reverb_H
#define CSL_Reverb_H

#include "CSL_Core.h"

#define undenormalise(sample) if (((*(unsigned int*)&sample)&0x7f800000)==0) sample=0.0f

namespace csl {

class Comb;         // predeclaration of utility classes
class FAllpass;


class Freeverb : public Effect, public Scalable {

public:
    Freeverb(UnitGenerator &input);
    ~Freeverb();

    float roomSize();
    void setRoomSize(float size);   
    float dampening();  
    void setDampening(float damp);  
    float wetLevel();
    void setWetLevel(float level);  
    float dryLevel();
    void setDryLevel(float level);  
    float width();
    void setWidth(float width);     
    
    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:          // accessable parameters
    float mRoomSize;
    float mDampening;   
    float mWetLevel;
    float mDryLevel;
    float mWidth;
                    // internal parameters  
    float mGain;

    std::vector <Comb *> mCombFilters;
    std::vector <FAllpass *> mAllpassFilters;

    SampleBufferVector mCombBuffers;
    SampleBufferVector mAllpassBuffers; 

    void constructReverbGraph();
    void updateParameters();
};


class Comb {
public:
    Comb() : mFilterStore(0), mBufIdx(0) { };

    void    mute();
    float   damp() { return mDamp1; }
    float   feedback() { return mFeedback; }
    void    setDamp(float val);
    void    setFeedback(float val) { mFeedback = val; }
    void    setBuffer(float *buf, int size);
    
    inline  float process(float inp);   

private:
    float   mFeedback;
    float   mFilterStore;
    float   mDamp1;
    float   mDamp2;
    float   *mBufferPtr;
    int     mBufSize;
    int     mBufIdx;
};


class FAllpass {
public:
    FAllpass() : mBufIdx(0) { };

    void    mute();
    float   feedback() { return mFeedback; };
    void    setFeedback(float val) { mFeedback = val; };
    void    setBuffer(float *buf, int size);
    
    inline  float process(float inp);

private:
    float   mFeedback;
    float   *mBufferPtr;
    int     mBufSize;
    int     mBufIdx;
};

// Big to inline - but crucial for speed

inline float Comb::process(float input) {
    float output = mBufferPtr[mBufIdx];
    undenormalise(output);
    mFilterStore = (output * mDamp2) + (mFilterStore * mDamp1);
    undenormalise(mFilterStore);
    mBufferPtr[mBufIdx] = input + (mFilterStore * mFeedback);
    if (++mBufIdx >= mBufSize) 
        mBufIdx = 0;
    return output;
}

inline float FAllpass::process(float input) {
    float bufout = mBufferPtr[mBufIdx];
    undenormalise(bufout);
    float output = -input + bufout;
    mBufferPtr[mBufIdx] = input + (bufout * mFeedback);
    if (++mBufIdx >= mBufSize)
        mBufIdx = 0;
    return output;
}

// Stereoverb is a simple wrapper around 2 freeverbs with splitter/joiners for handling stereo inputs

class Stereoverb : public Effect {

public:
    Stereoverb(UnitGenerator & input);
    ~Stereoverb();

    void setRoomSize(float size);
    void setDampening(float damp);
    void setWetLevel(float level);
    void setDryLevel(float level);
    void setWidth(float width);

    void nextBuffer(Buffer &outputBuffer) throw (CException);

protected:
    Freeverb * leftRev, * rightRev; // 2 mono reverberators
    Splitter * split;               // stereo-to-mono splitter
    Joiner * join;                  // mono-to-stereo joiner
};

}

#endif

---