Oscillator.h

Go to the documentation of this file.

//
//  Oscillator.h -- specification of the base oscillator class and a few simple waveform generators
//  See the copyright notice and acknowledgment of authors in the file COPYRIGHT
//
// What's here:
//  Oscillator -- Abstract oscillator class
//  WavetableOscillator -- Oscillator with a stored wave table (default wave table is an 8192-sample  sine)
//  CompOrCacheOscillator -- Abstract oscillator class for those who can compute of cache their wavetables
//  Sine -- oscillator class (this computes the sine fcn on the fly)
//  Sawtooth -- Sawtooth oscillator class
//  Square -- Square oscillator class
//  SumOfSines -- Sum-of-sines oscillator class

#ifndef _Oscillator_H
#define _Oscillator_H

#include "CSL_Core.h"
#include <stdarg.h>     // for varargs

#define DEFAULT_WAVETABLE_SIZE 8192         // use large wave tables by default

namespace csl {


class Oscillator : public UnitGenerator, public Phased, public Scalable {
public:                             
    Oscillator(float frequency = 220.0, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
    Oscillator(UnitGenerator & frequency, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
    Oscillator(UnitGenerator & frequency, UnitGenerator & ampl, float offset = 0.0, float phase = 0.0);
    ~Oscillator();                      
    
    void dump();                        
};


#ifdef CSL_ENUMS
typedef enum {
    kTruncate,
    kLinear,
    kCubic,
    kAllPass
} InterpolationPolicy;
#else
    #define kTruncate 1
    #define kLinear 2
    #define kCubic 3
    #define kAllPass 4
    typedef int  InterpolationPolicy;
#endif


class WavetableOscillator : public Oscillator {
public:
//  WavetableOscillator();
    WavetableOscillator(Buffer & wave);
//  WavetableOscillator(SampleBuffer samps, unsigned size);
#ifndef SWIG_ONLY                       // SWIG can't handle the initializers
//  WavetableOscillator(Buffer & wave, float frequency);
//  WavetableOscillator(Buffer & wave, float frequency, float phase);
    WavetableOscillator(float frequency = 1, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
#else
    WavetableOscillator(Buffer & wave, float frequency = 220.0f);
    WavetableOscillator(Buffer & wave, float frequency = 220.0f, float phase = 0.0f);
    WavetableOscillator(float frequency = 1, float ampl = 1.0f, float offset = 0.0f, float phase = 0.0f);
#endif
    void setWaveform(Buffer & wave);        
//  void setWaveform(SampleBuffer samps, unsigned size);
    void setInterpolate(InterpolationPolicy whether) { mInterpolate = whether; };
                                        // get the next buffer of samples
    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);

    InterpolationPolicy mInterpolate;   
    Buffer mWavetable;                  
    
    void fillSine();                    
};


class CompOrCacheOscillator : public WavetableOscillator, public Cacheable {
public:
    CompOrCacheOscillator(bool whether = false, float frequency = 220, float phase = 0.0);
    void createCache();

protected:
    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
    virtual void nextWaveInto(SampleBuffer dest, unsigned count, bool oneHz) = 0;
};


class Sine : public Oscillator {    
public:
    Sine(float frequency = 220, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
};


class Sawtooth : public Oscillator {
public:
    Sawtooth(float frequency = 220, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
};


class Square : public Oscillator {
public:
    Square(float frequency = 220, float ampl = 1.0, float offset = 0.0, float phase = 0.0);
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
};


class Impulse : public Oscillator {
public:
    Impulse();
    Impulse(float delay);
    Impulse(float frequency, float ampl);
    Impulse(float frequency, float ampl, float offset);
    Impulse(float frequency, float ampl, float offset, float phase);
    
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);

protected:
    int mCounter;
};


typedef struct {                // Harmonic partial data structure used here and by the SHARC classes
    float number;           // partial number (need not be an integer)
    float amplitude;            // partial amplitude (0.0 - 1.0)
    float phase;                // Partial phase in radians
} Partial;


#ifdef CSL_ENUMS
typedef enum {
    kFrequency,
    kFreqAmp,
    kFreqAmpPhase
} PartialDescriptionMode;
#else
    #define kFrequency 1
    #define kFreqAmp 2
    #define kFreqAmpPhase 3
    typedef int PartialDescriptionMode;
#endif

    
class SumOfSines : public CompOrCacheOscillator {
public:
    SumOfSines();
    SumOfSines(float frequency);
    SumOfSines(PartialDescriptionMode format, unsigned partialCount, ...);
    
    void addPartial(Partial * pt);
    void addPartials(unsigned num_p, Partial ** pt);
    void addPartials(int argc, void ** argv);
    void addPartial(float nu, float amp);
    void addPartial(float nu, float amp, float phase);
    void clearPartials();

    void dump();                        

protected:
    std::vector<Partial *> mPartials;
    void nextWaveInto(SampleBuffer dest, unsigned count, bool oneHz);

private:
    Buffer outputBuffer;            // kludj so we can use the inherited macros
};

}

#endif