sequencer.h

Go to the documentation of this file.

#pragma once

#include "synthbase.h"
#include "synthfunctions.h"


// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    template <typename T>
    class JumpTable
    {
    public:
        JumpTable() {}      
        ~JumpTable() {}     

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

        void reset() { readIndex = 0; }

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

        void createCircularBufferPowerOfTwo(unsigned int _bufferLengthPowerOfTwo)
        {
            // --- reset to top
            readIndex = 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(uint32_t index, T input)
        {
            // --- write and increment index counter
            buffer[index] = input;
        }

        T readBufferCircular()
        {
            T output = buffer[readIndex++];

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

            // --- read it
            return output;
        }

        T readBuffer(int index)
        {
            // --- read it
            return buffer[index];
        }


    private:
        std::unique_ptr<T[]> buffer = nullptr;  
        unsigned int readIndex = 0;         
        unsigned int bufferLength = 1024;   
        unsigned int wrapMask = 1023;       
    };
    
    struct LaneStep
    {
        LaneStep() {}
        LaneStep& operator=(const LaneStep& aLane)  // need this override for collections to work
        {
            if (this == &aLane)
                return *this;

            stepValue = aLane.stepValue;
            stepDurationSamples = aLane.stepDurationSamples;
            xfadeDurationSamples = aLane.xfadeDurationSamples;
            stepDurationSamplesRunning = aLane.stepDurationSamplesRunning;
            xfadeDurationSamplesRunning = aLane.xfadeDurationSamplesRunning;

            stepDurationNote = aLane.stepDurationNote;
            xfadeDurationNote = aLane.xfadeDurationNote;

            probability_Pct = aLane.probability_Pct;
            stepMode = aLane.stepMode;
            isNULLStep = aLane.isNULLStep;
            nextStepIndex = aLane.nextStepIndex;
            previousStepIndex = aLane.previousStepIndex;

            return *this;
        }

        void initStepTiming()
        {
            stepDurationSamplesRunning = stepDurationSamples;
            xfadeDurationSamplesRunning = xfadeDurationSamples;
        }

        void updateStepDurationSamples(uint32_t _stepDurationSamples)
        {
            stepDurationSamples = _stepDurationSamples;
        }

        void updateStepXFadeSamples(uint32_t _xfadeDurationSamples)
        {
            xfadeDurationSamples = _xfadeDurationSamples;
        }

        // --- see korg wavestate docs -----------------------
        //     these are all equivalent values and need to be 
        //     updated together
        uint32_t stepDurationSamplesRunning = 0;    
        double stepDurationMilliSec = 0.0;          
        NoteDuration stepDurationNote = NoteDuration::kQuarter;
        // --------------------------------------------------- 

        // --- XFADE Time
        //     cannot exceed 2X duration of shortest step
        uint32_t xfadeDurationSamplesRunning = 0;   
        double xfadeDurationMilliSec = 0.0;         
        NoteDuration xfadeDurationNote = NoteDuration::kQuarter;
        // --------------------------------------------------- 

        // --- probability %
        double probability_Pct = 100.0; 

        int32_t getNextStepIndex() { return nextStepIndex; }                                
        void setNextStepIndex(int32_t _nextStepIndex) { nextStepIndex = _nextStepIndex; }   

        int32_t getPreviousStepIndex() { return previousStepIndex; }                                        
        void setPreviousStepIndex(int32_t _previousStepIndex) { previousStepIndex = _previousStepIndex; }   

        double getStepValue() { return stepValue; }     
        void setStepValue(double _stepValue) { stepValue = _stepValue; }

        void updateStepProbability()
        {
            double wn = noiseGen.doWhiteNoise();
            wn = unipolar(wn);
            double probPct = wn * 100.0;

            if(probability_Pct < 100.0)
                int t = 0;

            if (probPct <= probability_Pct)
                setNULLStep(false);
            else
                setNULLStep(true);
        }

        bool getIsNULLStep() { return isNULLStep; }
        void setNULLStep(bool _isNULLStep) { isNULLStep = _isNULLStep; /*stepValue  = 0.0;*/ }

    protected:
        uint32_t stepDurationSamples = 0;   
        uint32_t xfadeDurationSamples = 0;  
        int32_t nextStepIndex = -1;         
        int32_t previousStepIndex = -1;     
        double stepValue = 0.0;             
        uint32_t stepMode = 0;              
        bool isNULLStep = false;            
        NoiseGenerator noiseGen;            
    };
    
    class Lane
    {
    public:
        Lane(){
            resetJumpTable();   
        }
        ~Lane() {}              

        void resetJumpTable()   
        {
            for (uint32_t i = 0; i < MAX_SEQ_STEPS; i++)
                jumpTable[i] = i;
        }

        // --- https://stackoverflow.com/questions/21877904/getting-random-unique-integers-in-c
        //
        
        inline void shuffleJumpTable() 
        {           
            std::vector<int> v = { jumpTable[0], jumpTable[1], jumpTable[2], jumpTable[3], jumpTable[4], jumpTable[5], jumpTable[6], jumpTable[7] };
            std::random_device rd;
            std::mt19937 g(rd());
            std::shuffle(v.begin(), v.end(), g);
            for (uint32_t i = 0; i < MAX_SEQ_STEPS; i++)
            {
                jumpTable[i] = v[i];
            }
        }

        inline void updateLaneLoopPoints()
        {
            for (uint32_t i = 0; i < MAX_SEQ_STEPS; i++)
            {
                if (i == startPoint)
                    laneStep[getJumpTableValue(i)].setPreviousStepIndex(getJumpTableValue(endPoint));
                else
                    laneStep[getJumpTableValue(i)].setPreviousStepIndex(-1);

                if (i == endPoint)
                    laneStep[getJumpTableValue(i)].setNextStepIndex(getJumpTableValue(startPoint));
                else
                    laneStep[getJumpTableValue(i)].setNextStepIndex(-1);
            }
        }

        void initStepTiming(uint32_t stepIndex)
        {
            laneStep[stepIndex].initStepTiming();
        }

        void initCurrentStep(uint32_t jumpIndex)
        {
            jumpTableIndex = jumpIndex;
            currentStepIndex = jumpTable[jumpTableIndex];
            initStepTiming(currentStepIndex);
            currentStep = laneStep[currentStepIndex];
            currentStepValue = currentStep.getStepValue();
        }

        void initNextStep(uint32_t jumpIndex, uint32_t loopDirectionIndex, bool applyProbability = false)
        {
            bool forwardBackward = loopDirectionIndex == enumToInt(LoopDirection::kForwardBackward);
            bool looped = false;
            jumpTableIndex = jumpIndex;
            nextStepIndex = getNextStepIndex(jumpTableIndex, forwardBackward, looped);
           // boundIntValue(nextStepIndex, 0, 7);
            
            initStepTiming(nextStepIndex);
            nextStep = laneStep[nextStepIndex];

            if(applyProbability)
                nextStep.updateStepProbability();

            if (nextStep.getIsNULLStep())
                nextStepValue = currentStep.getStepValue();
            else
                nextStepValue = nextStep.getStepValue();
        }

        void setCurrentStepFromNextStep()
        {
            currentStep = laneStep[nextStepIndex];
            currentStepIndex = nextStepIndex;
            
            if (!currentStep.getIsNULLStep())
                currentStepValue = currentStep.getStepValue();
        }

        bool loadNextStep(uint32_t loopDirectionIndex, bool applyProbability = false)
        {
            bool forwardBackward = loopDirectionIndex == enumToInt(LoopDirection::kForwardBackward);
            bool looped = false;
            uint32_t next = getNextStepIndex(jumpTableIndex, forwardBackward, looped);

            if (looped && randomizeSteps)
            {
                shuffleJumpTable();
                updateLaneLoopPoints();
            }

            nextStepIndex = next;
            initStepTiming(nextStepIndex);
            nextStep = laneStep[nextStepIndex];

            if(applyProbability)
                nextStep.updateStepProbability();

            if (nextStep.getIsNULLStep())
                nextStepValue = currentStep.getStepValue();
            else
                nextStepValue = nextStep.getStepValue();

            return looped;
        }
    
        uint32_t getNextStepIndex(uint32_t& jumpTableIndex, bool forwardBackward, bool& hitLoopPoint)
        {
            uint32_t nextStepIndex = 0;
            uint32_t nextIndex = calcNextIndex(jumpTableIndex);
            uint32_t previousIndex = calcPreviousIndex(jumpTableIndex);

            // --- if forward
            if (forwardDirection)
            {
                if (currentStep.getNextStepIndex() < 0)
                {
                    nextStepIndex = jumpTable[nextIndex];
                    jumpTableIndex = nextIndex;
                }
                else // hit a loop point
                {
                    hitLoopPoint = true;
                    if (forwardBackward)
                    {
                        jumpTableIndex = previousIndex;
                        nextStepIndex = jumpTable[jumpTableIndex];
                        forwardDirection = false;
                    }
                    else
                    {
                        nextStepIndex = currentStep.getNextStepIndex();
                        jumpTableIndex = nextStepIndex;
                    }
                }
            }
            else // going backwards
            {
                if (currentStep.getPreviousStepIndex() < 0)
                {
                    nextStepIndex = jumpTable[previousIndex];
                    jumpTableIndex = previousIndex;
                }
                else // it a loop point
                {
                    hitLoopPoint = true;
                    if (forwardBackward)
                    {
                        jumpTableIndex = nextIndex;
                        nextStepIndex = jumpTable[nextIndex];
                        forwardDirection = true;
                    }
                    else
                    {
                        nextStepIndex = currentStep.getPreviousStepIndex();
                        jumpTableIndex = nextStepIndex;
                    }
                }
            }
            return nextStepIndex;
        }


        void updateLEDMeterWithCurrentStep()
        {
            currentLEDStep = currentStepIndex;
            currentLEDStepDuration = currentStep.stepDurationSamplesRunning;
        }

        void updateLEDMeterWithNextStep()
        {
            currentLEDStep = nextStepIndex;
            currentLEDStepDuration = nextStep.stepDurationSamplesRunning;
        }


        void updateStepValues()
        {
            if(!currentStep.getIsNULLStep())
                currentStepValue = currentStep.getStepValue();
            
            if (!nextStep.getIsNULLStep())
                nextStepValue = nextStep.getStepValue();
        }

        void setRandomizeSteps(bool _randomizeSteps)
        {
            if (randomizeSteps != _randomizeSteps)
            {
                randomizeSteps = _randomizeSteps;
                if (!randomizeSteps)
                    resetJumpTable();
            }
        }

    public: 
        // --- LOOP points
        uint32_t startPoint = 0;            
        uint32_t endPoint = MAX_SEQ_STEPS;  
        bool forwardDirection = true;       

        // --- steps for the lane
        LaneStep laneStep[MAX_SEQ_STEPS];   
        LaneStep currentStep;               
        LaneStep nextStep;                  
        uint32_t currentLEDStep = 0;        
        uint32_t currentLEDStepDuration = 0; 
        int32_t getCurrentStepIndex() { return currentStepIndex; }
        int32_t getNextStepIndex() { return nextStepIndex; }
        double getCurrentStepValue() { return currentStepValue; }
        double getNextStepValue() { return nextStepValue; }
        
        int32_t getJumpTableValue(uint32_t index) 
        {
            if (index > MAX_SEQ_STEPS - 1)
                return 0;

            return jumpTable[index];
        }

    protected:
        inline uint32_t calcNextIndex(uint32_t baseIndex)
        {
            uint32_t next = baseIndex + 1;
            next &= WRAP_MASK;
            return next;
        }

        inline uint32_t calcPreviousIndex(uint32_t baseIndex)
        {
            uint32_t next = baseIndex - 1;
            next &= WRAP_MASK;
            return next;
        }

        // --- table of steps
        int32_t jumpTable[MAX_SEQ_STEPS]; 

        // --- realtime operation
        int32_t currentStepIndex = 0;       
        int32_t nextStepIndex = 0;          
        uint32_t jumpTableIndex = 0;        

        double currentStepValue = 0.0;  
        double nextStepValue = 0.0;     
        bool randomizeSteps = false;    
    };

    struct WaveSequencerStatusMeters
    {
        WaveSequencerStatusMeters& operator=(const WaveSequencerStatusMeters& wssm) // need this override for collections to work
        {
            if (this == &wssm)
                return *this;

            memcpy(timingLaneMeter, wssm.timingLaneMeter, MAX_SEQ_STEPS * sizeof(uint32_t));
            memcpy(waveLaneMeter, wssm.waveLaneMeter, MAX_SEQ_STEPS * sizeof(uint32_t));
            memcpy(pitchLaneMeter, wssm.pitchLaneMeter, MAX_SEQ_STEPS * sizeof(uint32_t));
            memcpy(stepSeqLaneMeter, wssm.stepSeqLaneMeter, MAX_SEQ_STEPS * sizeof(uint32_t));
            return *this;
        }

        uint32_t timingLaneMeter[MAX_SEQ_STEPS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
        uint32_t waveLaneMeter[MAX_SEQ_STEPS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
        uint32_t pitchLaneMeter[MAX_SEQ_STEPS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
        uint32_t stepSeqLaneMeter[MAX_SEQ_STEPS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    };

    enum class soloType { SOLO_OFF, SOLO_0, SOLO_1, SOLO_2, SOLO_3, SOLO_4, SOLO_5, SOLO_6, SOLO_7 };

    struct WaveSequencerParameters
    {
        WaveSequencerParameters() {}
        WaveSequencerStatusMeters statusMeters; 
        bool haltSequencer = false;

        double BPM = 120;
        double timeStretch = 1.0;
        bool interpolateStepSeqMod = false;
        bool randomizeStepOrder = false;
        bool randomizePitchOrder = false;
        bool randomizeWaveOrder = false;
        bool randomizeSSModOrder = false;

        uint32_t timingLoopStart = 1; // NOTE: 1 is the minimum value here, 1-indexed to match GUI for user
        uint32_t timingLoopEnd = MAX_SEQ_STEPS;// -1;
        uint32_t timingLoopDirIndex = enumToInt(LoopDirection::kForward);

        double stepDurationMilliSec[MAX_SEQ_STEPS] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };
        uint32_t stepDurationNoteIndex[MAX_SEQ_STEPS] = { enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter) };
        uint32_t stepType[MAX_SEQ_STEPS] = { 0,0,0,0,0,0,0,0 }; // 0 = NOTE, 1 = REST
        // uint32_t timingLaneMeter[MAX_SEQ_STEPS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
        // --------------------------------------------------- 

        double xfadeDurationMilliSec[MAX_SEQ_STEPS] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };
        uint32_t xfadeDurationNoteIndex[MAX_SEQ_STEPS] = { enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter),enumToInt(NoteDuration::kQuarter) };
        // --------------------------------------------------- 

        uint32_t modLoopStart[NUM_MOD_LANES] = { 1, 1, 1 };  // NOTE: 1 is the minimum value here, 1-indexed to match GUI for user
        uint32_t modLoopEnd[NUM_MOD_LANES] = { MAX_SEQ_STEPS, MAX_SEQ_STEPS, MAX_SEQ_STEPS }; 
        uint32_t modLoopDirIndex[NUM_MOD_LANES] = { enumToInt(LoopDirection::kForward), enumToInt(LoopDirection::kForward), enumToInt(LoopDirection::kForward) };

        double waveLaneAmp_dB[MAX_SEQ_STEPS] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };
        double waveLaneValue[MAX_SEQ_STEPS] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };
        double waveLaneProbability_pct[MAX_SEQ_STEPS] = { 100.0,100.0,100.0,100.0,100.0,100.0,100.0,100.0 }; // WRAP_MASK = MAX-1

        double pitchLaneValue[MAX_SEQ_STEPS] = { 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 };
        double pitchLaneProbability_pct[MAX_SEQ_STEPS] = { 100.0,100.0,100.0,100.0,100.0,100.0,100.0,100.0 }; // WRAP_MASK = MAX-1

        double stepSeqValue[MAX_SEQ_STEPS] = { -1.0,1.0,-0.3,-0.1, 1.0, 0.6, 0.3, 0.0 };
        double stepSeqProbability_pct[MAX_SEQ_STEPS] = { 100.0,100.0,100.0,100.0,100.0,100.0,100.0,100.0 }; // WRAP_MASK = MAX-1
    };

    class WaveSequencer : public SynthModule
    {
    public:
        WaveSequencer(std::shared_ptr<MidiInputData> _midiInputData,
            std::shared_ptr<WaveSequencerParameters> _parameters,
            uint32_t blockSize = 64);   /* C-TOR */

        virtual ~WaveSequencer() {}     /* D-TOR */

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

        void clearStatusArray();
        uint32_t setCurrentTimingXFadeSamples();
        void setXFadeHoldParams(uint32_t xfadeInTimeSamples);
        void updateLaneLoopPoints();

    protected:
        std::shared_ptr<WaveSequencerParameters> parameters = nullptr;

        // --- for LEDs 
        uint32_t sampleCounter = 0; 

        // --- lanes
        Lane    timingLane;         
        Lane    waveLane;           
        Lane    pitchLane;          
        Lane    stepSeqLane;        

        // --- crossfader
        XHoldFader xHoldFader;      
        bool initialStep = false;

        // --- for probabilities
        NoiseGenerator noiseGen;    

        // --- basic variables
        double sampleRate = 0.0;        
        double samplesPerMSec = 0.0;    
    };

} // namespace