GranularOscillator.h

Go to the documentation of this file.

/*
==============================================================================
 
    GranularOscillator.h
    Header for sample based oscillator / granular engine
    Author: Sandy
    Date: 19/08/2020
 
==============================================================================
*/
 
#pragma once
#include <mutex>
 
namespace krotos
{
    class GranularOscillator : public Oscillator
    {
 
      public:
        GranularOscillator();
 
        ~GranularOscillator() override {}
 
        void setSampleRate(double sampleRate) override;
 
        double getSampleRate() override;
 
        void setFrequency(float frequency) override;
 
        float getFrequency() override;
 
        void setPhaseOffset(float /*offset*/) override {}
        void reset() override {}
        void setPhase(double /*phase*/) override {}
        double getPhase() override { return 0.0; }
 
        int getNumActiveGrains() override;
 
        StereoSample getNextStereoSample(size_t sampleIndex) override;
 
        // float getNextSample() override;
 
        void setGranularParameter(size_t paramIndex, const float* newValue);
 
        void setGranularParameters(std::vector<const float*>& newParams);
 
        void setSampleData(SampleEngine* sampleEngine);
 
        void startNote(int midiNote, float velocity, int voiceIndex);
 
        const float getVelocity();
 
        void stopNote();
 
        void clearNote();
 
        enum GranularParam
        {
            // Granular basics
            Start = 0,
            StartRand,
            Size,
            SizeRand,
            Rate,
            RateRand,
            Width,
            WidthRand,
            Pan,
            PanRand,
            Detune,
            DetuneMod,
            DetuneRand,
            Level,
            SamplerLevel,
            GranularLevel,
            VehicleLevel,
            LevelMod,
            LevelRand,
            Quench,
            Robin,
            SALoop,
            AutoRate,
            Autoplay,
            Shape,
            GrainLim,
            // Phase locked granular
            Tracking,
            Cycles,
            PhaseLock,
            PhaseSync,
            Normalise,
            MuteUp,
            MuteDown,
            Smoothing,
            MovementSensitivity,
            // Phase locked granular
            SizeST,
            DivST,
            SprayST,
            MixST,
            SizeDY,
            DivDY,
            SprayDY,
            MixDY,
            Mute,
            Solo,
            NUM_PARAMS
        };
 
      private:
        // Methods
        void setGranularOscillatorType(GranularPlaybackMode newType);
 
        void flushGranular();
        float cube(float val);
        void setTaggingType(bool isOn);
        void setTrackingEnable(bool isOn);
 
        void setLoopEnableFlag();
 
        void killNANs(StereoSample& sample);
        Grain* launchGrain(float paramSize, float paramStart, float paramSpray, Grain::Flavour flavour,
                           float gain = -1.f);
        double calculatePlayheadPosition(double startPosition, float halfSpray, float referenceGrainsize);
        StereoSample getNextStereoGranularSamplePhaseLocked();
 
        StereoSample getNextStereoGranular();
 
        StereoSample getNextStereoSampler();
 
        void generateGrainsGranular(StereoSample& sampleAccumulator);
        void generateGrainsSampler(StereoSample& sampleAccumulator);
 
        void setGrainData(Grain* playingGrain);
 
        void generateNewFluxFactor();
 
        // Variables
        juce::Random m_rand{1234};
        GranularPlaybackMode m_granularOscillatorType{GranularPlaybackMode::MGranular};
        PhaseGenerator m_grainTimer;
        float m_playbackHz{0.0f};
        float m_playbackHzDetuned{0.0f}; // Desired frequency of note to be played back
 
        double m_samplerate{48000.0};
        float m_fluxFactor{0.0f};
        float m_grainRate{0.0f};
        float m_startIndex{0.0f};
        float m_startIndexSearched{0.0f};
        AudioDescriptor m_closestDescriptor;
        SampleEngine* m_sampleEngine{nullptr};
        std::vector<Grain*> m_activeGrains;
        int m_length{0};
        std::vector<const float*> m_parameters;
        bool m_stopped{false};
        bool m_keyDown{false};
 
        int m_voiceIndex{-1};
 
        volatile float m_directionGating{0.f};
        SlewLimiter m_channelCrossfade;
        SlewLimiter m_directionGatingSmoother;
 
        float m_crossfadeValue{0.f};
 
        bool m_taggingType{false};
        bool m_trackingEnable{false};
        bool m_loopingEnable{false};
        bool m_normalisationEnable{false};
        size_t m_sampleIndex{0};
        float m_velocity{1.0f};
        bool m_allowAudiosegmentIncrement{false};
 
        // float value between 0.0-12.0f given by the ADSR applied on a Detune modSlider
        float m_detuneModVal{0.0f};
        const float AMPLITUDE_FIDDLE_FACTOR{0.6f};
        const float FADE_POINT_MIN{0.000001f};
        bool m_isDrone{false};
        bool m_autoplayEnabled{false};
        const float PARAMETER_TRUE_THRESHOLD{0.5f};
 
        // Experimentally derived scaling values
        const float FLUX_PARAM_SKEW{0.3f};
        const float FLUX_SCALING_POSITIVE{6.0f};
        const float FLUX_SCALING_NEGATIVE{1.5f};
 
        // This is the length of the anti-click ramp applied to the start and end of the sample in loop mode
        const float RAMP_LENGTH_SECONDS{0.004f};
 
        // The number of samples in the anti-click ramp
        float m_rampSamples{0};
        // Added to the ramp value to create the ramp
        float m_rampInc{1.f};
    };
} // namespace krotos