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

#ifndef GAMMA_DELAY_H_INC
#define GAMMA_DELAY_H_INC

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

//#include "Gamma/arr.h"
#include "Gamma/ipl.h"
#include "Gamma/mem.h"
#include "Gamma/scl.h"
//#include "Gamma/tbl.h"

#include "Gamma/Containers.h"
#include "Gamma/Strategy.h"
#include "Gamma/Sync.h"
#include "Gamma/Types.h"

namespace gam{



template <class Tv=gam::real, template<class> class Si=ipl::Linear, class Ts=Synced>
class Delay : public ArrayPow2<Tv>, Ts{
public:

    Delay();

    Delay(float delay);

    Delay(float maxDelay, float delay);


    void delay(float v);                        
    void delayUnit(float u);                    
    void freq(float v);                         
    void ipolType(ipl::Type v){ mIpol.type(v); }
    void maxDelay(float v);                     
    void zero();                                

    Tv operator()(const Tv& v);                 
    Tv operator()() const;                      
    Tv read(float ago);                         
    void write(const Tv& v);                    
    void writePre(const Tv& v);                 
    
    float delay() const;                        
    uint32_t delayIndex(uint32_t delay) const;  
    float delayUnit() const;                    
    float freq() const { return 1.f/delay(); }  
    uint32_t indexBack() const;                 
    float maxDelay() const;                     

    virtual void onResize();
    virtual void onResync(double r);

    void print();

protected:
    Si<Tv> mIpol;

    float mMaxDelay;                // maximum delay length
    float mDelayFactor;             // multiplication factor when setting delay
    float mDelayLength;             // current delay length
    uint32_t mPhase;                // write tap
    uint32_t mPhaseInc;             // phase increment
    uint32_t mDelay;                // read tap as delay from write tap

    void incPhase();                // increment phase
    void refreshDelayFactor();
    uint32_t delayFToI(float v);    // convert f.p. delay to fixed-point
};



template <class Tv=gam::real, template <class> class Si=ipl::Linear, class Ts=Synced>
class Delays : public Delay<Tv,Si,Ts> {
public:

    Delays(float delay, uint32_t numTaps)
    :   Delay<Tv,Si,Ts>(delay)
    {   taps(numTaps); }

    uint32_t taps() const { return mDelays.size(); }    

    Tv read(uint32_t tap) const {
        return mIpol(*this, this->mPhase - mDelays[tap]);
    }

    void delay(float length, uint32_t tap){
        mDelays[tap] = this->delayFToI(length);
    }

    void taps(uint32_t numTaps){ mDelays.resize(numTaps); }

protected:
    std::vector<uint32_t> mDelays;
};




template <uint32_t N, class T>
class DelayShift{
public:
    #define IT for(uint32_t i=0; i<N; ++i)

    DelayShift(const T& v=T()){ IT mElems[i]=v; }

    T& operator[](uint32_t i){ return mElems[i]; }
    
    const T& operator[](uint32_t i) const { return mElems[i]; }

    T * elems(){ return mElems; }
    const T * elems() const { return mElems; }


    T operator()(const T& v) const {
        const T r = mElems[N-1];
        for(uint32_t i=N-1; i>0; --i) mElems[i] = mElems[i-1];
        mElems[0]=v;
        return r;
    }

    static uint32_t size(){ return N; }

    #undef IT

protected:
    mutable T mElems[N];
};


template<class T=gam::real> 
class Delay1 : public DelayShift<1,T>{
public:

    Delay1(const T& v=T()): DelayShift<1,T>(v){}
};


template<class T=gam::real> 
class Delay2 : public DelayShift<2,T>{
public:

    Delay2(const T& v=T()): DelayShift<2,T>(v){}
    
    Delay2(const T& v2, const T& v1){ (*this)[1]=v2; (*this)[0]=v1; }
};




// H(z) = (ffd + z^-m) / (1 - fbk z^-m)
// y[n] = ffd x[n] + x[n-m] + fbk y[n-m]
template<
    class Tv=gam::real,
    template <class> class Si=ipl::Linear,
    class Tp=gam::real,
    class Ts=Synced
>
class Comb : public Delay<Tv,Si,Ts> {

private:
    typedef Delay<Tv,Si,Ts> Base;

public:
    using Base::operator();

    Comb();

    Comb(float delay, const Tp& ffd = Tp(0), const Tp& fbk = Tp(0));
    
    Comb(float maxDelay, float delay, const Tp& ffd, const Tp& fbk);

    
    
    void decay(float units, float end = 0.001f);

    void allPass(const Tp& v);

    void fbk(const Tp& v);                  
    void ffd(const Tp& v);                  
    void feeds(const Tp& fwd, const Tp& bwd){ ffd(fwd); fbk(bwd); }

    void set(float delay, const Tp& ffd, const Tp& fbk); 

    Tv operator()(const Tv& i0);                
    Tv operator()(const Tv& i0, const Tv& oN);  
    Tv circulateFbk(const Tv& i0, const Tv& oN);

    Tv nextFbk(const Tv& i0);
    
    float norm() const;             
    float normFbk() const;          
    float normFfd() const;          
    Tp ffd() const;                 
    Tp fbk() const;                 

protected:
    Tp mFFD, mFBK;
};




// Implementation_______________________________________________________________

#define TM1 template <class Tv, template <class> class Ti, class Ts>
#define TM2 Tv,Ti,Ts

#define DELAY_INIT mMaxDelay(0), mDelayFactor(0), mDelayLength(0), mPhase(0), mPhaseInc(0), mDelay(0)

TM1 Delay<TM2>::Delay()
:   ArrayPow2<Tv>(), DELAY_INIT
{   Ts::initSynced(); }

TM1 Delay<TM2>::Delay(float maxDelay, float delay)
:   ArrayPow2<Tv>(), DELAY_INIT
{
    Ts::initSynced();
    this->maxDelay(maxDelay);
    this->delay(delay);
}

TM1 Delay<TM2>::Delay(float delay)
:   ArrayPow2<Tv>(), DELAY_INIT
{   //printf("Delay::Delay(float)\n");
    Ts::initSynced();
    this->maxDelay(delay);
    this->delay(delay);
}

#undef DELAY_INIT

TM1 void Delay<TM2>::maxDelay(float length){ //printf("Delay::maxDelay(%f)\n", length);
    mMaxDelay = length;
    if(Ts::sync() && Ts::sync()->hasBeenSet()){
        //printf("Delay::maxDelay(): resize to %d\n", (uint32_t)(mMaxDelay * spu()));
        
        // This will only trigger onResize() -> onResync(double r) calls if
        // the size changes, thereby preventing infinite recursion.
        this->resize((uint32_t)(mMaxDelay * Ts::spu()));
    }
}

TM1 void Delay<TM2>::zero(){ this->assign(Tv(0)); }

TM1 inline Tv Delay<TM2>::operator()() const{ return mIpol(*this, mPhase - mDelay); }

TM1 inline Tv Delay<TM2>::operator()(const Tv& i0){
//  writePre(i0);
//  return (*this)();
    Tv o0 = (*this)();  // read delayed element
    write(i0);          // write input element
    return o0;
}

TM1 inline uint32_t Delay<TM2>::delayFToI(float v){
    return castIntRound((v * mDelayFactor) * 4294967296.);
    //return scl::unitToUInt(v * mDelayFactor);
}

TM1 inline void Delay<TM2>::incPhase(){ mPhase += mPhaseInc; }

TM1 void Delay<TM2>::onResize(){ //printf("Delay::onResize %d elements\n", this->size());
    mPhaseInc = this->oneIndex();
    //for(uint32_t i=0; i<this->size(); ++i) (*this)[i] = Tv(0);
    if(this->isSoleOwner()) zero();
    onResync(1);
}

TM1 void Delay<TM2>::onResync(double r){ //printf("Delay::onSyncChange\n");
    if(this->usingExternalSource()){
        mMaxDelay = this->size() * Ts::ups();
    }
    else{
        maxDelay(mMaxDelay);
    }
    refreshDelayFactor();
    delay(mDelayLength);
}

TM1 inline Tv Delay<TM2>::read(float ago){ return mIpol(*this, mPhase - delayFToI(ago)); }

TM1 void Delay<TM2>::refreshDelayFactor(){ mDelayFactor = 1. / maxDelay(); }

TM1 inline void Delay<TM2>::write(const Tv& v){
    mem::put(this->elems(), this->fracBits(), mPhase, v);
    incPhase();
}

TM1 inline void Delay<TM2>::writePre(const Tv& v){
    incPhase();
    mem::put(this->elems(), this->fracBits(), mPhase, v);
}

TM1 inline void Delay<TM2>::delay(float v){
    mDelayLength = v;
    mDelay = delayFToI(v);
}

TM1 inline float Delay<TM2>::delay() const { return mDelayLength; }

TM1 inline float Delay<TM2>::delayUnit() const {
    return uintToUnit<float>(mDelay);
}

TM1 inline void Delay<TM2>::delayUnit(float n){ mDelay = unitToUInt(n); }

TM1 inline uint32_t Delay<TM2>::delayIndex(uint32_t delay) const {
    return this->index(mPhase - (delay << this->fracBits()));
}

TM1 inline void Delay<TM2>::freq(float v){ delay(1.f/v); }

TM1 inline uint32_t Delay<TM2>::indexBack() const {
    return this->index(mPhase + this->oneIndex());
}

TM1 inline float Delay<TM2>::maxDelay() const { return this->size() * Ts::ups(); }

TM1 void Delay<TM2>::print(){
    printf("SPU:       %f\n", Ts::spu());
    printf("Buffer:    %p\n", this->elems());
    printf("BufBits:   %d\n", this->log2Size());
    printf("FracBits:  %d\n", this->fracBits());
    printf("Phase:     %d\n", mPhase);
    printf("PhaseInc:  %d\n", mPhaseInc);
    printf("Delay:     %d, %f\n", mDelay, mDelayLength);
    printf("Max Delay: %f\n",  mMaxDelay);
    printf("DlyFactor: %f\n",  mDelayFactor);
}

#undef TM1
#undef TM2




#define TM1 template<class Tv, template<class> class Si, class Tp, class Ts>
#define TM2 Tv,Si,Tp,Ts
TM1 Comb<TM2>::Comb(): Delay<Tv,Si,Ts>(), mFFD(0), mFBK(0){}

TM1 Comb<TM2>::Comb(float delay, const Tp& ffd, const Tp& fbk)
:   Delay<Tv,Si,Ts>(delay), mFFD(ffd), mFBK(fbk)
{}

TM1 Comb<TM2>::Comb(float delayMax, float delay, const Tp& ffd, const Tp& fbk)
:   Delay<Tv,Si,Ts>(delayMax, delay), mFFD(ffd), mFBK(fbk)
{}

TM1 inline Tv Comb<TM2>::operator()(const Tv& i0){
    return (*this)(i0, (*this)()); }

TM1 inline Tv Comb<TM2>::operator()(const Tv& i0, const Tv& oN){
    Tv t = i0 + oN * mFBK;
    this->write(t);
    return oN + t * mFFD;
}

TM1 inline Tv Comb<TM2>::circulateFbk(const Tv& i0, const Tv& oN){
    this->write(i0 + oN * mFBK);
    return oN;
}

TM1 inline Tv Comb<TM2>::nextFbk(const Tv& i0){
    return circulateFbk(i0, (*this)()); }

TM1 inline void Comb<TM2>::decay(float units, float end){
    mFBK = ::pow(end, this->delay() / scl::abs(units));
    if(units < 0.f) mFBK = -mFBK;
}

TM1 inline void Comb<TM2>::allPass(const Tp& v){ fbk(v); ffd(-v); }
TM1 inline void Comb<TM2>::fbk(const Tp& v){ mFBK=v; }
TM1 inline void Comb<TM2>::ffd(const Tp& v){ mFFD=v; }
TM1 inline void Comb<TM2>::set(float d, const Tp& ff, const Tp& fb){ this->delay(d); ffd(ff); fbk(fb); }

TM1 inline Tp Comb<TM2>::fbk() const { return mFBK; }
TM1 inline Tp Comb<TM2>::ffd() const { return mFFD; }
TM1 inline float Comb<TM2>::norm() const { return (1.f - scl::abs(fbk()))/(1.f + scl::abs(ffd())); }
TM1 inline float Comb<TM2>::normFbk() const { return 1.f - scl::abs(fbk()); }
TM1 inline float Comb<TM2>::normFfd() const { return 1.f/(1.f + scl::abs(ffd())); }

#undef TM1
#undef TM2

} // gam::
#endif