OscillatorUtils.h

Go to the documentation of this file.

/*
  ==============================================================================
 
    OscillatorUtils.h
    Author:  sandy
 
  ==============================================================================
*/
 
#pragma once
 
#include <algorithm>
#include <vector>
 
namespace krotos
{
    // TODO: might be better not to have these be global and have them stored together in a class/namespace
    // In Juce, MIDI notes are passed around as 32 bit ints
    // We take advantage of the fact that only the lowest 7 bits are required to represent the MIDI note number ...
    // ... and use some of the remaining 25 bits to pass some flags along with the note message
    static const int MIDI_NOTE_MASK{0x7f};               // This masks the actual MIDI note number
    static const int MIDI_NOTE_FLAG_DRONE{0x80};         // Bit is set if the note event is a drone
    static const int MIDI_NOTE_FLAG_DRONE_NOTEUP{0x100}; // Bit is set if the note event is a drone note-up
    static const int MIDI_NOTE_FLAG_FLUSH{0x200};        // Bit is set if the note event is a note flush event
    static const int MIDI_NOTE_FLAG_NOR{0x400};          // Bit is set if the note event is a Note On Release event
    static const int MIDI_NOTE_NUMBER_C3{60};
    static const int MIDI_NOTE_NUMBER_CS3{61};
    static const int MIDI_NOTE_NUMBER_D3{62};
    static const int MIDI_NOTE_NUMBER_DS3{63};
    static const int MIDI_NOTE_NUMBER_E3{64};
 
    static const int NUM_VOICES_POLY = 8;
    static const int NUM_VOICES_DRONE = 1;
    static const int NUM_VOICES_TOTAL = NUM_VOICES_POLY + NUM_VOICES_DRONE;
 
    static const int SEMITONES_PER_OCTAVE{12};
 
    class Grain
    {
      public:
        void setLifetime(int grainPlaybackLength);
 
        // Used within playback engine and for display
        enum Flavour
        {
            vehicleMoving = 0,
            vehicleStatic,
            foreground,
            background,
            tagged,
            predicted
        } flavour{vehicleMoving}; // the type of grain
        float mix{1.f};           // mix positions between flavours (percentage)
        int playHeadStart{0};     // start of grain (samples)
 
        float grainSize{0.f};   // The size in samples of the grain as calculated by analysis
        int length{0};          // Compensated length of grain in samples - how many will we actually play back
        float grainWindow{0.f}; // playback position in grain (percentage)
        float envelope{0.f};    // amplitude of grain "shape" (percentage)
 
        double playHead{0.0};
        int segmentIndex{0}; // Keep a copy of which segment index we are playing
        float resampleRatio{1.f};
        float pitchRand{0.01f};
        float gainRand{1.0f};
        float panRand{0.5f};
        float widthRand{0.5f};
        float ramp{0.0f}; // Ramp value for anti-click ramp when looping
        bool isPlaying{false};
        float windowDelta{0.f};
        int voiceIndex{-1};
        float gainMod{0.f};  // Audio ADSR output value used in the grain display
        float pitchMod{0.f}; // Pitch ADSR output value used in the grain display
 
        float principalX{0.f}; // ML principals
        float principalY{0.f};
        float principalZ{0.f};
        float principalQ{0.f};
 
      private:
        friend class SampleEngine;
    };
 
    class PhaseGenerator
    {
      public:
        PhaseGenerator() {}
        ~PhaseGenerator() {}
 
        inline void nextPhase();
        inline float getPhase();
        inline float getDelta();
 
        inline void synchronise(double& grainPhase)
        {
            int grain = int(grainPhase);
            if (m_newCycle)
            {
                grain++;
            }
            grainPhase = double(grain) + m_phase;
        }
 
        inline void setPhaseDelta(float val);
        inline void setLoopSize(int val);
        inline void setLoopSize2(int val);
        inline void setFrequency(float val);
        inline float getFrequency();
        inline void setPhase(float val);
        inline void triggerNewGrain();
        inline void mixPhase(float val);
 
        inline bool hasWrapped();
        inline bool hasLooped();
        inline bool hasLooped2();
        inline void setSampleRate(float val);
 
      private:
        volatile float m_phase{0.0f};
        volatile float m_delta{0.1f};
        volatile bool m_newCycle{false};
 
        volatile int m_loopPhaseCounter{0};
        volatile int m_loopSize{1};
        volatile bool m_newLoop{false};
 
        volatile int m_loopPhaseCounter2{0};
        volatile int m_loopSize2{1};
        volatile bool m_newLoop2{false};
 
        float m_sampleRate{48000.0f};
        float m_sampleRateReciprocal{1.0f / m_sampleRate};
        float m_frequency{1.0f};
    };
 
    class Randomiser
    {
      public:
        Randomiser() {}
        ~Randomiser() {}
 
        inline void setRange(int val);
        inline bool randomiseIf(bool enable);
        inline int getValue();
 
      private:
        int m_value{0};
        int m_range{0};
    };
 
    class DeClicker
    {
      public:
        DeClicker() {}
        ~DeClicker() {}
 
        inline float processSample(float sample); // Inline for speed
        inline float getRamp();
        inline void setLength(float val);
        inline void trigger();
        inline bool triggerIf(bool enable);
        inline bool isActive();
 
      private:
        float m_ramp{0.0f};
        float m_delta{0.0f};
        float m_previousSample{0.0f};
        float m_length{20.0f};
        bool m_triggered{false};
    };
 
    template <class T> class WatchValue
    {
      public:
        WatchValue() {}
        ~WatchValue() {}
 
        inline void setValue(T val)
        {
            m_hasChanged = val != m_value;
            m_value = val;
        }
 
        inline T getValue() { return m_value; }
 
        inline bool hasChanged() { return m_hasChanged; }
 
      private:
        bool m_hasChanged{false};
        T m_value{0};
    };
 
    class SlewLimiter
    {
      public:
        SlewLimiter() {}
        ~SlewLimiter() {}
 
        inline float processSample(float sample);              // Inline for speed
        inline float processSample(float sample, bool enable); // Inline for speed
        void setMaxSlewRate(float val);
        void setMaxSlewRates(float valPosative, float valNegative);
 
      private:
        float m_maxSlewPosative{100.0f};
        float m_maxSlewNegative{-100.0f};
        float m_previousSample{0.0f};
    };
 
    class MouseVelocityExtractor
    {
      public:
        MouseVelocityExtractor() {}
        ~MouseVelocityExtractor() {}
 
        void process();
 
        void prepare(double sampleRate, int samplesPerBlock);
 
        void setInput(float val);
 
        float getOutput();
 
      private:
        double m_sampleRate{0.0};
        int m_samplesPerBlock{0};
        float m_blockRateHZ{0.f};
        float m_input{0.0f};
        float m_previousInput{0.0f};
        float m_velocity{0.0f};
        float m_calibration{0};
        SmoothedFloat m_smoothedVelocity;
        // VELOCITY_LP_FILTER_HZ defines the cut-off frequency of the low pass filter applied to puck X and Y movement.
        // Mouse driven parameters are very noisy, this value needs to balance effective noise filtering against
        // 'sluggish' response to mouse movement.
        const float VELOCITY_LP_FILTER_HZ{4.5f};
        // We don't need a "peaky" filter so Q left at 1
        const float VELOCITY_LP_FILTER_Q{1.f};
        // CALIBRATION_FACTOR defines how sensitive the velocity modulator is to movement of the puck. Larger means more
        // sensitive. It has been experimentally chosen to 'feel' responsive. If anything, it is set slightly 'hot'
        // because it can be toned down using the modulator amount slider
        const float CALIBRATION_FACTOR{0.1f};
        dsp::IIR::Filter<float> m_smoother;
    };
} // namespace krotos