/Users/ljp/code/gamma/trunk/Gamma/Envelope.h

#ifndef GAMMA_ENVELOPE_H_INC
#define GAMMA_ENVELOPE_H_INC

/*  Gamma - Generic processing library
    See COPYRIGHT file for authors and license information */

#include <math.h>
#include <float.h>

#include "Gamma/Types.h"
#include "Gamma/gen.h"
#include "Gamma/ipl.h"
#include "Gamma/scl.h"
#include "Gamma/Strategy.h"
#include "Gamma/Sync.h"

namespace gam{


template <class Tv=real, class Tp=real>
class Curve{
public:
    Curve();
    
    Curve(Tp length, Tp curve, Tv end=Tv(1), Tv start=Tv(0));

    bool done() const;              
    Tv end() const { return mEnd; } 
    Tv value() const;               

    Tv operator()();                
    Curve& reset(Tv start=Tv(0));   
    Curve& value(const Tv& v);      

    
    Curve& set(Tp length, Tp curve, Tv end=Tv(1), Tv start=Tv(0));

protected:
    Tv mEnd, mA, mB;
    Tp mMul;
};




template <int N, class Tv=real, class Tp=real, class Ts=Synced>
class Env : public Ts{
public:

    Env()
    :   mSustain(N), mLoop(0)
    {
        for(int i=0; i<N; ++i){
            mLengths[i]= 1e-8;
            mCurves[i] =-4;
            mLevels[i] = 1e-8;
        }   mLevels[N] = 1e-8;
        reset();
    }

    int size() const { return N; }
    
    int position() const { return mPos; }
    
    int sustainPoint() const { return mSustain; }
    
    int stage() const { return mStage; }
    
    Tv value() const { return mCurve.value(); }

    bool done() const { return mStage == size(); }
    
    bool released() const { return mSustain < 0; }
    
    bool sustained() const { return (mStage == mSustain); }


    Tv operator()(){
        if(sustained()){
            return mLevels[mStage];
        }
        else if(mPos < mLen){
            ++mPos;
            return mCurve();
        }
        else if(mStage < size()){
            ++mStage;
            if(mLoop && done()) mStage=0;
            if(!done()){
                mPos = 0;
                setLen(mStage);
                mCurve.set(mLen, mCurves[mStage], mLevels[mStage+1], mLevels[mStage]);
                return (*this)(); // return level of new stage
            }
        }
        return mLevels[mStage];
    }   

    void release(){
        mSustain = -scl::abs(mSustain);

        // begin release portion immediately starting at current level
        Tv curVal = value();
        mStage = -mSustain;
        if(!done()){
            mPos = 0;
            setLen(mStage);
            mCurve.set(mLen, mCurves[mStage], mLevels[mStage+1], curVal);
        }
    }


    Env& loop(bool v){ mLoop=v; return *this; }

    Env& sustainPoint(int v){ mSustain=v; return *this; }

    Env& sustainDisable(){ return sustainPoint(N); }

    void reset(){
        // this forces a stage increment upon first iteration
        mPos = 0xFFFFFFFF;
        mLen = 0;
        mStage = -1;
        mSustain = scl::abs(mSustain);
    }

    
    Tp * lengths(){ return mLengths; }

    template <class V>
    Env& lengths(const V* vals, int len){
        int n = len <= size() ? len : size();
        for(int i=0; i<n; ++i) lengths()[i] = vals[i];
        return *this;
    }
    
    Env& lengths(Tp a, Tp b){ Tp v[]={a,b}; return lengths(v,2); }

    Env& lengths(Tp a, Tp b, Tp c){ Tp v[]={a,b,c}; return lengths(v,3); }

    Env& lengths(Tp a, Tp b, Tp c, Tp d){ Tp v[]={a,b,c,d}; return lengths(v,4); }

    Env& lengths(Tp a, Tp b, Tp c, Tp d, Tp e){ Tp v[]={a,b,c,d,e}; return lengths(v,5); }

    Tp totalLength() const {
        Tp sum=Tp(0);
        for(int i=0;i<size();++i) sum += mLengths[i];
        return sum;
    }
    
    
    Env& totalLength(Tp length, int modSegment){
        mLengths[modSegment] = Tp(0);
        mLengths[modSegment] = length - totalLength();
        return *this;
    }

    Env& totalLength(Tp length){
        Tp mul = length / totalLength();
        for(int i=0; i<size(); ++i){
            lengths()[i] *= mul;
        }
        return *this;
    }


    Tp * curves(){ return mCurves; }
    
    Env& curve(Tp v){
        for(int i=0; i<N; ++i) curves()[i]=v;
        return *this;
    }


    Env& segment(int i, Tp len, Tp crv){
        mLengths[i]=len;
        mCurves [i]=crv;
        return *this;
    }

    template <class V>
    Env& segments(const V* lens, const V* crvs, int len, int begin=0){
        int max = size() - begin;
        int n = len < max ? len : max;
        for(int i=0; i<n; ++i){
            segment(i+begin, lens[i], crvs[i]);
        }
        return *this;
    }
    
    Env& segments(Tp la, Tp ca, Tp lb, Tp cb){
        Tp l[]={la,lb}; Tp c[]={ca,cb}; return segments(l,c,2); }

    Env& segments(Tp la, Tp ca, Tp lb, Tp cb, Tp lc, Tp cc){
        Tp l[]={la,lb,lc}; Tp c[]={ca,cb,cc}; return segments(l,c,3); }
    
    Env& segments(Tp la, Tp ca, Tp lb, Tp cb, Tp lc, Tp cc, Tp ld, Tp cd){
        Tp l[]={la,lb,lc,ld}; Tp c[]={ca,cb,cc,cd}; return segments(l,c,4); }


    Tv * levels(){ return mLevels; }

    template <class V>
    Env& levels(const V* vals, int len){
        int n = len <= size() ? len : size()+1;
        for(int i=0; i<n; ++i) levels()[i] = vals[i];
        return *this;
    }
    
    Env& levels(Tv a, Tv b){ Tv v[]={a,b}; return levels(v,2); }

    Env& levels(Tv a, Tv b, Tv c){ Tv v[]={a,b,c}; return levels(v,3); }

    Env& levels(Tv a, Tv b, Tv c, Tv d){ Tv v[]={a,b,c,d}; return levels(v,4); }

    Env& levels(Tv a, Tv b, Tv c, Tv d, Tv e){ Tv v[]={a,b,c,d,e}; return levels(v,5); }


    Env& maxLevel(Tv v){
        using namespace gam::scl;
        Tv mx(0);
        for(int i=0; i<N+1; ++i) mx = max(abs(mLevels[i]), mx);
        v = v/mx;
        for(int i=0; i<N+1; ++i) mLevels[i] *= v;
        return *this;
    }

protected:
    Curve<Tv,Tp> mCurve;
    Tp mLengths[N];         // segment lengths, in samples
    Tp mCurves[N];          // segment curvatures
    Tv mLevels[N+1];        // break-point levels

    uint32_t mPos, mLen;    // position in and length of current segment, in samples
    int mStage;             // the current curve segment
    int mSustain;           // index of sustain point
    int mLoop;

    void setLen(int i){ mLen=mLengths[i]*Ts::spu(); }
};




template <class Tv=real, class Tp=real, class Ts=Synced>
class AD : public Env<2,Tv,Tp,Ts>{
public:
    using Env<2,Tv,Tp,Ts>::release;

    AD(Tp att =Tp(0.01), Tp dec =Tp(0.1), Tv amp = Tv(1), Tp crv =Tp(-4))
    {
        attack(att).decay(dec);
        levels(0,amp,0);
        curve(crv);
    }

    AD& attack(Tp len){ return setLen(0,len); }

    AD& decay(Tp len){ return setLen(1,len); }

    AD& amp(Tv v){ this->levels()[1]=v; return *this; }
    
protected:
    AD& setLen(int i, Tp v){
        this->lengths()[i] = v; return *this;
    }
};



template <class Tv=real, class Tp=real, class Ts=Synced>
class ADSR : public Env<3,Tv,Tp,Ts>{
public:
    using Env<3,Tv,Tp,Ts>::release;

    ADSR(
        Tp att =Tp(0.01), Tp dec =Tp(0.1), Tv sus =Tv(0.7), Tp rel =Tp(1.),
        Tv amp =Tv( 1),
        Tp crv =Tp(-4)
    )
    {
        this->sustainPoint(2);
        levels(0,amp,sus*amp,0);
        attack(att).decay(dec).release(rel);
        curve(crv);
    }

    ADSR& attack(Tp len){ return setLen(0,len); }

    ADSR& decay(Tp len){ return setLen(1,len); }

    ADSR& sustain(Tv val){
        this->levels()[2] = val * this->levels()[1];
        return *this;
    }

    ADSR& release(Tp len){ return setLen(2,len); }
    
    ADSR& amp(Tv v){ return this->maxLevel(v); }
    
protected:
    ADSR& setLen(int i, Tp v){
        this->lengths()[i] = v; return *this;
    }
};




template <class T=real, class Ts=Synced>
class Decay : public Ts{
public:

    Decay(T decay=T(1), T val=T(1));

    T decay() const;        
    bool done(T thresh=T(0.001)) const; 
    T value() const;        

    T operator()();         
    
    void decay(T val);      
    void reset();           
    void value(T val);      
    
protected:
    T mVal, mMul, mDcy;

    virtual void onResync(double r);
};



template <class T=real, class Ts=Synced>
class Gate : public Ts{
public:

    Gate(double closingDelay=0, double threshold=0.001)
    :   mDelay(closingDelay), mRemain(closingDelay), mThresh(threshold), mClosed(0)
    {}

    bool done() const { return mClosed; }

    T operator()(const T& v){       
        if(gam::norm(v) < mThresh){
            mRemain -= Synced::ups();
            if(mRemain <= 0) return close();
        }
        else{
            mRemain = mDelay;
        }
        return open();
    }
    
    Gate& delay(double v){ mDelay=mRemain=v; return *this; }

protected:
    double mDelay, mRemain;
    double mThresh;
    int mClosed;
    T close(){ mClosed=1; return T(0); }
    T  open(){ mClosed=0; return T(1); }
};



template <
    class Tv=real,
    template <class> class Si=iplSeq::Linear,
    class Tp=real,
    class Ts=Synced
>
class Seg : public Ts{
public:

    Seg(Tp len=0.5, Tv start=1, Tv end=0, Tp phase=0):
        mFreq((Tp)1/len), mAcc(0, phase), mIpl(start)
    {
        mIpl.push(end);
        Ts::initSynced();
    }
    
    bool done() const { return mAcc.val >= Tp(1); }
    
    Tv operator()(){
        Tp f = mAcc.val;
        if(done()) return mIpl.val();
        mAcc();
        return mIpl(scl::min(f, Tp(1)));
    }
    
    void operator= (Tv v){
        mIpl.val(mIpl(scl::min(mAcc.val, Tp(1))));
        mIpl.push(v);
        reset();
    }

    
    template <class G>
    Tv operator()(G& g){
        Tp f = mAcc.val;
        Tv v;
        if(f >= Tp(1)){ v = mIpl.val(); (*this) = g(); }
        else{           v = val(); }
        mAcc();
        return v;
    }
    
    void freq(Tp v){ mFreq = v; mAcc.add = v * Ts::ups(); }
    
    void period(Tp v){ freq((Tp)1/v); }

    void phase(Tp v){ mAcc = v; }

    void reset(){ phase((Tp)0); }
    
    Tv val() const { return mIpl(scl::min(mAcc.val, Tp(1))); }
    
    Si<Tv>& ipol(){ return mIpl; }
    
protected:
    Tp mFreq;
    gen::RAdd<Tp> mAcc;
    Si<Tv> mIpl;
    
    virtual void onResync(double r){ freq(mFreq); }
};




template <class T=gam::real, class Ts=Synced>
class SegExp : public Ts{
public:

    SegExp(T len, T crv=-3, T start=1, T end=0):
        mLen(len), mCrv(crv), mVal1(start), mVal0(end)
    {
        Ts::initSynced();
    }
    
    bool done() const { return mFnc.value() >= T(1); }
    
    T operator()(){
        if(done()) return mVal0;
        return ipl::linear(scl::min(mFnc(), T(1)), mVal1, mVal0);
    }
    
    void operator= (T v){
        mVal1 = ipl::linear(scl::min(mFnc.value(), T(1)), mVal1, mVal0);
        mVal0 = v;
        mFnc.reset();
    }
    
    void curve(T v){ set(mLen, v); }
    
    void period(T v){ set(v, mCrv); }

    void reset(){ mFnc.reset(); }

    void set(T len, T crv){
        mLen = len; mCrv = crv;
        mFnc.set(len * Ts::spu(), crv);
    }
    
    virtual void onResync(double r){ set(mLen, mCrv); }
    
protected:
    T mLen, mCrv, mVal1, mVal0;
    Curve<T,T> mFnc;
};





// Implementation_______________________________________________________________

#define TEM template <class Tv,class Tp>

//---- Curve
TEM Curve<Tv,Tp>::Curve(): mEnd(Tv(1)), mA(Tv(0)), mB(Tv(0)), mMul(Tp(1))
{}

TEM Curve<Tv,Tp>::Curve(Tp length, Tp curve, Tv end, Tv start){
    set(length, curve, end, start);
}

TEM inline bool Curve<Tv,Tp>::done() const { return scl::abs(mA - mB*mMul) >= scl::abs(end()); }

TEM inline Tv Curve<Tv,Tp>::value() const { return mA - mB; }

// dividing by mMul goes back one step
TEM inline Curve<Tv,Tp>& Curve<Tv,Tp>::reset(Tv start){ mB = (mA-start) / mMul; return *this; }


// hack to get proper max floating point value
namespace{
    template<class T> inline T  eps(){ return T(0.00001  ); }
    template<> inline double    eps(){ return   0.00000001; }
    template<class T> inline T  maxReal(){ return DBL_MAX; }
    template<> inline float     maxReal<float>(){ return FLT_MAX; }
}

TEM Curve<Tv,Tp>& Curve<Tv,Tp>::set(Tp len, Tp crv, Tv end, Tv start){
    static const Tp EPS = eps<Tp>();

    if(len == Tp(0)){ // if length is 0, return end value immediately
        mEnd = end;
        mMul = maxReal<Tp>();
        mA = end;
        mB = Tv(0);
        return *this;
    }

    // Avoid discontinuity when curve = 0 (a line)
    if(crv < EPS && crv > -EPS){
        crv = crv < Tp(0) ? -EPS : EPS;
    }
    
    Tp crvOverLen = crv / len;
    
    if(crvOverLen < EPS && crvOverLen > -EPS){
        crvOverLen = crvOverLen < Tp(0) ? -EPS : EPS;
        crv = crvOverLen * len;
    }

    /*
    This algorithm uses an exponential curve in [0,1] to linearly interpolate
    between the start and end values.
    
        1 - e^(cx)
    y = ---------- * (end-start) + start
         1 - e^c

         delta             delta
      = ------- + start - ------- e^(cx) 
        1 - e^c           1 - e^c
    */

    mEnd = end;
    mMul = ::exp(crvOverLen);
    mA = (end-start) / (Tp(1) - ::exp(crv));
    mB = mA / mMul;
    mA+= start;
    return *this;
}

TEM inline Curve<Tv,Tp>& Curve<Tv,Tp>::value(const Tv& v){ mB = mA-v; return *this; }

TEM inline Tv Curve<Tv,Tp>::operator()(){
    mB *= mMul;
    return value();
}
#undef TEM



#define TM1 template <class T, class Ts>
#define TM2 T,Ts
//---- Decay

TM1 Decay<TM2>::Decay(T decay_, T val)
:   mVal(val)
{
    Ts::initSynced();
    decay(decay_);
}

TM1 inline T Decay<TM2>::operator()(){ T o = mVal; mVal *= mMul; return o; }

TM1 inline void Decay<TM2>::decay(T v){
    mDcy = v;
    mMul = scl::t60(v * Ts::spu());
}

TM1 inline void Decay<TM2>::reset(){ mVal = 1; }
TM1 inline void Decay<TM2>::value(T v){ mVal = v; }

TM1 inline T Decay<TM2>::decay() const { return mDcy; }
TM1 inline bool Decay<TM2>::done(T thr) const { return mVal < thr; }
TM1 inline T Decay<TM2>::value() const { return mVal; }

TM1 void Decay<TM2>::onResync(double r){ decay(mDcy); }

#undef TM1
#undef TM2


} // gam::
#endif