CSL_Core.h

Go to the documentation of this file.

#ifndef CSL_CORE_H          // This is in case you 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

// #define CSL_DEBUG        // define this for verbose debugging of constructors and call-backs

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 mMonoBuffers;    
    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 allocateMonoBuffers() throw (MemoryError); 
    void freeMonoBuffers();                         
    
    void zeroBuffers();                 
    void fillWith(sample value);            
    void copySamplesFrom(Buffer & src) throw (RunTimeError);    
    
    sample * monoBuffer(unsigned bufNum) { return mMonoBuffers[bufNum]; }
    
    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, sample * result);   
};

class BufferCMap : public Buffer {
public:
    BufferCMap();                           
    BufferCMap(unsigned numChannels, unsigned numFrames); 
    BufferCMap(unsigned numChannels, unsigned realNumChannels, unsigned numFrames);
    ~BufferCMap();                          
    
    unsigned mRealNumChannels;              
    std::vector<unsigned> mChannelMap;      

    sample * monoBuffer(unsigned bufNum) { return mMonoBuffers[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; }

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

    BufferCopyPolicy copyPolicy() { return mCopyPolicy; };  
    void setCopyPolicy(BufferCopyPolicy ch) { mCopyPolicy = ch; }
    
//  string name() { return mName; };                        ///< get/set the receiver's name string
//  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:          
    unsigned mFrameRate;            
    unsigned mNumChannels;          
    BufferCopyPolicy mCopyPolicy;   
    UGenVector mOutputs;            
    unsigned mNumOutputs;           
    unsigned mSequence;         

    RingBuffer * mOutputCache;      
//  string mName;                   ///< my name (used for editors)
    
    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(sample * where);
    inline bool Port :: 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(sample * where) {
    for (unsigned i = 0; i < mBuffer->mNumChannels; i++)
        *where++ = mBuffer->mMonoBuffers[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() { };            
    
protected:  
    PortMap mInputs;                //< the map of my inputs or controls (used by the mix-in classes)

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

class Phased : public virtual Controllable {
public:
    Phased();                           
    Phased(UnitGenerator & frequency);  
    Phased(float frequency);
    Phased(float frequency, float phase);   
    ~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 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() { return (mInputs[CSL_INPUT]->isActive()); };

    void setInput(UnitGenerator & inp); 
//  UnitGenerator *input() { return mInputs[CSL_INPUT]->mUGen; }

protected:
    sample *mInputPtr;                  

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


class Writeable {
public:                             
    virtual void writeBuffer(Buffer& inputBuffer) throw(CException);

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) { }   

    unsigned mCurrentFrame;             
    
    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;    
};


// Support for the IO classes

#ifndef CSL_WINDOWS
#define DO_TIMING               // Do the timing statistics
#endif CSL_WINDOWS

#ifdef CSL_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

#else                           // other 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                          // other platforms

#endif                          // DO_TIMING

class IO {                                  // no superclass
public:                                     
    IO() : mGraph(NULL), mNumFramesPlayed(0), mSequence(0), mLoggingPeriod(CGestalt::loggingPeriod()) { };
    virtual ~IO() { };

//  static IO * theInstance() { return mInstance; };    ///< Access the singleton instance

    virtual void open() throw(CException) { };  
    virtual void close() throw(CException) { };
    virtual void start() throw(CException) { };
    virtual void stop() throw(CException) { };
    void setRoot(UnitGenerator & root);
    void clearRoot();

    virtual Buffer & getInput() throw(CException) = 0;  
    virtual Buffer & getInput(unsigned numFrames, unsigned numChannels) throw(CException) = 0;  
    unsigned getAndIncrementSequence();     
    
    UnitGenerator * mGraph;                 
    Buffer mInputBuffer;                        
    Buffer mOutputBuffer;                   

    unsigned mNumFramesPlayed;              
    unsigned mSequence;                 
    unsigned mLoggingPeriod;                    
    unsigned mNumInChannels;                // # inputs
    unsigned mNumOutChannels;               // # outputs
    unsigned mNumRealInChannels;            // # physical inputs
    unsigned mNumRealOutChannels;           // # physical outputs

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

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

};

}   // end of namespace

#endif CSL_CORE_H

---