leaf-oscillators.h

/*==============================================================================
 leaf-oscillators.h
 Created: 20 Jan 2017 12:00:58pm
 Author:  Michael R Mulshine
 ==============================================================================*/
 
#ifndef LEAF_OSCILLATORS_H_INCLUDED
#define LEAF_OSCILLATORS_H_INCLUDED
 
#ifdef __cplusplus
extern "C" {
#endif
    
    //==============================================================================
    
#include "leaf-math.h"
#include "leaf-mempool.h"
#include "leaf-tables.h"
#include "leaf-filters.h"
#include "leaf-distortion.h"
    
    //==============================================================================
    
    typedef struct _tTable
    {
        tMempool mempool;
        
        float* waveTable;
        int size;
        float inc, freq;
        float phase;
    } _tTable;
    
    typedef _tTable* tTable;
 
     void    tTable_init(tTable* const osc, float* table, int size, LEAF* const leaf);
     void    tTable_initToPool(tTable* const osc, float* table, int size, tMempool* const mempool);
     void    tTable_free(tTable* const osc);
    
     float   tTable_tick(tTable* const osc);
     void    tTable_setFreq(tTable* const osc, float freq);
    
    //==============================================================================
    
    typedef struct _tWavetable
    {
        tMempool mempool;
        
        float** tables;
        int size;
        int numTables;
        float baseFreq, invBaseFreq;
        float inc, freq;
        float phase;
        
        int oct;
        float w;
        float aa;
        
        tButterworth bl;
    } _tWavetable;
    
    typedef _tWavetable* tWavetable;
    
    void    tWavetable_init(tWavetable* const osc, const float* table, int size, float maxFreq, LEAF* const leaf);
    void    tWavetable_initToPool(tWavetable* const osc, const float* table, int size, float maxFreq, tMempool* const mempool);
    void    tWavetable_free(tWavetable* const osc);
    
    float   tWavetable_tick(tWavetable* const osc);
    void    tWavetable_setFreq(tWavetable* const osc, float freq);
    void    tWavetable_setAntiAliasing(tWavetable* const osc, float aa);
    
    //==============================================================================
    
    typedef struct _tCompactWavetable
    {
        tMempool mempool;
        
        float** tables;
        int numTables;
        int* sizes;
        float baseFreq, invBaseFreq;
        float inc, freq;
        float phase;
        
        int oct;
        float w;
        float aa;
        
        tButterworth bl;
        
        float dsBuffer[2];
        tOversampler ds;
    } _tCompactWavetable;
    
    typedef _tCompactWavetable* tCompactWavetable;
    
    void    tCompactWavetable_init(tCompactWavetable* const osc, const float* table, int size, float maxFreq, LEAF* const leaf);
    void    tCompactWavetable_initToPool(tCompactWavetable* const osc, const float* table, int size, float maxFreq, tMempool* const mempool);
    void    tCompactWavetable_free(tCompactWavetable* const osc);
    
    float   tCompactWavetable_tick(tCompactWavetable* const osc);
    void    tCompactWavetable_setFreq(tCompactWavetable* const osc, float freq);
    void    tCompactWavetable_setAntiAliasing(tCompactWavetable* const osc, float aa);
    
    //==============================================================================
    
    typedef struct _tCycle
    {
        
        tMempool mempool;
        // Underlying phasor
        float phase;
        float inc,freq;
    } _tCycle;
    
    typedef _tCycle* tCycle;
    
    void    tCycle_init         (tCycle* const osc, LEAF* const leaf);
    void    tCycle_initToPool   (tCycle* const osc, tMempool* const mempool);
    void    tCycle_free         (tCycle* const osc);
    
    float   tCycle_tick         (tCycle* const osc);
    void    tCycle_setFreq      (tCycle* const osc, float freq);
    
    //==============================================================================
    
    typedef struct _tTriangle
    {
        
        tMempool mempool;
        // Underlying phasor
        float phase;
        float inc,freq;
        int oct;
        float w;
    } _tTriangle;
    
    typedef _tTriangle* tTriangle;
 
    void    tTriangle_init          (tTriangle* const osc, LEAF* const leaf);
    void    tTriangle_initToPool    (tTriangle* const osc, tMempool* const mempool);
    void    tTriangle_free          (tTriangle* const osc);
    
    float   tTriangle_tick          (tTriangle* const osc);
    void    tTriangle_setFreq       (tTriangle* const osc, float freq);
 
    
    //==============================================================================
    
    typedef struct _tSquare
    {
        
        tMempool mempool;
        // Underlying phasor
        float phase;
        float inc,freq;
        int oct;
        float w;
    } _tSquare;
    
    typedef _tSquare* tSquare;
 
    void    tSquare_init        (tSquare* const osc, LEAF* const leaf);
    void    tSquare_initToPool  (tSquare* const osc, tMempool* const);
    void    tSquare_free        (tSquare* const osc);
 
    float   tSquare_tick        (tSquare* const osc);
    void    tSquare_setFreq     (tSquare* const osc, float freq);
    
    //==============================================================================
    
    typedef struct _tSawtooth
    {
        
        tMempool mempool;
        // Underlying phasor
        float phase;
        float inc,freq;
        int oct;
        float w;
    } _tSawtooth;
    
    typedef _tSawtooth* tSawtooth;
 
    void    tSawtooth_init          (tSawtooth* const osc, LEAF* const leaf);
    void    tSawtooth_initToPool    (tSawtooth* const osc, tMempool* const mempool);
    void    tSawtooth_free          (tSawtooth* const osc);
 
    float   tSawtooth_tick          (tSawtooth* const osc);
    void    tSawtooth_setFreq       (tSawtooth* const osc, float freq);
    
    //==============================================================================
    
    typedef struct _tPBTriangle
    {
        tMempool mempool;
        float phase;
        float inc,freq;
        float skew;
        float lastOut;
    } _tPBTriangle;
    
    typedef _tPBTriangle* tPBTriangle;
    
    void    tPBTriangle_init          (tPBTriangle* const osc, LEAF* const leaf);
    void    tPBTriangle_initToPool    (tPBTriangle* const osc, tMempool* const mempool);
    void    tPBTriangle_free          (tPBTriangle* const osc);
    
    float   tPBTriangle_tick          (tPBTriangle* const osc);
    void    tPBTriangle_setFreq       (tPBTriangle* const osc, float freq);
    void    tPBTriangle_setSkew       (tPBTriangle* const osc, float skew);
    
    //==============================================================================
    
    typedef struct _tPBPulse
    {
        tMempool mempool;
        float phase;
        float inc,freq;
        float width;
    } _tPBPulse;
    
    typedef _tPBPulse* tPBPulse;
    
    void    tPBPulse_init        (tPBPulse* const osc, LEAF* const leaf);
    void    tPBPulse_initToPool  (tPBPulse* const osc, tMempool* const);
    void    tPBPulse_free        (tPBPulse* const osc);
    
    float   tPBPulse_tick        (tPBPulse* const osc);
    void    tPBPulse_setFreq     (tPBPulse* const osc, float freq);
    void    tPBPulse_setWidth    (tPBPulse* const osc, float width);
    
    //==============================================================================
    
    typedef struct _tPBSaw
    {
        tMempool mempool;
        float phase;
        float inc,freq;
    } _tPBSaw;
    
    typedef _tPBSaw* tPBSaw;
    
    void    tPBSaw_init          (tPBSaw* const osc, LEAF* const leaf);
    void    tPBSaw_initToPool    (tPBSaw* const osc, tMempool* const mempool);
    void    tPBSaw_free          (tPBSaw* const osc);
    
    float   tPBSaw_tick          (tPBSaw* const osc);
    void    tPBSaw_setFreq       (tPBSaw* const osc, float freq);
    
    //==============================================================================
    
    typedef struct _tPhasor
    {
        
        tMempool mempool;
        float phase;
        float inc,freq;
        uint8_t phaseDidReset;
    } _tPhasor;
    
    typedef _tPhasor* tPhasor;
    
    void    tPhasor_init        (tPhasor* const osc, LEAF* const leaf);
    void    tPhasor_initToPool  (tPhasor* const osc, tMempool* const);
    void    tPhasor_free        (tPhasor* const osc);
    
    float   tPhasor_tick        (tPhasor* const osc);
    void    tPhasor_setFreq     (tPhasor* const osc, float freq);
    
    //==============================================================================
    
    /* tNoise. WhiteNoise, PinkNoise. */
    enum NoiseType
    {
        WhiteNoise, 
        PinkNoise, 
        NoiseTypeNil,
    };
    
    typedef enum NoiseType NoiseType;
    
    typedef struct _tNoise
    {
        
        tMempool mempool;
        NoiseType type;
        float pinkb0, pinkb1, pinkb2;
        float(*rand)(void);
    } _tNoise;
    
    typedef _tNoise* tNoise;
 
    void    tNoise_init         (tNoise* const noise, NoiseType type, LEAF* const leaf);
    void    tNoise_initToPool   (tNoise* const noise, NoiseType type, tMempool* const);
    void    tNoise_free         (tNoise* const noise);
    
    float   tNoise_tick         (tNoise* const noise);
    
    //==============================================================================
    
    enum NeuronMode
    {
        NeuronNormal, 
        NeuronTanh, 
        NeuronAaltoShaper, 
        NeuronModeNil
    };
    
    typedef enum NeuronMode NeuronMode;
    
    typedef struct _tNeuron
    {
        tMempool mempool;
        
        tPoleZero f;
        
        NeuronMode mode;
        
        float voltage, current;
        float timeStep;
        
        float alpha[3];
        float beta[3];
        float rate[3];
        float V[3];
        float P[3];
        float gK, gN, gL, C;
    } _tNeuron;
    
    typedef _tNeuron* tNeuron;
    
    void    tNeuron_init        (tNeuron* const neuron, LEAF* const leaf);
    void    tNeuron_initToPool  (tNeuron* const neuron, tMempool* const mempool);
    void    tNeuron_free        (tNeuron* const neuron);
    
    void    tNeuron_reset       (tNeuron* const neuron);
    float   tNeuron_tick        (tNeuron* const neuron);
    void    tNeuron_setMode     (tNeuron* const neuron, NeuronMode mode);
    void    tNeuron_setCurrent  (tNeuron* const neuron, float current);
    void    tNeuron_setK        (tNeuron* const neuron, float K);
    void    tNeuron_setL        (tNeuron* const neuron, float L);
    void    tNeuron_setN        (tNeuron* const neuron, float N);
    void    tNeuron_setC        (tNeuron* const neuron, float C);
    void    tNeuron_setV1       (tNeuron* const neuron, float V1);
    void    tNeuron_setV2       (tNeuron* const neuron, float V2);
    void    tNeuron_setV3       (tNeuron* const neuron, float V3);
    void    tNeuron_setTimeStep (tNeuron* const neuron, float timestep);
    
 
    
    //==============================================================================
    
    
#define FILLEN 256
    
    typedef struct _tMBPulse
    {
        
        tMempool mempool;
        float    out;
        float    amp;
        float    last_amp;
        float    freq;
        float    waveform;    // duty cycle, must be in [-1, 1]
        float    lastsyncin;
        float    sync;
        float    syncdir;
        int      softsync;
        float   _p, _w, _b, _x, _z;
        float   _f [FILLEN + STEP_DD_PULSE_LENGTH];
        int     _j, _k;
        bool    _init;
    } _tMBPulse;
    
    typedef _tMBPulse* tMBPulse;
    
    void tMBPulse_init(tMBPulse* const osc, LEAF* const leaf);
    void tMBPulse_initToPool(tMBPulse* const osc, tMempool* const mempool);
    void tMBPulse_free(tMBPulse* const osc);
    
    float tMBPulse_tick(tMBPulse* const osc);
    void tMBPulse_setFreq(tMBPulse* const osc, float f);
    void tMBPulse_setWidth(tMBPulse* const osc, float w);
    float tMBPulse_sync(tMBPulse* const osc, float sync);
    void tMBPulse_setSyncMode(tMBPulse* const osc, int hardOrSoft);
    
    typedef struct _tMBTriangle
    {
        
        tMempool mempool;
        float    out;
        float    amp;
        float    last_amp;
        float    freq;
        float    waveform;    // duty cycle, must be in [-1, 1]
        float    lastsyncin;
        float    sync;
        float    syncdir;
        int      softsync;
        float   _p, _w, _b, _z;
        float   _f [FILLEN + LONGEST_DD_PULSE_LENGTH];
        int     _j, _k;
        bool    _init;
    } _tMBTriangle;
    
    typedef _tMBTriangle* tMBTriangle;
    
    void tMBTriangle_init(tMBTriangle* const osc, LEAF* const leaf);
    void tMBTriangle_initToPool(tMBTriangle* const osc, tMempool* const mempool);
    void tMBTriangle_free(tMBTriangle* const osc);
    
    float tMBTriangle_tick(tMBTriangle* const osc);
    void tMBTriangle_setFreq(tMBTriangle* const osc, float f);
    void tMBTriangle_setWidth(tMBTriangle* const osc, float w);
    float tMBTriangle_sync(tMBTriangle* const osc, float sync);
    void tMBTriangle_setSyncMode(tMBTriangle* const osc, int hardOrSoft);
    
    
    typedef struct _tMBSaw
    {
        tMempool mempool;
        float    out;
        float    amp;
        float    last_amp;
        float    freq;
        float    lastsyncin;
        float    sync;
        float    syncdir;
        int      softsync;
        float   _p, _w, _z;
        float   _f [FILLEN + STEP_DD_PULSE_LENGTH];
        int     _j;
        bool    _init;
    } _tMBSaw;
    
    typedef _tMBSaw* tMBSaw;
    
    void tMBSaw_init(tMBSaw* const osc, LEAF* const leaf);
    void tMBSaw_initToPool(tMBSaw* const osc, tMempool* const mempool);
    void tMBSaw_free(tMBSaw* const osc);
    
    float tMBSaw_tick(tMBSaw* const osc);
    void tMBSaw_setFreq(tMBSaw* const osc, float f);
    float tMBSaw_sync(tMBSaw* const osc, float sync);
    void tMBSaw_setSyncMode(tMBSaw* const osc, int hardOrSoft);
 
    
#ifdef __cplusplus
}
#endif
 
#endif  // LEAF_OSCILLATORS_H_INCLUDED
 
//==============================================================================