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 tend) { mEnd = tend; }
    void setStart(float tstart) { mStart = tstart; mCurrentValue = mStart; }
    void setDuration(unsigned tduration) { mDuration = (float) tduration; } 
    void setDuration(float tduration) { mDuration = tduration; }
    void setMode(LineMode tmode) { mMode = tmode; }     
    
    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<float, LineSegment *> Breakpoints;


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

    virtual ~Envelope();
    virtual bool isActive();

    void addBreakpoint(float startTime, float value);
    
    void setMode(LineMode mode);
//  void setInterpolationAtSegment(LineMode mode, unsigned idx); ///< allows to specify interpolation other than linear for a segment.
    virtual void setDuration(float d);  
    virtual void scaleTimes(float s);   
    virtual void scaleValues(float s);  
    
    virtual void reset();               
    virtual void trigger();             
    virtual void dump();
    virtual void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:
    float mDuration;                    
    float mCurrentMark;                 
    Breakpoints mSegmentMap;            
    LineSegment **mSegments;            
    float *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(LineMode mode, float t, float a, float d, float s, float r);
    ADSR(LineMode mode, float t, float i, float a, float d, float s, float r);
    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 setDuration(float d);      
    void setDelay(float del);
    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(LineMode mode, float t, float a, float r);
    AR(LineMode mode, float t, float i, float a, float r);
    AR(float t, float a, float r);
    AR(float t, float i, float a, float r);

    ~AR() { };
    void setDuration(float d);      
    void setDelay(float del);
    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(LineMode mode, float duration, float amplitude);
    Triangle(LineMode mode, float duration,  float initialDelay, float amplitude);
    Triangle(float duration, float amplitude = 1.0f);
    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; };

    virtual bool isActive() { return false; };
    void reset() { };               
    void trigger() { };             
    void dump() { };                
    void setDuration(float d) { };  
    void scaleTimes(float s) { };   

    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

---