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

#ifndef GAMMA_AUDIOIO_H_INC
#define GAMMA_AUDIOIO_H_INC

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


/*  This is a simple example demonstrating how to set up a callback
    and process input and output buffers.
    
    struct MyStuff{};

    // Simple: Using automatic indexing
    void audioCBSimple(AudioIOData& io){
        
        MyStuff& stuff = io.user<MyStuff>();

        while(io()){

            float inSample1 = io.in(0);
            float inSample2 = io.in(1);

            io.out(0) = -inSample1;
            io.out(1) = -inSample2;
        }
    }

    // Advanced: Using manual indexing
    void audioCB(AudioIOData& io){
        
        MyStuff& stuff = io.user<MyStuff>();

        for(unsigned i=0; i<io.framesPerBuffer(); ++i){

            float inSample1 = io.in(0,i);
            float inSample2 = io.in(1,i);

            io.out(0,i) = -inSample1;
            io.out(1,i) = -inSample2;
        }
    }
    
    int main(){
        MyStuff stuff;
        
        AudioIO audioIO(128, 44100, audioCB, &stuff, 2,2);
        audioIO.start();
    }
*/

#include <string>

namespace gam{

class AudioIOData;


typedef void (* audioCallback)(AudioIOData& io);


class AudioDevice{
public:

    AudioDevice(int deviceNum);
    
    AudioDevice(const std::string& nameKeyword, bool input=true, bool output=true);

    ~AudioDevice();

    bool valid() const { return 0!=mImpl; } 
    int id() const { return mID; }          
    const char * name() const;              
    int channelsInMax() const;              
    int channelsOutMax() const;             
    double defaultSampleRate() const;       
    
    bool hasInput() const;                  
    bool hasOutput() const;                 
    
    void print() const;                     

    static AudioDevice defaultInput();      
    static AudioDevice defaultOutput();     
    static int numDevices();                
    static void printAll();                 

private:
    void setImpl(int deviceNum);
    static void initDevices();
    int mID;
    const void * mImpl;
};



class AudioIOData {
public:
    AudioIOData(void * user);

    virtual ~AudioIOData();


    bool operator()() const { return (++mFrame)<framesPerBuffer(); }
        
    int frame() const { return mFrame; }

    float& bus(int chan) const { return bus(chan, frame()); }

    float& bus(int chan, int frame) const;

    float * busBuffer(int chan=0) const { return &bus(chan,0); }

    const float& in(int chan) const { return in (chan, frame()); }

    const float& in (int chan, int frame) const;

    const float * inBuffer(int chan=0) const { return &in(chan,0); }

    float& out(int chan) const { return out(chan, frame()); }

    float& out(int chan, int frame) const;

    float * outBuffer(int chan=0) const { return &out(chan,0); }
    
    void sum(float v, int chan) const { out(chan)+=v; }
    
    void sum(float v, int ch1, int ch2) const { sum(v, ch1); sum(v,ch2); }
    
    float& temp(int frame) const;

    float * tempBuffer() const { return &temp(0); }

    void * user() const{ return mUser; } 

    template<class UserDataType>
    UserDataType& user() const { return *(static_cast<UserDataType *>(mUser)); }

    int channelsIn () const;            
    int channelsOut() const;            
    int channelsBus() const;            
    int channelsInDevice() const;       
    int channelsOutDevice() const;      
    int framesPerBuffer() const;        
    double framesPerSecond() const;     
    double fps() const { return framesPerSecond(); }
    double secondsPerBuffer() const;    
    double time() const;                
    double time(int frame) const;       


    void frame(int v){ mFrame=v-1; }    
    void zeroBus();                     
    void zeroOut();                     

protected:
    class Impl; Impl * mImpl;
    void * mUser;                   // User specified data
    mutable int mFrame;
    int mFramesPerBuffer;
    double mFramesPerSecond;
    float *mBufI, *mBufO, *mBufB;   // input, output, and aux buffers
    float * mBufT;                  // temporary one channel buffer
    int mNumI, mNumO, mNumB;        // input, output, and aux channels
};




class AudioIO : public AudioIOData {
public:

    AudioIO(
        int framesPerBuf=64, double framesPerSec=44100.0,
        void (* callback)(AudioIOData &) = 0, void * userData = 0,
        int outChans = 2, int inChans = 0 );

    virtual ~AudioIO();

    using AudioIOData::channelsIn;
    using AudioIOData::channelsOut;
    using AudioIOData::framesPerBuffer;
    using AudioIOData::framesPerSecond;

    audioCallback callback;                     

    bool autoZeroOut() const { return mAutoZeroOut; }
    int channels(bool forOutput) const;
    bool clipOut() const { return mClipOut; }   
    double cpu() const;                         
    bool supportsFPS(double fps) const;         
    bool zeroNANs() const;                      
    
    void operator()();                          
    bool open();                                
    bool close();                               
    bool start();                               
    bool stop();                                

    void autoZeroOut(bool v){ mAutoZeroOut=v; }

    
    void channels(int num, bool forOutput);

    void channelsIn(int n){channels(n,false);}  
    void channelsOut(int n){channels(n,true);}  
    void channelsBus(int num);                  
    void clipOut(bool v){ mClipOut=v; }         
    void deviceIn(const AudioDevice& v);        
    void deviceOut(const AudioDevice& v);       
    void framesPerSecond(double v);             
    void framesPerBuffer(int n);                
    void zeroNANs(bool v){ mZeroNANs=v; }       

    void print();                               

    static const char * errorText(int errNum);      // Returns error string.

private:
    AudioDevice mInDevice, mOutDevice;

    bool mInResizeDeferred, mOutResizeDeferred;
    bool mZeroNANs;         // whether to zero NANs
    bool mClipOut;          // whether to clip output between -1 and 1
    bool mAutoZeroOut;      // whether to automatically zero output buffers each block

    void init();        // Initializes PortAudio and member variables.
    void deferBufferResize(bool forOutput);
    void reopen();      // reopen stream (restarts stream if needed)
    void resizeBuffer(bool forOutput);
};


//==============================================================================

inline float&       AudioIOData::bus(int c, int f) const { return mBufB[c*framesPerBuffer() + f]; }
inline const float& AudioIOData::in (int c, int f) const { return mBufI[c*framesPerBuffer() + f]; }
inline float&       AudioIOData::out(int c, int f) const { return mBufO[c*framesPerBuffer() + f]; }
inline float&       AudioIOData::temp(int f) const { return mBufT[f]; }

} // gam::

#endif