CSL_Core1.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
//#include "ThreadUtilities.h"  // Thread util classes (used only by NullIO)
//#include "ThreadedFrameStream.h"

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

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

typedef enum {          
    kSamples,               
    kSpectra,               
    kLPCCoeff,              
    kIRData,                    
    kWavelet,               
    kGeometry,              
    kUnknown                
} BufferContentType;

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;               
    BufferContentType mType;                
    
    bool mAreBuffersAllocated;          
    bool mDidIAllocateBuffers;          
    bool mIsPopulated;                  
    bool mAreBuffersZero;               

    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]]; }
};

typedef enum {          
    kCopy,              
    kExpand,            
    kIgnore             
} BufferCopyPolicy;

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 (Exception);
    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (Exception);
    
    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;         

    void checkBuffer() throw (LogicError);  
    inline float nextValue();           
    void resetPtr();                    
    void dump();                        
    bool isFixed() { return (mPtrIncrement == 0); };            
};

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


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 (Exception);
    
    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]->mUGen->isActive()); };
    virtual unsigned numChannels() { return (mInputs[CSL_INPUT]->mUGen->numChannels()); };

    void setInput(UnitGenerator & inp); 

    Port * inPort() { return mInputs[CSL_INPUT]; };

    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (Exception);
protected:
    sample *mInputPtr;                  

    void pullInput(Buffer & outputBuffer) throw (Exception);
    void pullInput(unsigned numFrames) throw (Exception);
};


class Writeable {
public:                             
    virtual void writeBuffer(Buffer& inputBuffer) throw(Exception);
    virtual ~Writeable() {};

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

typedef enum {
    kPositionStart,
    kPositionCurrent,
    kPositionEnd
} SeekPosition;

class Seekable {
public:
    Seekable() : mCurrentFrame(0) { }   
    virtual ~Seekable() {};
    
    unsigned mCurrentFrame;             
    
    virtual unsigned seekTo(int position, SeekPosition whence) throw(Exception) = 0;
    virtual void reset() throw(Exception);  
    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(Exception);

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

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

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

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

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

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


// Support for the IO classes

#define DO_TIMING               // Do the timing statistics

#ifdef DO_TIMING                    // Here are the macros and globals for the timing code

#ifndef CSL_WINDOWS         // for UNIX-like platforms

#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))

#else                           // else for MS-Windows

#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                          // platform switch

#endif                          // DO_TIMING

#define DEFAULT_LOGGINGPERIOD 4         // print statistics every 5 seconds

class IO {                                  // no superclass
public:                                     
    IO() : mGraph(NULL), mNumFramesPlayed(0), mSequence(0), mLoggingPeriod(CGestalt::loggingPeriod()) { };
    virtual ~IO() { };
    
    virtual void open() throw(Exception) { };   
    virtual void close() throw(Exception) { };
    virtual void start() throw(Exception) { };
    virtual void stop() throw(Exception) { };
    void setRoot(UnitGenerator & root);
    void clearRoot();
                                
    virtual Buffer & getInput() throw(Exception) = 0;   
    virtual Buffer & getInput(unsigned numFrames, unsigned numChannels) throw(Exception) = 0;   
    unsigned getAndIncrementSequence();     
    
    UnitGenerator * mGraph;                 
    Buffer mInputBuffer;                        
    Buffer mOutputBuffer;                   

    unsigned mNumFramesPlayed;              
    unsigned mSequence;                 
    unsigned mLoggingPeriod;                    
    unsigned mNumInChannels;                
    unsigned mNumOutChannels;               
    unsigned mNumRealInChannels;            
    unsigned mNumRealOutChannels;           
    
#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

---