CSL_Core.h

Go to the documentation of this file.

#ifndef CSL_CORE_H          // This is in case you try to include this twice
#define CSL_CORE_H

#include "CSL_Types.h"      // CSL type definitions and central macros, Observer classes
#include "CSL_Exceptions.h" // CSL exception hierarchy
#include "CGestalt.h"       // System constants class

namespace csl {             // All this happens in the CSL namespace


#ifdef CSL_ENUMS
typedef enum {
    kSamples,               
    kSpectra,               
    kLPCCoeff,              
    kIRData,                
    kWavelet,               
    kGeometry,              
    kUnknown                
} BufferContentType;
#else
    #define kSamples 0
    #define kSpectra 1
    #define kLPCCoeff 2
    #define kIRData 3
    #define kWavelet 4
    #define kGeometry 5
    #define kUnknown 6
    typedef int BufferContentType;
#endif


class Buffer {
public:                                 
    Buffer(unsigned numChannels = 1, unsigned numFrames = CGestalt::blockSize()); 
    ~Buffer();                          
    
                                    // public data members  
    SampleBufferVector mBuffers;        
    unsigned mNumChannels;              
    unsigned mNumFrames;                
    unsigned mMonoBufferByteSize;       
    unsigned mSequence;                 
    Timestamp mTimestamp;               

    bool mAreBuffersAllocated;          
    bool mDidIAllocateBuffers;          
    bool mIsPopulated;                  
    bool mAreBuffersZero;               
    BufferContentType mType;            

    void setSize(unsigned numChannels, unsigned numFrames);
    void setSizeOnly(unsigned numChannels, unsigned numFrames);

    void checkBuffers() throw (MemoryError);    
    void allocateBuffers() throw (MemoryError); 
    void freeBuffers();                         

    void zeroBuffers();                     
    void fillWith(sample value);            
    void copyFrom(Buffer & src) throw (RunTimeError);           
    void copySamplesFrom(Buffer & src) throw (RunTimeError);    

    SampleBuffer monoBuffer(unsigned bufNum) { return mBuffers[bufNum]; }


#ifdef CSL_DSP_BUFFER                       
    float rms(unsigned chan);               
    float avg(unsigned chan);               
    float max(unsigned chan);               
    float min(unsigned chan);               
    unsigned int zeroX(unsigned chan);      
    unsigned int indexOfPeak(unsigned chan);                            
    unsigned int indexOfPeak(unsigned chan, unsigned low, unsigned hi); 
    unsigned int indexOfMin(unsigned chan);                             
    unsigned int indexOfMin(unsigned chan, unsigned low, unsigned hi);  
    void autocorrelation(unsigned chan, SampleBuffer result);           
#endif
};


class BufferCMap : public Buffer {
public:
    BufferCMap();                           
    BufferCMap(unsigned numChannels, unsigned numFrames); 
    BufferCMap(unsigned numChannels, unsigned realNumChannels, unsigned numFrames);
    ~BufferCMap();                          

    unsigned mRealNumChannels;              
    std::vector<int> mChannelMap;           

    SampleBuffer monoBuffer(unsigned bufNum) { return mBuffers[mChannelMap[bufNum]]; }
};


#ifdef CSL_ENUMS
typedef enum {
    kCopy,              
    kExpand,            
    kIgnore             
} BufferCopyPolicy;
#else
    #define kCopy 0
    #define kExpand 1
    #define kIgnore 2
    typedef int BufferCopyPolicy;
#endif

class RingBuffer;   


class UnitGenerator : public Model {
public:
    UnitGenerator(unsigned rate = CGestalt::frameRate(), unsigned chans = 1);   
    virtual ~UnitGenerator() { }        

                                        // accessing methods
    unsigned frameRate() { return mFrameRate; };                
    void setFrameRate(unsigned rate) { mFrameRate = rate; }

    virtual unsigned numChannels() { return mNumChannels; };    
    void setNumChannels(unsigned ch) { mNumChannels = ch; }

    BufferCopyPolicy copyPolicy() { return mCopyPolicy; };      
    void setCopyPolicy(BufferCopyPolicy ch) { mCopyPolicy = ch; }

    string * name() { return mName; };                          
    void setName(string ch) { mName = &ch; }

    virtual void nextBuffer(Buffer & outputBuffer) throw (CException);
    
    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);

    virtual bool isFixed() { return false; };
    virtual bool isActive() { return true; };
    void addOutput(UnitGenerator * ugen);
    void removeOutput(UnitGenerator * ugen);
    UGenVector outputs() { return mOutputs; };

    virtual void setValue(sample theValue) { throw LogicError("can't set value of a generator"); };
    virtual sample value() { throw LogicError("can't get value of a generator"); };

    virtual void dump();            

protected:              // My data members
    unsigned mFrameRate;            
    unsigned mNumChannels;          
    BufferCopyPolicy mCopyPolicy;   
    UGenVector mOutputs;            
    unsigned mNumOutputs;           
    RingBuffer * mOutputCache;      
    unsigned mSequence;             
    string * mName;                 

    void zeroBuffer(Buffer & outputBuffer, unsigned outBufNum);
};


class Port {
public:
    Port();                             
    Port(UnitGenerator * ug);           
    Port(float value);                  
    virtual ~Port();                    

                                        // public data members
    UnitGenerator * mUGen;              
    Buffer * mBuffer;                   
    float mValue;                       
    float *mValuePtr;                   
    unsigned mPtrIncrement;             
    unsigned mValueIndex;               

    void checkBuffer() throw (LogicError);  
    inline float nextValue();               
    inline void nextFrame(SampleBuffer where);
    inline bool isReady();
    void resetPtr();                    
    virtual bool isActive();            
    void dump();                        
    bool isFixed() { return (mPtrIncrement == 0); };    
};

// Answer the next value (dynamic or constant) as a fast inline function

inline sample Port::nextValue() {
    mValuePtr += mPtrIncrement;         // increment the pointer (mPtrIncrement may be 0)
    return *mValuePtr;                  // return the value
}

// Write the next n-dimensional sample frame

inline void Port::nextFrame(SampleBuffer where) {
    for (unsigned i = 0; i < mBuffer->mNumChannels; i++)
        *where++ = mBuffer->mBuffers[i][mValueIndex];
    mValueIndex++;                      // increment the counter (an unsigned, initially 0)
}

// Answer whether the give port is ready (i.e., has its UGen or scalar value set up and primed)

inline bool Port::isReady() {
    return (mValuePtr != 0);
}


class Controllable {
public:
    Controllable() : mInputs() { };         
    virtual ~Controllable() { };            

    Port * getPort(CSL_MAP_KEY name);
protected:
    PortMap mInputs;                        

    void addInput(CSL_MAP_KEY name, UnitGenerator & ugen);
    void addInput(CSL_MAP_KEY name, float value);
    void pullInput(Port * thePort, unsigned numFrames) throw (CException);
    void pullInput(Port * thePort, Buffer & theBuffer) throw (CException);

    virtual void dump();                    
};


class Scalable : public virtual Controllable {
public:
    Scalable();                                     
    Scalable(float scale);                          
    Scalable(float scale, float offset);            
    Scalable(UnitGenerator & scale, float offset);  
    Scalable(UnitGenerator & scale, UnitGenerator & offset);    
    ~Scalable();                                    

                                                    // accessors
    void setScale(UnitGenerator & scale);           
    void setScale(float scale);

    void setOffset(UnitGenerator & offset);         
    void setOffset(float offset);
};



#define DECLARE_SCALABLE_CONTROLS                           \
    Port * scalePort = mInputs[CSL_SCALE];                  \
    Port * offsetPort = mInputs[CSL_OFFSET];                \
    float scaleValue, offsetValue


#define LOAD_SCALABLE_CONTROLS                              \
    Controllable::pullInput(scalePort, numFrames);          \
    scaleValue = scalePort->nextValue();                    \
    Controllable::pullInput(offsetPort, numFrames);         \
    offsetValue = offsetPort->nextValue()

// Update the scale/offset-related values in the loop

#define UPDATE_SCALABLE_CONTROLS                            \
    scaleValue = scalePort->nextValue();                    \
    offsetValue = offsetPort->nextValue()

#define CHECK_UPDATE_SCALABLE_CONTROLS                      \
    if (scalePort)                                          \
        scaleValue = scalePort->nextValue();                \
    if (offsetPort)                                         \
        offsetValue = offsetPort->nextValue()


class Effect : public UnitGenerator, public virtual Controllable {
public:
    Effect();                                   
    Effect(UnitGenerator & input);              

    bool isActive();

    void setInput(UnitGenerator & inp);         
//  UnitGenerator *input() { return mInputs[CSL_INPUT]->mUGen; }    // no getter for now
    bool isInline;                              
    void setInline() { isInline = true; }       
    
protected:
    SampleBuffer mInputPtr;                     

    void pullInput(Buffer & outputBuffer) throw (CException);
    void pullInput(unsigned numFrames) throw (CException);
    inline Port * inPort() { return mInputs[CSL_INPUT]; };
};


class Phased : public virtual Controllable {
public:
    Phased();                                       
    Phased(float frequency, float phase = 0);       
    Phased(UnitGenerator & freq, float phase = 0);  
    ~Phased();                                      

    void setFrequency(UnitGenerator & frequency);
    void setFrequency(float frequency);
    void setPhase(float phase) { mPhase = phase; };

protected:
    float mPhase;                                   
};



#define DECLARE_PHASED_CONTROLS                             \
    Port * freqPort = mInputs[CSL_FREQUENCY];               \
    float freqValue


#define LOAD_PHASED_CONTROLS                                \
    Controllable::pullInput(freqPort, numFrames);           \
    freqValue = freqPort->nextValue()


#define UPDATE_PHASED_CONTROLS                              \
    freqValue = freqPort->nextValue()

#define CHECK_UPDATE_PHASED_CONTROLS                        \
    if (freqPort)                                           \
        freqValue = freqPort->nextValue()

class Writeable {
public:                             
    virtual void writeBuffer(Buffer& inputBuffer) throw(CException);
    virtual ~Writeable() { /* ?? */ };

protected:                          
    virtual void writeBuffer(Buffer & inputBuffer, unsigned bufNum) throw(CException);
};


#ifdef CSL_ENUMS
typedef enum {
    kPositionStart,
    kPositionCurrent,
    kPositionEnd
} SeekPosition;
#else
    #define kPositionStart 0
    #define kPositionCurrent 1
    #define kPositionEnd 2
    typedef int SeekPosition;
#endif


class Seekable {
public:
    Seekable() : mCurrentFrame(0), mActualFrame(0.0)  { }   
    virtual ~Seekable() { /* ?? */ };

    unsigned mCurrentFrame;                 
    double mActualFrame;                    

    virtual unsigned seekTo(int position, SeekPosition whence) throw(CException) = 0;
    virtual void reset() throw(CException); 
    virtual unsigned duration() const = 0;  
};


class Cacheable {
public:
    Cacheable() : mUseCache(false) { }  ;   
    Cacheable(bool uC) : mUseCache(uC) { };

    bool mUseCache;                         
};



class FanOut : public Effect {
public:
    FanOut(UnitGenerator & in, unsigned taps);  
    ~FanOut() { };

    virtual void nextBuffer(Buffer & outputBuffer) throw(CException);

protected:
    Buffer mBuffer;         
    unsigned mOutputs;      
    unsigned mCurrent;      
};


class Splitter : public FanOut {
public:
    Splitter(UnitGenerator & in, unsigned taps);    
    ~Splitter() { };

    void nextBuffer(Buffer & outputBuffer) throw(CException);
};


class Joiner : public Effect {
public:                                     
    Joiner() { };                           
    Joiner(UnitGenerator & in1, UnitGenerator & in2);
    ~Joiner() { };

    void nextBuffer(Buffer & outputBuffer) throw(CException);
    void addInput(UnitGenerator & in);      

protected:
    std::vector<UnitGenerator *>mInputs;    
};


class Interleaver {

public:
    void interleave(Buffer & output, SampleBuffer samples, unsigned numFrames, 
                    unsigned numChannels) throw (CException);
    void interleave(Buffer & output, short * samples, unsigned numFrames, 
                    unsigned numChannels) throw (CException);

    void interleaveAndRemap(Buffer & output, SampleBuffer samples, unsigned numFrames, unsigned numChannels,
                        unsigned *channelMap) throw (CException);

    void deinterleave(Buffer & output, SampleBuffer samples, unsigned numFrames, 
                    unsigned numChannels) throw (CException);
    void deinterleave(Buffer & output, short * samples, unsigned numFrames, 
                    unsigned numChannels) throw (CException);
};



#ifndef CSL_WINDOWS                 // on "normal" platforms

#ifdef DO_TIMING                    // Here are the macros and globals for the timing code
#include <sys/time.h>
#define GET_TIME(val) if (gettimeofday(val, 0) != 0) logMsg(kLogError, "Output: Error reading current time");
#define SUB_TIMES(t1, t2) (((t1->tv_sec - t2->tv_sec) * 1000000) + (t1->tv_usec - t2->tv_usec))
#endif

#else                               // If on Windows

#ifdef DO_TIMING                    // Here are the macros and globals for the timing code
#include <Winsock2.h>
#include <winsock.h>
#include <time.h>
int getSysTime(timeval *val, void * e);
#define GET_TIME(val) if (getSysTime(val, 0) != 0) logMsg(kLogError, "Output: Error reading current time");
#define SUB_TIMES(t1, t2) (((t1->tv_sec - t2->tv_sec) * 1000000) + (t1->tv_usec - t2->tv_usec))
#endif

#endif                              // Windows

// IO Status flag

#ifdef CSL_ENUMS
typedef enum {
    kIONew,
    kIOInit,
    kIOOpen,
    kIORunning,
    kIOClosed,
    kIOExit
} IO_Status;
#else
    #define kIONew 0
    #define kIOInit 1
    #define kIOOpen 2
    #define kIORunning 3
    #define kIOClosed 4
    #define kIOExit 5
    typedef int IO_Status;
#endif


class IO : public Model  {                                  // superclass = Model
public:
    IO(unsigned s_rate = 44100, unsigned b_size = CGestalt::blockSize(),
        int in_device = -1, int out_device = -1,
        unsigned in_chans = 0, unsigned out_chans = 2);             
    virtual ~IO() { };
                            // Control methods
    virtual void open() throw(CException) { mStatus = kIOOpen; };   
    virtual void close() throw(CException) { mStatus = kIOClosed; };
    virtual void start() throw(CException) { mStatus = kIORunning; };
    virtual void stop() throw(CException) { mStatus = kIOOpen; };
    virtual void test() throw(CException) { };  
    
    void setRoot(UnitGenerator & root);     
    void clearRoot();
    void pullInput(Buffer & outBuffer, SampleBuffer out = 0)  throw(CException);

    virtual Buffer & getInput() throw(CException);  
    virtual Buffer & getInput(unsigned numFrames, unsigned numChannels) throw(CException);
    unsigned getAndIncrementSequence();     

                            // Data members
    UnitGenerator * mGraph;                 
    Buffer mInputBuffer;                    
    Buffer mOutputBuffer;                   
    SampleBuffer mInputPointer;             
    unsigned * mChannelMap;                 

    unsigned mNumFramesPlayed;              
    unsigned mSequence;                     
    unsigned mLoggingPeriod;                
    unsigned mNumInChannels;                
    unsigned mNumOutChannels;               
    unsigned mNumRealInChannels;            
    unsigned mNumRealOutChannels;           
    IO_Status mStatus;                      
    bool mInterleaved;                      

#ifdef DO_TIMING                            // This is for the performance timing code
    struct timeval mThen, mNow;             
    long mTimeVals, mThisSec, mTimeSum;     
    float mUsage;                           

    void printTimeStatistics(struct timeval * tthen, struct timeval * tnow, long * tsecond, 
                            long * ttimeSum, long * ttimeVals);
#endif

protected:                                  
    virtual void initialize(unsigned sr, unsigned bs, int is, int os, unsigned ic, unsigned oc) { };
};


class IODevice {
public:
    IODevice() { } ;                        
    IODevice(char * name, unsigned index, unsigned maxIn, unsigned maxOut, bool isIn, bool isOut);
    IODevice(string name, unsigned index, unsigned maxIn, unsigned maxOut, bool isIn, bool isOut);
    char mName[CSL_NAME_LEN];       
    unsigned mIndex;                
    unsigned mMaxInputChannels;     
    unsigned mMaxOutputChannels;    
    float mFrameRate;               
    vector<float> mFrameRates;      
    bool mIsDefaultIn;              
    bool mIsDefaultOut;             
    void dump();                    
};

}   // end of namespace

#endif // CSL_CORE_H

---