Envelope.h

Go to the documentation of this file.

//

#ifndef CSL_Envelope_H
#define CSL_Envelope_H

#include "CSL_Core.h"
#include "CPoint.h"

namespace csl {


#ifdef CSL_ENUMS
typedef enum {          
    kLine,      
    kExpon,     
} LineMode;
#else
    #define kLine 1
    #define kExpon 2
    typedef int LineMode;
#endif
class LineSegment : public UnitGenerator {
public:
    LineSegment();          
    LineSegment(float d, float s, float e, LineMode mode = kLine); 

    float start() { return mStart; }            
    float end() { return mEnd; }            
    float duration() { return mDuration; }  
    unsigned currentFrame() { return mCurrentFrame; };

    void setEnd(float end) { mEnd = end; }
    void setStart(float start) { mStart = start; mCurrentValue = mStart; }
    void setDuration(unsigned duration) { mDuration = (float)duration; }    
    void setDuration(float duration) { mDuration = duration; }
    void setMode(LineMode mode) { mMode = mode; }       
    
    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);
    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum, Port * scalePort, Port * offsetPort) throw (CException);

    void reset();               
    void trigger() { this->reset(); };      
    void dump();                

protected:

    float mStart;           
    float mEnd;         
    float mDuration ;   

    LineMode mMode;     
    
    float mCurrentValue;            
    unsigned mCurrentFrame;     
    
};

typedef map<double, LineSegment *> Breakpoints;

class Envelope : public UnitGenerator, public Scalable {
public:
    Envelope() : UnitGenerator(), Scalable(1, 0), mDuration(0) {};
    Envelope(double t, double x1, double y1, double x2 = NULL, double y2 = 1.0, double x3 = NULL, double y3 = 1.0,
                double x4 = NULL, double y4 = 1.0, double x5 = NULL, double y5 = 1.0, double x6 = NULL, double y6 = 1.0);
    Envelope(double t, unsigned int size, double x[], double y[]);

    virtual ~Envelope();

    bool isActive() { return (mCurrentMark < mDuration); };

    void addBreakpoint(double startTime, double value);
    
    void setInterpolationAtSegment(LineMode mode, unsigned idx); 
    void setDuration(float d);      
    void scaleTimes(float s);       
    
    void reset();                   
    void trigger();             
    void dump();
    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:
    float mDuration;                
    float mCurrentMark;         
    Breakpoints mSegmentMap;
    LineSegment **mSegments;
    double *mValues;
    unsigned mSize;
    unsigned int privateNextBuffer(CPoint *breakpoint, LineSegment *segment, float *buffer, unsigned int numFrames);
    void createSegments();      
    void calculateSegments();       
};


class ADSR : public Envelope {

public:
    
    ADSR() : Envelope() {};
    ADSR(float t, float a, float d, float s, float r);
    ADSR(float t, float i, float a, float d, float s, float r);
    ~ADSR() {};
    void setAttack(float attack);
    void setDecay(float decay);
    void setSustain(float sustain);
    void setRelease(float release);

    void release(void);     
};


class AR : public Envelope {

public:
    AR() : Envelope() {};
    AR(float t, float a, float r);
    AR(float t, float i, float a, float r);

    ~AR() {};
    void setAttack(float attack);
    void setRelease(float release);
    void setAll(float d, float a, float r);
    void release(void);         
};

class Triangle : public Envelope {

public:
    Triangle() : Envelope() {};
    Triangle(float duration, float amplitude);
    Triangle(float duration,  float initialDelay, float amplitude);
    ~Triangle() {};
};

class RandEnvelope : public Envelope {
public:
    RandEnvelope(float frequency = 1, float amplitude = 1, float offset = 0, float step = 0);
    ~RandEnvelope() {};
    void setWalk(bool walk) { mWalk = walk; };
    void setAmplitude(float amplitude) { mAmplitude = amplitude; };
    void setFrequency(float frequency) { mFrequency = frequency; };
    void setStep(float step) { mStep = step; };
    void setOffset(float offset) { mOffset = offset; };

    bool isActive() { return true; };
    
    void reset() { };               
    void trigger() { };             
    void dump() {};             

    void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:
    float mLastVal;             
    float mFrequency;           
    float mAmplitude;           
    float mStep;                    
    float mOffset;              
    unsigned mCurrentIndex;     
    unsigned mSegmentLength;    
    bool mWalk;                 
    LineSegment mSegment;       
    
    void initSegment();         
    void nextSegment();         

};

}

#endif

---