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

#ifndef GAMMA_PLAYER_H_INC
#define GAMMA_PLAYER_H_INC

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

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

namespace gam{



template<
    class T = real,
    template<class> class Si = ipl::Trunc,
    class St = tap::Clip
>
class Player: public Synced, public Array<T>{
public:
    using Array<T>::size; using Array<T>::elems;

    Player()
    :   Array<T>(defaultBuffer(), 1),
        mPos(0), mInc(0),
        mSampleRate(1), mChans(1),
        mRate(1), mMin(0), mMax(1)
    {}


    explicit Player(Player<T>& src, double rate=1)
    :   Array<T>(src), 
        mPos(0), mInc(1), 
        mSampleRate(src.sampleRate()), mChans(src.channels()), 
        mRate(rate), mMin(0), mMax(src.size())
    { initSynced(); }


    Player(Array<T>& src, double smpRate, double rate=1)
    :   Array<T>(src),
        mPos(0), mInc(1),
        mSampleRate(smpRate), mChans(1),
        mRate(rate), mMin(0), mMax(src.size())
    {
        initSynced();
        sampleRate(smpRate);
    }


    template<class Char>
    explicit Player(const Char * pathToSoundFile, double rate=1);


    template<class Char>
    bool load(const Char * pathToSoundFile);


    void advance(){
        mPos = mTap(pos(), mInc, max(), min()); // update read tap, in frames
    }

    T operator()(int channel=0){ T r = read(channel); advance(); return r; }

    T read(int channel) const {
        uint32_t posi = uint32_t(pos());
        int Nframes= frames();
        int offset = channel*Nframes;
        return mIpol(*this, posi+offset, pos()-posi, offset+Nframes-1, offset);
    }

    
    void buffer(Array<T>& src, double smpRate, int channels);

    void free();                            
    void max(double v);                     
    void min(double v);                     
    void pos(double v);                     
    void phase(double v);                   
    void rate(double v);                    
    void range(double phs, double period);  
    void reset();                           

    double max() const { return mMax; }     
    double min() const { return mMin; }     
    double period() const;                  
    double pos() const { return mPos; }     
    double posInInterval(double frac) const;
    double rate() const { return mRate; }   
    double sampleRate() const { return mSampleRate; } 

    int channels() const { return mChans; } 

    virtual void onResync(double r){ sampleRate(mSampleRate); }

protected:  
    static T * defaultBuffer(){
        static T v(0);
        return &v;
    }

    Si<T> mIpol;
    St mTap;

    double mPos, mInc;          // real index position and increment
    double mSampleRate;         // sample rate of array data
    int mChans;                 // number of channels
    double mRate, mMin, mMax;
    
    void sampleRate(double v){
        mSampleRate = v;
        rate(mRate);
    }

    int frames() const { return size()/channels(); }
};

#define PRE template <class T, template<class> class Si, class St>
#define CLS Player<T,Si,St>

PRE
template<class Char>
CLS::Player(const Char * path, double rate)
:   Array<T>(), mPos(0), mInc(1), mChans(1), mRate(rate), mMin(0), mMax(1)
{   
    if(!load(path)){
        this->source(defaultBuffer(), 1);
    }
}

PRE
template<class Char>
bool CLS::load(const Char * pathToSoundFile){
    SoundFile sf(pathToSoundFile);
    
    if(sf.openRead()){
        Array<T>::resize(sf.samples());
        sf.readAllD(elems());
        sampleRate(sf.frameRate());
        mChans = sf.channels();
        mMin = 0;
        mMax = frames();
        mPos = 0;
        sf.close();
        return true;
    }
    
    return false;
}

PRE void CLS::buffer(Array<T>& src, double smpRate, int channels){
    this->source(src);
    sampleRate(smpRate);    // sets mSampleRate, mRate, and mInc
    mChans = channels;
    mMin = 0;
    mMax = frames();
    mPos = 0;
}

PRE inline void CLS::pos(double v){ mPos = v; }
PRE inline void CLS::phase(double v){ pos(v * frames()); }
PRE inline void CLS::min(double v){ mMin = scl::clip<double>(v, frames()); }    
PRE inline void CLS::max(double v){ mMax = scl::clip<double>(v, frames()); }

PRE void CLS::free(){ this->freeElements(); }
PRE inline void CLS::rate(double v){
    mRate = v;
    mInc = v * mSampleRate * ups();
}
PRE inline void CLS::range(double posn, double period){
    phase(posn);
    min(pos());
    max(pos() + period * spu());    
}

PRE inline void CLS::reset(){
    pos(rate()<0 ? max() : min());
    mTap.reset();
}

PRE inline double CLS::period() const { return frames() * ups(); }
PRE inline double CLS::posInInterval(double frac) const { return min() + (max() - min()) * frac; }

#undef PRE
#undef CLS

} // gam::

#endif