synthbase.h

Go to the documentation of this file.

#ifndef __synthBase_h__
#define __synthBase_h__

#include <cmath>
#include <random>
#include <string>
#include <sstream>
#include <vector>
#include <stdint.h>
#include <memory>
#include <algorithm>
#include <map>

#include "synthstructures.h"
#include "synthlabparams.h"

#define _MATH_DEFINES_DEFINED

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    struct DMConfig
    {
        bool dm_build = false;
        bool dual_mono_filters = false;
        bool half_sample_set = false;
        bool reduced_unison_count = false;
        bool analog_fgn_filters = false;
        bool parameterSmoothing = true;
    };
    
    // ---------------------- SYNTH OBJECTS WITHOUT BASE CLASES --------------------------------------------- //
    //
    /* 
        These are simple, stand-alone objects or primary synth objects that perform intrinsically
        basic/fundamental synth operations. 
       
        Many of these are used as base classes for extended objects.

        These are NOT interfaces, which are defined in a separate section of this file.
    */
    //
    // ------------------------------------------------------------------------------------------------------- //

    class AudioBuffer
    {
    public:
        AudioBuffer() {}
        AudioBuffer(uint32_t _numInputChannels, uint32_t _numOutputChannels, uint32_t _blockSize);
        ~AudioBuffer();

        void init(uint32_t _numInputChannels, uint32_t _numOutputChannels, uint32_t _blockSize);
        void flushBuffers(); 

        float* getInputBuffer(uint32_t channel);
        float* getOutputBuffer(uint32_t channel);

        float** getInputBuffers() { return inputBuffer; }
        float** getOutputBuffers() { return outputBuffer; }

        uint32_t getInputChannelCount() { return numInputChannels; }
        uint32_t getOutputChannelCount() { return numOutputChannels; }

        uint32_t getBlockSize() { return blockSize; }
        uint32_t getSamplesInBlock() { return samplesInBlock; }
        void setSamplesInBlock(uint32_t _samplesInBlock);

    protected:
        void destroyInputBuffers();
        void destroyOutputBuffers();
        float** inputBuffer = nullptr;  
        float** outputBuffer = nullptr; 
        uint32_t numInputChannels = 1;
        uint32_t numOutputChannels = 1;
        uint32_t blockSize = 64;        
        uint32_t samplesInBlock = 64;   
    };


    class SynthClock
    {
    public:
        SynthClock() {}
        ~SynthClock() {}
        SynthClock& operator=(const SynthClock& params);

        void reset(double startValue = 0.0);
        void initWithClock(SynthClock& clock);

        void advanceClock(uint32_t renderInterval = 1);
        bool advanceWrapClock(uint32_t renderInterval = 1);
        bool wrapClock();

        void setFrequency(double _frequency_Hz, double _sampleRate);
        double getFrequency() { return frequency_Hz; }

        void addPhaseOffset(double _phaseOffset, bool wrap = true);
        void removePhaseOffset();

        void addFrequencyOffset(double _freqOffset);
        void removeFrequencyOffset();

        void saveState();
        void restoreState();

    public: // for fastest access
        double mcounter = 0.0;          
        double phaseInc = 0.0;          
        double phaseOffset = 0.0;       
        double freqOffset = 0.0;        
        double frequency_Hz = 0.0;      
        double sampleRate = 0.0;
        enum { MOD_COUNTER, PHASE_INC, PHASE_OFFSET, FREQUENCY_HZ, NUM_VARS };
        double state[NUM_VARS] = { 0.0, 0.0, 0.0, 0.0 };
    };
    
    class Timer
    {
    public:
        Timer() {}
        ~Timer() {}

        void resetTimer() { counter = 0; }      
        
        void setExpireSamples(uint32_t _targetValueInSamples) { targetValueInSamples = _targetValueInSamples; } 
        void setExpireMilliSec(double timeMSec, double sampleRate) { setExpireSamples( ((uint32_t)(sampleRate*(timeMSec / 1000.0))) ); } 
        
        uint32_t getExpireSamples() { return targetValueInSamples; } 

        bool timerExpired() { return (counter >= targetValueInSamples); } 

        void advanceTimer(uint32_t ticks = 1) { counter += ticks; }     
        uint32_t getTick() { return counter; }      

    protected:
        uint32_t counter = 0;
        uint32_t targetValueInSamples = 0;
    };

    class XFader
    {
    public:
        XFader() {} 
        XFader(uint32_t _xfadeTime_Samples);

        void reset();

        void setXFadeTime(uint32_t _xfadeTime_Samples);
        void startCrossfade() { running = true; }
        void stopCrossfade() { running = false; }
        bool isCrossfading() { return running; }

        // --- crossfade FROM A to B
        //     returns TRUE if the crossfade is still going (needs more samples)
        //             FALSE if the crossfade is finished (done)
        bool crossfade(XFadeType xfadeType, double inputA, double inputB, double& output);

    protected:
        uint32_t xfadeTime_Samples = 4410;  
        uint32_t xfadeTime_Counter = 0;     
        bool running = false;               
    };


    class XHoldFader
    {
    public:
        XHoldFader() {}
        ~XHoldFader() {}

        // --- fader functions
        void reset();

        inline void setXFadeTimeSamples(uint32_t _xfadeTimeSamples){ xfadeTime_Samples = _xfadeTimeSamples; }
        inline uint32_t getXFadeTimeSamples(){ return xfadeTime_Samples; }

        void setHoldTimeSamples(double _holdTimeSamples);
        inline double getHoldTimeSamples() { return holdTime_Samples; }

        XFadeData getCrossfadeData();

    protected:
        uint32_t xfadeTime_Samples = 4410;  
        uint32_t xfadeTime_Counter = 0;     
        uint32_t holdTime_Samples = 4410;   
        uint32_t holdTime_Counter = 0;      
        bool holding = false;               
    };


    class SlewLimiter
    {
    public:
        SlewLimiter() {}
        ~SlewLimiter() {}

        // --- slewing functions
        void reset() { z1 = 0; }        

        // --- slew value is:  0 <= slewvalue <= 0.9999
        void setSlewValue(double _g) { g = _g; }
        inline double doSlewLimiter(double input)
        {
            double output = input*(1.0 - g) + g*z1;
            z1 = output;
            return output;
        }

    protected:
        double g = 0;       
        double z1 = 0.0;    
    };


    class Synchronizer
    {
    public:
        Synchronizer() {}
        ~Synchronizer() {}

        bool reset(double _sampleRate, double startPhase, int32_t xfadeSamples = 16);

        bool setHardSyncFrequency(double hardSyncFrequency);
        SynthClock& getHardSyncClock() { return hardSyncClock; }
        SynthClock& getCrossFadeClock() { return crossFadeClock; }
        void startHardSync(SynthClock oscClock);
        double doHardSyncXFade(double inA, double inB);
        bool isProcessing() { return hardSyncFader.isCrossfading(); }

        void addPhaseOffset(double offset);
        void removePhaseOffset();

    protected:
        SynthClock hardSyncClock;   
        SynthClock crossFadeClock;  
        XFader hardSyncFader;       
        double hardSyncFrequency = 440.0;   
        double sampleRate = 44100.0;        
    };


    class RampModulator
    {
    public:
        RampModulator() {}
        ~RampModulator() {}

        bool startModulator(double startValue, double endValue, double modTime_mSec, double sampleRate);
        
        bool setModTime(double modTime_mSec, double sampleRate);

        double getNextModulationValue(uint32_t advanceClock = 1);

        void advanceClock(uint32_t ticks = 1);
        inline bool isActive() { return timerActive; } 

    protected:
        bool timerActive = false;   
        double timerInc = 0.0;      
        double countUpTimer = 0.0;  
        double modRange = 1.0;      
        double modStart = 0.0;      
        double modEnd = 1.0;        
    };

    class GlideModulator
    {
    public:
        GlideModulator() {}
        ~GlideModulator() {}

        bool startModulator(double startNote, double endNote, double glideTime_mSec, double sampleRate);
        
        bool setGlideTime(double glideTime_mSec, double sampleRate);
        
        double getNextModulationValue(uint32_t advanceClock = 1);

        void advanceClock(uint32_t ticks = 1);
        inline bool isActive() { return timerActive; }

    protected:
        bool timerActive = false;   
        double timerInc = 0.0;      
        double countDownTimer = 1.0;
        double glideRange = 1.0;    
    };

    class NoiseGenerator
    {
    public:
        NoiseGenerator() {}
        ~NoiseGenerator() {}

        std::default_random_engine defaultGeneratorEngine;

        double doGaussianWhiteNoise(double mean = 0.0, double variance = 1.0);
        double doWhiteNoise();
        double doPinkNoise();
        double doPinkingFilter(double white);

    protected:
        double bN[3] = { 0.0, 0.0, 0.0 };

        // --- another method of white noise, faster
        float g_fScale = 2.0f / 0xffffffff;
        int g_x1 = 0x67452301;
        int g_x2 = 0xefcdab89;
    };

    // ---------------------- SYNTH INTERFACE OBJECTS-------------------------------------------------------- //
    //
    /*
        These are pure abstrace interfaces to be used as base classes for the synth objects. These allow
        container objects to hold (shared) simple interface pointers, or the actual object pointers; all
        object interfacing is done through the common objec model interfaces here.
    */
    //
    // ------------------------------------------------------------------------------------------------------- //
    
    class IModulator
    {
    public:
        virtual double* getModArrayPtr(uint32_t index) = 0;

        virtual double getModValue(uint32_t index) = 0;
    
        virtual void setModValue(uint32_t index, double value) = 0;
    };

    // ---------------------- WAVETABLES --------------------------------------------------------- //
    class IWavetableSource
    {
    public:
        virtual void selectTable(uint32_t midiNoteNumber) = 0;
    
        virtual double readWaveTable(double normalizedPhaseInc) = 0;
    
        virtual uint32_t getWaveTableLength() = 0;


        virtual const char* getWaveformName() = 0;
        
        //\return the table index (unique) for faster iteration (OPTIONAL), or -1 if not found
        //*/
        //virtual int32_t getWaveformIndex() { return -1; }
    };

    class IWavetableDatabase
    {
    public:
        virtual IWavetableSource* getTableSource(const char* uniqueTableName) = 0;
        virtual IWavetableSource* getTableSource(uint32_t uniqueTableIndex) { return nullptr; }

        virtual bool addTableSource(const char* uniqueTableName, IWavetableSource* tableSource, uint32_t& uniqueIndex) = 0;

        virtual bool removeTableSource(const char* uniqueTableName) = 0;

        virtual bool clearTableSources() = 0;

        virtual int32_t getWaveformIndex(const char* uniqueTableName) { return -1; }
    };


    // ---------------------- PCM SAMPLES --------------------------------------------------------- //
    struct PCMSampleOutput
    {
        double audioOutput[STEREO_CHANNELS] = { 0.0, 0.0 }; 
        uint32_t numActiveChannels = 0; 
    };

    enum class SampleLoopMode { loop, sustain, oneShot };

    class IPCMSampleSource
    {
    public:
        virtual double selectSample(double oscFrequency) = 0;
    
        virtual PCMSampleOutput readSample(double& readIndex, double inc) = 0;

        virtual void setSampleLoopMode(SampleLoopMode _loopMode) = 0;

        virtual void deleteSamples() = 0;
                
        virtual uint32_t getValidSampleCount() = 0;

        virtual bool haveValidSamples() = 0;
    };

    class IPCMSampleDatabase
    {
    public:
        virtual IPCMSampleSource* getSampleSource(const char* uniqueSampleSetName) = 0;
    
        virtual bool addSampleSource(const char* uniqueSampleSetName, IPCMSampleSource* sampleSource) = 0;
        

        virtual bool removeSampleSource(const char* uniqueSampleSetName) = 0;
        
        virtual bool clearSampleSources() = 0;
    };

    class IMidiInputData
    {
    public:
        virtual uint32_t getGlobalMIDIData(uint32_t index) = 0;

        virtual uint32_t getCCMIDIData(uint32_t index) = 0;

        virtual uint32_t getAuxDAWDataUINT(uint32_t index) = 0;
        
        virtual float getAuxDAWDataFloat(uint32_t index) = 0;
    };

    enum { LPF1, LPF2, LPF3, LPF4, HPF1, HPF2, HPF3, HPF4, BPF2, BPF4, BSF2, BSF4, 
        APF1, APF2, ANM_LPF1, ANM_LPF2, ANM_LPF3, ANM_LPF4, NUM_FILTER_OUTPUTS };


    const double GUI_Q_MIN = 1.0;
    const double GUI_Q_MAX = 10.0;
    const double SVF_Q_SLOPE = (25.0 - 0.707) / (GUI_Q_MAX - GUI_Q_MIN);
    const double KORG35_Q_SLOPE = (2.0 - 0.707) / (GUI_Q_MAX - GUI_Q_MIN);
    const double MOOG_Q_SLOPE = (4.0 - 0.0) / (GUI_Q_MAX - GUI_Q_MIN);
    const double DIODE_Q_SLOPE = (17.0 - 0.0) / (GUI_Q_MAX - GUI_Q_MIN);
    const double HSYNC_MOD_SLOPE = 3.0;

    struct FilterOutput
    {
        FilterOutput() { clearData(); }
        double filter[NUM_FILTER_OUTPUTS];
        void clearData()
        {
            memset(&filter[0], 0, sizeof(double) * NUM_FILTER_OUTPUTS);
        }
    };


    class IFilterBase
    {
        virtual bool reset(double _sampleRate) = 0;

        virtual bool update() = 0;

        virtual FilterOutput* process(double xn) = 0;

        virtual void setFilterParams(double _fc, double _Q) = 0;
    };


    struct CoreProcData
    {
        IModulator* modulationInputs = nullptr; 
        IModulator* modulationOutputs = nullptr;

        float** inputBuffers = nullptr;     
        float** outputBuffers = nullptr;    
        float** fmBuffers = nullptr;        

        IWavetableDatabase* wavetableDatabase = nullptr;    
        IPCMSampleDatabase* sampleDatabase = nullptr;       
        IMidiInputData* midiInputData = nullptr;            
        void* moduleParameters = nullptr;                   
        const char* dllPath = nullptr;                      

        double sampleRate = 0.0;            
        uint32_t samplesToProcess = 64;     
        double unisonDetuneCents = 0.0;     
        double unisonStartPhase = 0.0;      

        double BPM = 120.0;         
        MIDINoteEvent noteEvent;    
    };

    // ----------------------------------- SYNTH OBJECTS ----------------------------------------------------- //
    //
    /*
        Fundamental objects that are used throughout SynthLab
    */
    //
    // ------------------------------------------------------------------------------------------------------- //

    struct SynthLabTableSet
    {
        // --- multi initializer construction
        SynthLabTableSet(const char* _waveformName, double _tableFs,
            uint32_t* _tableLengths, uint64_t** _ppHexTableSet, double _outputComp)
            : waveformName(_waveformName)
            , tableFs(_tableFs)
            , tableLengths(_tableLengths)
            , ppHexTableSet(_ppHexTableSet)
            , outputComp(_outputComp)
        { }

        // --- ptr to array of table lengths
        uint32_t* tableLengths = nullptr;   
        uint64_t** ppHexTableSet = nullptr; 

        // --- fs for this table set
        double tableFs = 44100.0;

        // --- output scaling factor (NOT volume or attenuation, waveform specific)
        double outputComp = 1.0; 

        // --- GUI string for this waveform
        const char* waveformName; 
    };

    // --- fwd decl
    class StaticTableSource;
    struct SynthLabBankSet
    {
        SynthLabBankSet(unsigned int _tablePtrsCount, SynthLabTableSet** _tablePtrs, std::string* _tableNames, StaticTableSource* _staticSources = nullptr)
            : tablePtrsCount(_tablePtrsCount)
            , tablePtrs(_tablePtrs)
            , tableNames(_tableNames)
            , staticSources(_staticSources) {}

        unsigned int tablePtrsCount = 32; 
        SynthLabTableSet** tablePtrs = nullptr; 
        std::string* tableNames = nullptr; 
        StaticTableSource* staticSources = nullptr;
    };
    
    const uint32_t kDefaultWaveTableLength = 256;

    struct StaticWavetable
    {
        StaticWavetable() {}

        StaticWavetable(const uint64_t* _table, uint32_t _tableLength, const char* _waveformName,
            double _outputComp = 1.0, double _tableFs = 44100)
            : uTable(_table)
            , tableLength(_tableLength)
            , waveformName(_waveformName)
            , outputComp(_outputComp)
            , tableFs(_tableFs)
        {
            wrapMask = tableLength - 1;
            dTable = nullptr;
        }

        StaticWavetable(const double* _table, uint32_t _tableLength, const char* _waveformName,
            double _outputComp = 1.0, double _tableFs = 44100)
            : dTable(_table)
            , tableLength(_tableLength)
            , waveformName(_waveformName)
            , outputComp(_outputComp)
            , tableFs(_tableFs)
        {
            wrapMask = tableLength - 1;
            uTable = nullptr;
        }

        // --- either/or static tables
        const uint64_t* uTable; 
        const double*   dTable; 
        uint32_t tableLength = kDefaultWaveTableLength; 
        uint32_t wrapMask = kDefaultWaveTableLength - 1; 
        double outputComp = 1.0;    
        double tableFs = 44100.0;
        const char* waveformName;   
    };

    struct DynamicWavetable
    {
        DynamicWavetable() {}

        DynamicWavetable(std::shared_ptr<double> _table, uint32_t _tableLength, const char* _waveformName,
            double _outputComp = 1.0, double _tableFs = 44100)
            : table(_table)
            , tableLength(_tableLength)
            , waveformName(_waveformName)
            , outputComp(_outputComp)
            , tableFs(_tableFs)
        {
            wrapMask = tableLength - 1;
        }

        std::shared_ptr<double> table = nullptr; 
        uint32_t tableLength = kDefaultWaveTableLength; 
        uint32_t wrapMask = kDefaultWaveTableLength - 1; 
        double outputComp = 1.0;    
        double tableFs = 44100.0;
        const char* waveformName;   
    };


    class WavetableDatabase : public IWavetableDatabase
    {
    public:
        WavetableDatabase() {}
        ~WavetableDatabase();

        virtual IWavetableSource* getTableSource(const char* uniqueTableName) override;
        virtual IWavetableSource* getTableSource(uint32_t uniqueTableIndex) override;
        virtual bool addTableSource(const char* uniqueTableName, IWavetableSource* tableSource, uint32_t& uniqueIndex) override;
        virtual bool removeTableSource(const char* uniqueTableName) override;
        virtual bool clearTableSources() override;
        virtual int32_t getWaveformIndex(const char* uniqueTableName) override;

        IWavetableDatabase* getIWavetableDatabase() { return this; }

    protected:
        typedef std::map < std::string, IWavetableSource* > wavetableSourceMap; 
        wavetableSourceMap wavetableDatabase;
        std::vector<IWavetableSource*> wavetableVector;
    };


    class PCMSampleDatabase : public IPCMSampleDatabase
    {
    public:
        PCMSampleDatabase() {}
        ~PCMSampleDatabase();

        virtual IPCMSampleSource* getSampleSource(const char* uniqueSampleSetName) override;
        virtual bool addSampleSource(const char* uniqueSampleSetName, IPCMSampleSource* sampleSource) override;
        virtual bool removeSampleSource(const char* uniqueSampleSetName) override;
        virtual bool clearSampleSources() override;

        IPCMSampleDatabase* getIPCMSampleDatabase() { return this; }

    protected:
        typedef std::map < std::string, IPCMSampleSource* >sampleSourceMap;
        sampleSourceMap sampleDatabase;
        std::vector<IPCMSampleSource*> sources;
    };

    class SynthProcessInfo : public AudioBuffer
    {
    public:
        SynthProcessInfo(){}
        SynthProcessInfo(uint32_t _numInputChannels, uint32_t _numOutputChannels, uint32_t _blockSize);
        ~SynthProcessInfo() {}

        void pushMidiEvent(midiEvent event);
        void clearMidiEvents();
        uint64_t getMidiEventCount();
        midiEvent* getMidiEvent(uint32_t index);

        double absoluteBufferTime_Sec = 0.0;            
        double BPM = 0.0;                               
        double timeSigNumerator = 0.0;                  
        uint32_t timeSigDenomintor = 0;                 

    protected:
        std::vector<midiEvent> midiEventQueue;          
    };

    class MidiInputData : public IMidiInputData
    {
    public:
        MidiInputData();
        ~MidiInputData() {}

        virtual uint32_t getGlobalMIDIData(uint32_t index);
        virtual uint32_t getCCMIDIData(uint32_t index);
        virtual uint32_t getAuxDAWDataUINT(uint32_t index);
        virtual float getAuxDAWDataFloat(uint32_t index);
        
        void setGlobalMIDIData(uint32_t index, uint32_t value);
        void setCCMIDIData(uint32_t index, uint32_t value);
        void setAuxDAWDataUINT(uint32_t index, uint32_t value);
        void setAuxDAWDataFloat(uint32_t index, float value);

        IMidiInputData* getIMIDIInputData() { return this; }

    protected:
        // --- shared MIDI tables, via IMIDIData
        uint32_t globalMIDIData[kNumMIDIGlobals];   
        uint32_t ccMIDIData[kNumMIDICCs];           
        double auxData[kNumMIDIAuxes];              
    };

    class Modulators : public IModulator
    {
    public:
        Modulators();

        virtual double* getModArrayPtr(uint32_t index);
        virtual double getModValue(uint32_t index);
        virtual void setModValue(uint32_t index, double value);

        // --- fast clearing of array
        void clear();

        void initInputValues();

        IModulator* getModulatorPtr() { return this; }

    protected:
        // --- array of modulation inputs or outputs
        double modArray[MAX_MODULATION_CHANNELS]; 
    };

    class ModuleCore
    {
    public:
        ModuleCore() { glideModulator.reset(new(GlideModulator)); }
        virtual ~ModuleCore() { }

        virtual bool reset(CoreProcData& processInfo) = 0;
        virtual bool update(CoreProcData& processInfo) = 0;
        virtual bool render(CoreProcData& processInfo) = 0;
        virtual bool doNoteOn(CoreProcData& processInfo) = 0;
        virtual bool doNoteOff(CoreProcData& processInfo) = 0;

        virtual int32_t getState() { return -1; }
        virtual bool shutdown() { return false; }
        virtual void setSustainOverride(bool sustain) { return; }
        virtual void setStandAloneMode(bool b) { standAloneMode = b; }

        bool startGlideModulation(GlideInfo& glideInfo) {
            return glideModulator->startModulator(glideInfo.startMIDINote, glideInfo.endMIDINote, glideInfo.glideTime_mSec, glideInfo.sampleRate);
        }

        uint32_t getModuleType() { return moduleType; }
        const char* getModuleName() { return moduleName; }
        void* getModuleHandle() { return moduleHandle; }
        void  setModuleHandle(void* handle) { moduleHandle = handle; }
        uint32_t getModuleIndex() { return moduleIndex; }
        void  setModuleIndex(uint32_t index) { moduleIndex = index; }
        int32_t getPreferredModuleIndex() { return preferredIndex; }
        void  setPreferredModuleIndex(uint32_t index) { preferredIndex = index; }

        ModuleCoreData& getModuleData() { return coreData; }

    protected:
        // --- module
        uint32_t moduleType = UNDEFINED_MODULE; 
        const char* moduleName = nullptr;       
        void* moduleHandle = nullptr;           
        uint32_t moduleIndex = 0;               
        int32_t preferredIndex = -1;            
        ModuleCoreData coreData;                
        bool standAloneMode = false;            
        std::unique_ptr<GlideModulator> glideModulator; 
    };

    class SynthModule
    {
    public:
        SynthModule(std::shared_ptr<MidiInputData> _midiInputData);
        virtual ~SynthModule();

        virtual bool reset(double _sampleRate) = 0;
        virtual bool update() = 0;
        virtual bool render(uint32_t samplesToProcess = 1) = 0;
        virtual bool doNoteOn(MIDINoteEvent& noteEvent) = 0;
        virtual bool doNoteOff(MIDINoteEvent& noteEvent) = 0;

        virtual bool initialize(const char* _dllDirectory) { dllDirectory = _dllDirectory;  return true; }

        virtual int32_t getState() { return -1; }
        virtual bool shutdown() { return false; }

        virtual bool startGlideModulation(GlideInfo& glideInfo);

        std::shared_ptr<Modulators> getModulationInput() { return modulationInput; }
        std::shared_ptr<Modulators> getModulationOutput() { return modulationOutput; }

        std::shared_ptr<AudioBuffer> getAudioBuffers() { return audioBuffers; }

        void setUnisonMode(double _unisonDetuneCents, double _unisonStarPhase) {
            unisonDetuneCents = _unisonDetuneCents; unisonStartPhase = _unisonStarPhase;
        }

        void setFMBuffer(std::shared_ptr<AudioBuffer> pmBuffer) { fmBuffer = pmBuffer; }
        void clearFMBuffer() { fmBuffer = nullptr; }

        virtual bool getModuleStrings(std::vector<std::string>& moduleStrings, std::string ignoreStr = "");
        virtual bool getModuleStrings(uint32_t coreIndex, std::vector<std::string>& moduleStrings, std::string ignoreStr);
        virtual bool getAllModuleStrings(std::vector<std::string>& moduleStrings, std::string ignoreStr);
        virtual bool getModKnobStrings(std::vector<std::string>& modKnobStrings);
        virtual bool getModKnobStrings(uint32_t coreIndex, std::vector<std::string>& modKnobStrings);
        virtual bool getModuleCoreStrings(std::vector<std::string>& moduleCoreStrings);
        virtual bool addModuleCore(std::shared_ptr<ModuleCore> core);
        virtual uint32_t getSelectedCoreIndex();
        virtual bool selectModuleCore(uint32_t index);
        virtual bool selectDefaultModuleCore();
        virtual void packCores();
        virtual bool clearModuleCores();
        virtual void setStandAloneMode(bool b);

    protected:
        std::shared_ptr<Modulators> modulationInput = std::make_shared<Modulators>();

        std::shared_ptr<Modulators> modulationOutput = std::make_shared<Modulators>();

        std::shared_ptr<MidiInputData> midiInputData = nullptr;

        std::shared_ptr<AudioBuffer> audioBuffers = nullptr;

        std::unique_ptr<GlideModulator> glideModulator;

        std::shared_ptr<AudioBuffer> fmBuffer = nullptr;

        std::shared_ptr<ModuleCore> moduleCores[NUM_MODULE_CORES];
        std::shared_ptr<ModuleCore> selectedCore = nullptr;

        ModuleCoreData moduleData;  

        double unisonDetuneCents = 0.0;
        double unisonStartPhase = 0.0;
        bool standAloneMode = false;

        CoreProcData coreProcessData;
        std::string dllDirectory;
    };


    // ----------------------------------- FX-FILTERING OBJECTS ---------------------------------------------- //
    //
    /*
        Objects taken primarily from Will Pirkle's FX book (2nd edition)
        Most objects are heavily detailed in the book Designing Audio Effects Plugins in C++ 2nd Ed and
        at http://aspikplugins.com/sdkdocs/html/index.html
    */
    //
    // ------------------------------------------------------------------------------------------------------- //
    
    inline double doLinearInterp(double y1, double y2, double fractional_X)
    {
        // --- check invalid condition
        if (fractional_X >= 1.0) return y2;

        // --- use weighted sum method of interpolating
        return fractional_X*y2 + (1.0 - fractional_X)*y1;
    }

    template <typename T>
    class CircularBuffer
    {
    public:
        CircularBuffer() {}     /* C-TOR */
        ~CircularBuffer() {}    /* D-TOR */

        void flushBuffer() { memset(&buffer[0], 0, bufferLength * sizeof(T)); }

        void createCircularBuffer(uint32_t _bufferLength)
        {
            // --- find nearest power of 2 for buffer, and create
            createCircularBufferPowerOfTwo((uint32_t)(pow(2, ceil(log(_bufferLength) / log(2)))));
        }

        void createCircularBufferPowerOfTwo(uint32_t _bufferLengthPowerOfTwo)
        {
            // --- reset to top
            writeIndex = 0;

            // --- find nearest power of 2 for buffer, save it as bufferLength
            bufferLength = _bufferLengthPowerOfTwo;

            // --- save (bufferLength - 1) for use as wrapping mask
            wrapMask = bufferLength - 1;

            // --- create new buffer
            buffer.reset(new T[bufferLength]);

            // --- flush buffer
            flushBuffer();
        }

        void writeBuffer(T input)
        {
            // --- write and increment index counter
            buffer[writeIndex++] = input;

            // --- wrap if index > bufferlength - 1
            writeIndex &= wrapMask;
        }

        T readBuffer(int32_t delayInSamples)//, bool readBeforeWrite = true)
        {
            // --- subtract to make read index
            //     note: -1 here is because we read-before-write,
            //           so the *last* write location is what we use for the calculation
            int32_t readIndex = (writeIndex - 1) - delayInSamples;

            // --- autowrap index
            readIndex &= wrapMask;

            // --- read it
            return buffer[readIndex];
        }

        T readBuffer(double delayInFractionalSamples)
        {
            // --- truncate delayInFractionalSamples and read the int part
            int32_t intPart = (int32_t)delayInFractionalSamples;

            T y1 = readBuffer(intPart);

            // --- if no interpolation, just return value
            if (!interpolate) return y1;

            // --- else do interpolation
            //
            int readIndexNext = intPart + 1;

            // --- autowrap index
            readIndexNext &= wrapMask;

            // --- read the sample at n+1 (one sample OLDER)
            T y2 = readBuffer(readIndexNext);

            // --- get fractional part
            double fraction = delayInFractionalSamples - intPart;

            // --- do the interpolation (you could try different types here)
            return doLinearInterp(y1, y2, fraction);
        }

        void setInterpolate(bool b) { interpolate = b; }

    private:
        std::unique_ptr<T[]> buffer = nullptr;  
        uint32_t writeIndex = 0;        
        uint32_t bufferLength = 1024;   
        uint32_t wrapMask = 1023;       
        bool interpolate = true;            
    };

    class DelayLine
    {
    public:
        DelayLine(void) {}  /* C-TOR */
        ~DelayLine(void) {} /* D-TOR */

    public:
        void clear(){ delayBuffer.flushBuffer();}

        void reset(double _sampleRate, double minimumPitch = MIDI_NOTE_0_FREQ) // 8.176 = MIDI note 0
        {
            // ---
            delayBuffer.createCircularBuffer( ((uint32_t)(_sampleRate / minimumPitch)) );
            clear();
        }

        void setDelayInSamples(double _delaySamples)
        {
            delaySamples = _delaySamples;
        }

        void writeDelay(double xn)
        {
            // --- write to delay buffer
            delayBuffer.writeBuffer(xn);
        }

        double readDelay()
        {
            double yn = delayBuffer.readBuffer(delaySamples);
            return yn;
        }

    private:
        // --- our only variable
        double delaySamples = 0; 

        // --- delay buffer of doubles
        CircularBuffer<double> delayBuffer; 
    };


    struct BQCoeffs
    {
        // --- filter coefficients
        double coeff[7] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
    };

    class BQAudioFilter
    {
    public:
        BQAudioFilter(void) {}  /* C-TOR */
        ~BQAudioFilter(void) {} /* D-TOR */

    public:
        void reset(){ flushDelays(); }

        void flushDelays()
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;
        }

        void setCoeffs(BQCoeffs& _coeffs) {
            bq = _coeffs;
        }

        void copyCoeffs(BQAudioFilter& destination) {
            destination.setCoeffs(bq);
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = bq.coeff[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = bq.coeff[a1] * xn - bq.coeff[b1] * yn + state[xz2];
            state[xz2] = bq.coeff[a2] * xn - bq.coeff[b2] * yn;
            return xn*bq.coeff[d0] + yn*bq.coeff[c0];
        }

    protected:
        enum { a0, a1, a2, b1, b2, c0, d0 };
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 }; 
        BQCoeffs bq;    
    };


    class FracDelayAPF
    {
    public:
        FracDelayAPF(void) {}   /* C-TOR */
        ~FracDelayAPF(void) {}  /* D-TOR */

    public:
        void reset()
        {
            state[0] = 0.0;
            state[1] = 0.0;
        }

        void setAlpha(double _alpha)
        {
            alpha = _alpha;
        }

        double processAudioSample(double xn)
        {
            double yn = xn*alpha + state[0] - alpha*state[1];
            state[0] = xn;
            state[1] = yn;
            return yn;
        }

    private:
        // --- our only coefficient
        double alpha = 0.0; 
        double state[2] = { 0.0, 0.0 }; 
    };


    class ResLoopFilter
    {
    public:
        ResLoopFilter(void) {}  /* C-TOR */
        ~ResLoopFilter(void) {} /* D-TOR */

    public:
        void reset()
        {
            state[0] = 0.0;
            state[1] = 0.0;
        }

        double processAudioSample(double xn)
        {
            double yn = 0.5*xn + 0.5*state[0];
            state[0] = xn;
            return yn;
        }

    private:
        double state[2] = { 0.0, 0.0 }; 
    };


    class DCRemovalFilter
    {
    public:
        DCRemovalFilter(void) {}    /* C-TOR */
        ~DCRemovalFilter(void) {}   /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;

            // --- see book for formulae
            double theta_c = kTwoPi*fc / sampleRate;
            double gamma = cos(theta_c) / (1.0 + sin(theta_c));

            // --- update coeffs
            coeffs[a0] = (1.0 + gamma) / 2.0;
            coeffs[a1] = -(1.0 + gamma) / 2.0;
            coeffs[a2] = 0.0;
            coeffs[b1] = -gamma;
            coeffs[b2] = 0.0;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };       
        enum { a0, a1, a2, b1, b2 };
        double coeffs[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 }; 
        double fc = 1.0;                                
        double sampleRate = 1.0;
    };


    class TinyBPF
    {
    public:
        TinyBPF(void) {}    /* C-TOR */
        ~TinyBPF(void) {}   /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double _fc, double _Q)
        {
            if (fc == _fc && Q == _Q)
            return;

            fc = _fc;
            Q = _Q;

            // --- see book for formulae
            double K = tan(kPi*fc / sampleRate);
            double delta = K*K*Q + K + Q;

            // --- update coeffs
            coeffs[a0] = K / delta;;
            coeffs[a1] = 0.0;
            coeffs[a2] = -K / delta;
            coeffs[b1] = 2.0*Q*(K*K - 1) / delta;
            coeffs[b2] = (K*K*Q - K + Q) / delta;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2 };
        double coeffs[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 5.0;
        double Q = 0.5;
        double sampleRate = 1.0;
    };

    class LP2Filter
    {
    public:
        LP2Filter(void) {}  /* C-TOR */
        ~LP2Filter(void) {} /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            sampleRate = _sampleRate;
            clear();
        }

        void clear()
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;
        }

        void setParameters(double _fc, double _Q)
        {
            if (fc == _fc && Q == _Q)
                return;

            fc = _fc;
            Q = _Q;

            // --- see book for formulae
            double theta_c = 2.0*kPi*fc / sampleRate;
            double d = 1.0 / Q;
            double betaNumerator = 1.0 - ((d / 2.0)*(sin(theta_c)));
            double betaDenominator = 1.0 + ((d / 2.0)*(sin(theta_c)));

            double beta = 0.5*(betaNumerator / betaDenominator);
            double gamma = (0.5 + beta)*(cos(theta_c));
            double alpha = (0.5 + beta - gamma) / 2.0;

            // --- update coeffs
            coeffs[a0] = alpha;
            coeffs[a1] = 2.0*alpha;
            coeffs[a2] = alpha;
            coeffs[b1] = -2.0*gamma;
            coeffs[b2] = 2.0*beta;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2 };
        double coeffs[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 5.0;
        double Q = 0.5;
        double sampleRate = 1.0;
    };


    class HP2Filter
    {
    public:
        HP2Filter(void) {}  /* C-TOR */
        ~HP2Filter(void) {} /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double _fc, double _Q)
        {
            if (fc == _fc && Q == _Q)
                return;

            fc = _fc;
            Q = _Q;

            double theta_c = kTwoPi*fc / sampleRate;
            double d = 1.0 / Q;

            // --- see book for formulae
            double betaNumerator = 1.0 - ((d / 2.0)*(sin(theta_c)));
            double betaDenominator = 1.0 + ((d / 2.0)*(sin(theta_c)));

            double beta = 0.5*(betaNumerator / betaDenominator);
            double gamma = (0.5 + beta)*(cos(theta_c));
            double alpha = (0.5 + beta + gamma) / 2.0;

            // --- update coeffs
            coeffs[a0] = alpha;
            coeffs[a1] = -2.0*alpha;
            coeffs[a2] = alpha;
            coeffs[b1] = -2.0*gamma;
            coeffs[b2] = 2.0*beta;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2 };
        double coeffs[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 5.0;
        double Q = 0.5;
        double sampleRate = 1.0;
    };

    class TinyReson
    {
    public:
        TinyReson(void) {}  /* C-TOR */
        ~TinyReson(void) {} /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for(uint32_t i=0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double _fc, double _Q)
        {
            if (fc == _fc && Q == _Q)
                return;

            fc = _fc;
            Q = _Q;

            double theta_c = kTwoPi*fc / sampleRate;
            double BW = fc / Q;
            coeffs[b2] = exp(-2.0*kPi*(BW / sampleRate));
            coeffs[b1] = ((-4.0*coeffs[b2]) / (1.0 + coeffs[b2]))*cos(theta_c);
            coeffs[a0] = 1.0 - pow(coeffs[b2], 0.5);
            coeffs[a2] = -coeffs[a0];
        }

        double processAudioSample(double xn, double loss = 1.0)
        {
            // --- direct
            double yn = coeffs[a0]*xn + coeffs[a2]*state[xz2] - coeffs[b1]*state[yz1] -coeffs[b2]*state[yz2];
            state[xz2] = state[xz1];
            state[xz1] = xn;
            state[yz2] = state[yz1];
            state[yz1] = yn * loss;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a2, b1, b2 };
        double coeffs[4] = { 0.0, 0.0, 0.0, 0.0 };
        double fc = 440.0;
        double Q = 0.5;
        double sampleRate = 1.0;
    };

    class LowShelfFilter
    {
    public:
        LowShelfFilter(void) {} /* C-TOR */
        ~LowShelfFilter(void) {}    /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double shelfFreq, double boostCut_dB)
        {
            double theta_c = kTwoPi*shelfFreq / sampleRate;
            double mu = pow(10.0, boostCut_dB / 20.0);

            double beta = 4.0 / (1.0 + mu);
            double delta = beta*tan(theta_c / 2.0);
            double gamma = (1.0 - delta) / (1.0 + delta);

            // --- update coeffs
            coeffs[a0] = (1.0 - gamma) / 2.0;
            coeffs[a1] = (1.0 - gamma) / 2.0;
            coeffs[a2] = 0.0;
            coeffs[b1] = -gamma;
            coeffs[b2] = 0.0;

            coeffs[c0] = mu - 1.0;
            coeffs[d0] = 1.0;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return xn*coeffs[d0] + yn*coeffs[c0];
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2, c0, d0 };
        double coeffs[7] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 440.0;
        double boostCut_dB = 0.0;
        double sampleRate = 1.0;
    };


    class HighShelfFilter
    {
    public:
        HighShelfFilter(void) {}    /* C-TOR */
        ~HighShelfFilter(void) {}   /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double shelfFreq, double boostCut_dB)
        {
            double theta_c = kTwoPi*shelfFreq / sampleRate;
            double mu = pow(10.0, boostCut_dB / 20.0);

            double beta = (1.0 + mu) / 4.0;
            double delta = beta*tan(theta_c / 2.0);
            double gamma = (1.0 - delta) / (1.0 + delta);

            coeffs[a0] = (1.0 + gamma) / 2.0;
            coeffs[a1] = -coeffs[a0];
            coeffs[a2] = 0.0;
            coeffs[b1] = -gamma;
            coeffs[b2] = 0.0;

            coeffs[c0] = mu - 1.0;
            coeffs[d0] = 1.0;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return xn*coeffs[d0] + yn*coeffs[c0];
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2, c0, d0 };
        double coeffs[7] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 440.0;
        double boostCut_dB = 0.0;
        double sampleRate = 1.0;
    };

    class ParametricFilter
    {
    public:
        ParametricFilter(void) {}   /* C-TOR */
        ~ParametricFilter(void) {}  /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;

            sampleRate = _sampleRate;
        }

        void setParameters(double _fc, double _Q, double _boostCut_dB)
        {
            if (fc == _fc && Q == _Q && boostCut_dB == _boostCut_dB)
                return;
            fc = _fc;
            Q = _Q;
            boostCut_dB = _boostCut_dB;

            // --- see book for formulae
            double theta_c = kTwoPi*fc / sampleRate;
            double mu = pow(10.0, boostCut_dB / 20.0);

            // --- clamp to 0.95 pi/2 (you can experiment with this)
            double tanArg = theta_c / (2.0 * Q);
            if (tanArg >= 0.95*kPi / 2.0) tanArg = 0.95*kPi / 2.0;

            // --- intermediate variables (you can condense this if you wish)
            double zeta = 4.0 / (1.0 + mu);
            double betaNumerator = 1.0 - zeta*tan(tanArg);
            double betaDenominator = 1.0 + zeta*tan(tanArg);

            double beta = 0.5*(betaNumerator / betaDenominator);
            double gamma = (0.5 + beta)*(cos(theta_c));
            double alpha = (0.5 - beta);

            // --- update coeffs
            coeffs[a0] = alpha;
            coeffs[a1] = 0.0;
            coeffs[a2] = -alpha;
            coeffs[b1] = -2.0*gamma;
            coeffs[b2] = 2.0*beta;

            coeffs[c0] = mu - 1.0;
            coeffs[d0] = 1.0;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return xn*coeffs[d0] + yn*coeffs[c0];
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2, c0, d0 };
        double coeffs[7] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 0.0;
        double Q = 0.0;
        double boostCut_dB = 0.0;
        double sampleRate = 1.0;
    };


    class LP1PFilter
    {
    public:
        LP1PFilter(void) {} /* C-TOR */
        ~LP1PFilter(void) {}    /* D-TOR */

    public:
        void reset(double _sampleRate)
        {
            clear();
            sampleRate = _sampleRate;
        }

        void clear()
        {
            for (uint32_t i = 0; i<numStates; i++)
                state[i] = 0.0;
        }

        void setParameters(double _fc)
        {
            if (fc == _fc)
                return;

            fc = _fc;

            // --- see book for formulae
            double theta_c = 2.0*kPi*fc / sampleRate;
            double gamma = 2.0 - cos(theta_c);

            double filter_b1 = pow((gamma*gamma - 1.0), 0.5) - gamma;
            double filter_a0 = 1.0 + filter_b1;

            // --- update coeffs
            coeffs[a0] = filter_a0;
            coeffs[a1] = 0.0;
            coeffs[a2] = 0.0;
            coeffs[b1] = filter_b1;
            coeffs[b2] = 0.0;
        }

        double processAudioSample(double xn)
        {
            // --- transposed canonical
            double yn = coeffs[a0] * xn + state[xz1];

            // --- shuffle/update
            state[xz1] = coeffs[a1] * xn - coeffs[b1] * yn + state[xz2];
            state[xz2] = coeffs[a2] * xn - coeffs[b2] * yn;
            return yn;
        }

    protected:
        enum { xz1, xz2, yz1, yz2, numStates };
        double state[4] = { 0.0, 0.0, 0.0, 0.0 };
        enum { a0, a1, a2, b1, b2 };
        double coeffs[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
        double fc = 5.0;
        double Q = 0.5;
        double sampleRate = 1.0;
    };

    enum class PluckFilterType {kPluck, kPluckAndBridge, kPickup, kPluckAndPickup, kBridge, kPluckPickupBridge};


    class PluckPosFilter
    {
    public:
        PluckPosFilter(void) {} /* C-TOR */
        ~PluckPosFilter(void) {}    /* D-TOR */

    public:
        void clear()
        {
            combDelay.clear();
            bridgeIntegrator.clear();
        }

        void reset(double _sampleRate, double minimumPitch = MIDI_NOTE_0_FREQ) // 8.176 = MIDI note 0
        {
            // ---
            combDelay.reset(_sampleRate, minimumPitch);
            combDelay.clear();

            pickupFilter.reset(_sampleRate);
            pickupFilter.setParameters(2500.0, 1.5); // guitar pickup settings

            bridgeIntegrator.reset(_sampleRate);
            bridgeIntegrator.setParameters(20.0); // lower than the lowest note to synthesize which is note 0
        }

        void setDelayInSamples(double _delaySamples)
        {
            // --- the (-1) is needed here because of the way the circular buffer counts samples for read/write
            combDelay.setDelayInSamples(_delaySamples - 1);
        }

        double processAudioSample(double xn, PluckFilterType type)
        {
            if (type == PluckFilterType::kBridge)
                return 12.0*bridgeIntegrator.processAudioSample(xn);

            if (type == PluckFilterType::kPickup)
                return pickupFilter.processAudioSample(xn);

            // --- pluck position
            double yn = combDelay.readDelay();
            combDelay.writeDelay(xn);

            // --- output pluck
            double pluck = 0.5*(xn - yn);
            if (type == PluckFilterType::kPluck)
                return pluck;

            // --- pluck and pickup
            if (type == PluckFilterType::kPluckAndPickup)
                return pickupFilter.processAudioSample(pluck);

            // --- pluck and bridge
            if (type == PluckFilterType::kPluckAndBridge)
                return 12.0*bridgeIntegrator.processAudioSample(pluck);

            if (type == PluckFilterType::kPluckPickupBridge)
            {
                double pu = 2.0*pickupFilter.processAudioSample(pluck);
                return 12.0*bridgeIntegrator.processAudioSample(pu);
            }


            return xn; // should never get here
        }

    protected:
        DelayLine combDelay; 
        LP1PFilter bridgeIntegrator; 
        LP2Filter pickupFilter; 
    };

}// namespace

#endif /* defined(__synthDefs_h__) */