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

#ifndef GAMMA_SOUNDFILE_H_INC
#define GAMMA_SOUNDFILE_H_INC

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

#include <string>
#include <stdio.h>
#include "Gamma/mem.h"

#define TEM template<class T>

namespace gam{
    
    
class SoundFile{
public:

    enum Format{
        WAV = 1,    
        AIFF,       
        AU,         
        RAW,        
    };

    enum EncodingType{
        PCM_S8 = 1, 
        PCM_16,     
        PCM_24,     
        PCM_32,     
        PCM_U8,     
        FLOAT,      
        DOUBLE,     
        ULAW,       
        ALAW,       
    };
    
    static const char * toString(Format v);
    static const char * toString(EncodingType v);

    
    SoundFile(const std::string& path="");
    
    SoundFile(const std::string& path, const SoundFile& src);
    
    ~SoundFile();
    
    
    bool openRead();
    
    
    bool openWrite();
    
    bool close();       
    
    
    //ULONG read(float * dst, ULONG numFrames);
    TEM int read(T * dst, int numFrames);
    
    TEM int readAll(T * dst);

    
    TEM int readAllD(T * dst);
    
    
    TEM int write(const T * src, int numFrames);

    // Sound file properties
    EncodingType encoding() const;              
    Format format() const;                      
    double frameRate() const;                   
    int frames() const;                         
    int channels() const;                       
    int samples() const;                        
    const char * extension();                   
    const std::string& path() const;            
    
    SoundFile& encoding(EncodingType v);        
    SoundFile& format(Format v);                
    SoundFile& channels(int num);               
    SoundFile& frameRate(double hz);            
    SoundFile& info(const SoundFile& src);      
    SoundFile& path(const std::string& path);   

    void seek(int pos, int seekMode);
    
    void print();           
    
private:
    class Impl; Impl * mImpl;

    std::string mPath;
};




// Implementation_______________________________________________________________

inline SoundFile& SoundFile::path(const std::string& v){ mPath=v; return *this; }
inline int SoundFile::samples() const { return frames() * channels(); }

inline const std::string& SoundFile::path() const { return mPath; }

TEM inline int SoundFile::readAll(T * dst){
    seek(0, SEEK_SET);
    return read(dst, frames());
}

TEM int SoundFile::readAllD(T * dst){
    int numChannels = channels();

    if(1 == numChannels) return readAll(dst);
    
    // Allocate memory for deinterleaving.  Don't know of any in-place methods.
    T * temp = new T[samples()];
    int framesRead = 0;
    
    if(temp){
        framesRead = readAll(temp);
        if(framesRead == frames()){
            if(2 == numChannels)    mem::deinterleave2(dst, temp, frames());
            else                    mem::deinterleave(dst, temp, frames(), numChannels);
        }
        delete[] temp;
    }
    return framesRead;
}

} // gam::

#undef TEM
#endif