GranularOscillator.cpp

Go to the documentation of this file.

/*
==============================================================================
 
    GranularOscillator.cpp
    Sample based oscillator / granular engine
    Author: Sandy
    Date: 19/08/2020
 
==============================================================================
*/
 
#include "GranularOscillator.h"
 
namespace krotos
{
    GranularOscillator::GranularOscillator() { m_parameters.resize(GranularParam::NUM_PARAMS); }
 
    inline void GranularOscillator::setGranularOscillatorType(GranularPlaybackMode newType)
    {
        m_granularOscillatorType = newType;
        m_trackingEnable = newType == GranularPlaybackMode::MVehicle;
    }
 
    void GranularOscillator::setGranularParameter(size_t paramIndex, const float* newValue)
    {
        jassert(paramIndex >= 0 && paramIndex < GranularParam::NUM_PARAMS);
        m_parameters[paramIndex] = newValue;
    }
 
    inline void GranularOscillator::setGranularParameters(std::vector<const float*>& newParams)
    {
        jassert(newParams.size() == m_parameters.size());
        m_parameters = newParams;
    }
 
    inline void GranularOscillator::setSampleRate(double sampleRate)
    {
        m_samplerate = sampleRate;
        m_grainTimer.setSampleRate(static_cast<float>(m_samplerate));
        m_grainTimer.setFrequency(100.0f);
        m_channelCrossfade.setMaxSlewRate(2.f / static_cast<float>(sampleRate));
        m_directionGatingSmoother.setMaxSlewRate(2.f / static_cast<float>(sampleRate));
    }
 
    void GranularOscillator::setSampleData(SampleEngine* sampleEngine)
    {
        m_sampleEngine = sampleEngine;
        // m_length = sampleEngine->getNumSamples();
    }
 
    // Remove all playing grains from the active grains list
    void GranularOscillator::flushGranular()
    {
        for (auto& grain : m_activeGrains)
        {
            m_sampleEngine->freeGrain(grain); // Stop playing the grain
        }
        m_activeGrains.clear();
    }
 
    /*
        How the frequency calculation works
        setFrequency( frequency ) is called with the desired output frequency of the sample
 
        Things we need to calculate:
 
        1) An increment to be added to the playhead every sample
        2) A resample ratio to compensate for any difference between the sample's sample rate and the DAW's sample rate
        3) A ratio to adjust for the frequency of the sampled note (working with C3 at present, pending some analysis or
       meta-data)
 
        1 is simply m_playbackHz * m_resampleRatio
        2 & 3 are combined into m_resampleRatio
    */
 
    inline void GranularOscillator::setFrequency(float frequency)
    {
        // Clamp within reasonable limits ie frequency >= epsilon, frequency <= nyquist (m_samplerate / 2)
        m_playbackHz = std::max(std::min(float(m_samplerate * 0.5f), frequency), std::numeric_limits<float>::epsilon());
    }
 
    inline float GranularOscillator::cube(float val) { return val * val * val; }
 
    void GranularOscillator::startNote(int midiNote, float velocity, int voiceIndex)
    {
        m_voiceIndex = voiceIndex; // Used finally merely to indicate on the UX the voice index of each playhead
 
        // Setting the mode of the oscillator - no need to do this every sample, once at note-start is enough
        setGranularOscillatorType(m_sampleEngine->getGranularOscillatorTypeIndicator());
 
        m_autoplayEnabled = bool(m_parameters[GranularParam::Autoplay][0] > 0.5f);
        m_isDrone = (midiNote & MIDI_NOTE_FLAG_DRONE) != 0;
 
        m_stopped = false;
        m_keyDown = true;
        m_velocity = velocity;
        m_allowAudiosegmentIncrement = true;
        setFrequency(static_cast<float>(MidiMessage::getMidiNoteInHertz(midiNote & MIDI_NOTE_MASK)));
        m_grainTimer.triggerNewGrain(); // Trigger a new grain
    }
 
    void GranularOscillator::stopNote() { m_keyDown = false; }
 
    const float GranularOscillator::getVelocity() { return m_velocity; }
 
    void GranularOscillator::clearNote()
    {
        m_keyDown = false;
        if (!m_stopped)
        {
            m_stopped = true;
            flushGranular();
        }
    }
 
    inline void GranularOscillator::setTaggingType(bool isOn) { m_taggingType = isOn; }
 
    inline void GranularOscillator::setTrackingEnable(bool isOn) { m_trackingEnable = isOn; }
 
    inline void GranularOscillator::setLoopEnableFlag()
    {
        m_loopingEnable = m_parameters[GranularParam::SALoop][m_sampleIndex] > PARAMETER_TRUE_THRESHOLD;
    }
 
    inline void GranularOscillator::killNANs(StereoSample& sample)
    {
        if (std::isnan(sample.left))
        {
            jassertfalse; // Shouldn't get here
            sample.left = 0.0f;
        }
        if (std::isnan(sample.right))
        {
            jassertfalse; // Shouldn't get here
            sample.right = 0.0f;
        }
#ifdef USE_BRICK_WALL_CLIPPING
        const float clippingVal = 3.0f;
        if (sample.left > clippingVal)
        {
            sample.left = clippingVal;
        }
        if (sample.right > clippingVal)
        {
            sample.right = clippingVal;
        }
#endif
    }
 
    //
    //  This is a stereo oscillator, but we return a mono result here
    //
    // inline float GranularOscillator::getNextSample()
    //{
    //  StereoSample sample = getNextStereoSample();
    //  return (sample.left + sample.right) * 0.5f;
    //}
 
    void GranularOscillator::generateNewFluxFactor()
    {
        float rand = m_rand.nextFloat() - 0.5f; // rand varies between +- 0.5
        rand *= powf(m_parameters[GranularParam::RateRand][m_sampleIndex],
                     0.3f); // scaled by FLUX parameter, skewed for more action lower down
        if (rand > 0.0f)
        {
            m_fluxFactor = 1.0f + rand * 6.0f; // scaling ranges between 1.0 -> 4.0
        }
        else
        {
            m_fluxFactor = 1.0f + rand * 1.5f; // scaling ranges between 1.0 -> 0.25
        }
    }
 
    double GranularOscillator::calculatePlayheadPosition(double startPosition, float halfSpray,
                                                         float /*referenceGrainsize*/)
    {
        // Calculate start and spray
        // If the combination of start and spray take the spray range off the edge of the sample ...
        // .. then the spray range is shifted forwards or backwards to keep it inside the sample while preserving the
        // spray range size eg if spray is set to 1, start will have no effect whatsoever, as the spray range already
        // covers the entire sample Conversely if spray is set to 0, start will be effective throughout its entire range
 
        //--------------------- Scale spray range to grain size
        halfSpray *= 10.0f * m_closestDescriptor.grainSize / float(m_length); // += 10 grains max spray range
 
        Range<double> sprayRange(startPosition - static_cast<double>(halfSpray),
                                 startPosition + static_cast<double>(halfSpray));
        Range<double> constraintRange(0.f, 1.f);
        Range<double> useableRange = constraintRange.constrainRange(sprayRange);
 
        // Randomly place playhead somewhere within useable range
        return (useableRange.getStart() + m_rand.nextDouble() * useableRange.getLength()) *
               static_cast<double>(m_length);
    }
 
    Grain* GranularOscillator::launchGrain(float paramSize, float paramStart, float paramSpray, Grain::Flavour flavour,
                                           float gain)
    {
        const float minimumGrainLength{0.1f};
 
        bool shouldLaunchNewGrain = false;
        if (m_isDrone)
        {
            if (m_autoplayEnabled)
            {
                shouldLaunchNewGrain = true;
            }
        }
        else
        {
            shouldLaunchNewGrain = true;
        }
 
        if (shouldLaunchNewGrain)
        {
            // Ask the sample engine for a free grain slot, returns non-null if successful
            Grain* newGrain = m_sampleEngine->allocateGrain();
            if (newGrain) // If non-null, means a free grain slot was found and newGrain is pointing to it
            {
                // Each voice instance (this is a voice instance) keeps its own personal record of every grain it is
                // playing
                m_activeGrains.push_back(newGrain);
 
                int grainLength = int(jmax<float>(minimumGrainLength, m_closestDescriptor.grainSize * paramSize));
 
                double playHead = calculatePlayheadPosition(paramStart, paramSpray, m_closestDescriptor.grainSize);
                AudioDescriptor quantisedGrain = m_sampleEngine->audioIndexToDescriptor(
                        static_cast<int>(playHead) -
                        grainLength / 2); // Center the playing grain about the start position
 
                // Calculate jitter - this implementation is an amplitude variation factor of +-1 centered around 1
                if (gain < 0.f) // If supplied gain < 0, we generate it here
                {
                    gain = 1.0f +
                           2.f * m_parameters[GranularParam::LevelRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
                }
 
                // Calculate drift
                float pitchRand =
                        1.0f + m_parameters[GranularParam::DetuneRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
 
                // Now we populate all the properties of the grain ...
                newGrain->playHead =
                        static_cast<double>(quantisedGrain.grainIndexByTime); // phase cycle index with phase angle 0
                newGrain->playHeadStart =
                        quantisedGrain.audioIndex; // Keep a record of the start point - used in displaying grain in UI
                newGrain->windowDelta =
                        1.f /
                        float(grainLength);  // Calculate the increment needed to go from 0->1 during lifetime of grain
                newGrain->grainWindow = 0.f; // Reset the window value
                newGrain->length = grainLength; // Set the grainLength in samples
                newGrain->grainSize = m_closestDescriptor.grainSize;
                newGrain->gainRand = gain * gain;
                newGrain->pitchRand = pitchRand;
                newGrain->flavour = flavour;
            }
 
            return newGrain;
        }
 
        return nullptr;
    }
 
    inline StereoSample GranularOscillator::getNextStereoSample(size_t sampleIndex)
    {
        if (m_sampleEngine == nullptr)
        {
            return StereoSample{}; // Return silence if no sample data
        }
 
        m_length = m_sampleEngine->getNumSamples();
 
        jassert(sampleIndex >= 0 && sampleIndex < m_length);
 
        if (m_stopped || sampleIndex < 0 || sampleIndex >= m_length)
        {
            return StereoSample{}; // Return silence if engine stopped or sampleIndex out of range
        }
 
        m_sampleIndex = sampleIndex;
 
        setGranularOscillatorType(m_sampleEngine->getGranularOscillatorTypeIndicator());
 
        m_autoplayEnabled = bool(m_parameters[GranularParam::Autoplay][0] > 0.5f);
 
        switch (m_granularOscillatorType)
        {
        case GranularPlaybackMode::MVehicle:
            return getNextStereoGranularSamplePhaseLocked() *
                   Decibels::decibelsToGain(m_parameters[GranularParam::VehicleLevel][m_sampleIndex]);
            break;
        case GranularPlaybackMode::MGranular:
            return getNextStereoGranular() *
                   Decibels::decibelsToGain(m_parameters[GranularParam::GranularLevel][m_sampleIndex]);
            break;
        case GranularPlaybackMode::MSampler:
            return getNextStereoSampler() *
                   Decibels::decibelsToGain(m_parameters[GranularParam::SamplerLevel][m_sampleIndex]);
            break;
        default:
            return StereoSample(); // Return silence
            break;
        }
    }
 
    inline StereoSample GranularOscillator::getNextStereoGranularSamplePhaseLocked()
    {
        // Slider names: Rate of grain generation - RATE, Randomisation of grain rate - FLUX
 
        bool muteUp = m_parameters[GranularParam::MuteUp][0] > 0.5f;
        bool muteDown = m_parameters[GranularParam::MuteDown][0] > 0.5f;
        bool synch = m_parameters[GranularParam::PhaseSync][0] > 0.5f;
 
        if (!m_sampleEngine->analysisResultsAreValid())
        {
            // jassertfalse;
            return StereoSample{}; // Return silence if no sample data
        }
 
        // Declare local variables
        StereoSample sampleAccumulatorSustained;
        StereoSample sampleAccumulatorMoving;
 
        float startSlider = m_parameters[GranularParam::Start][m_sampleIndex] * 0.01f;
 
        // Find the closest (red line) descriptor to the start slider, but since it involves a search, only if the start
        // slider has moved
        if (m_startIndex != startSlider)
        {
            float smoothing = powf(m_parameters[GranularParam::Smoothing][m_sampleIndex],
                                   0.3f); // powf skewed for for more action towards zero
 
            float smoothingCoeff = jmap<float>(smoothing, 0.f, 1.f, 0.001f, 0.000001f);
 
            m_startIndex = (1.f - smoothingCoeff) * m_startIndex + smoothingCoeff * startSlider;
 
            float difference = m_startIndex - startSlider;
            float movement = jmin<float>(
                    fabsf(difference) * m_parameters[GranularParam::MovementSensitivity][m_sampleIndex] * 500.f,
                    1.f); // Clamp to <= 1
 
            m_crossfadeValue = movement;
            m_sampleEngine->setIndicator1(m_crossfadeValue);
 
            // Direction gating
            if (difference > 0)
            {
                m_directionGating = 0.f;
            }
            else
            {
                m_directionGating = movement;
            }
            if (muteUp && muteDown)
            {
                m_directionGating = 0.f;
            }
            else if (muteUp && !muteDown)
            {
                m_directionGating = 1 - m_directionGating;
            }
            else if (!muteUp && !muteDown)
            {
                m_directionGating = 1;
            }
 
            // Find the nearest grain
            if (m_sampleEngine->getGrainDescriptionByTime().size() != 0) // Safety
            {
                if (synch)
                {
                    float freq = jmap<float>(m_startIndex, 0.f, 1.f, 12.f, 60.f);
                    m_closestDescriptor = m_sampleEngine->audioFrequencyToDescriptor(freq); // Navigate by frequency
                }
                else
                {
                    m_closestDescriptor =
                            m_sampleEngine->audioPercentToDescriptor(m_startIndex); // Navigate by file position
                }
 
                // Set the frequency of the phase generator from the red line
                m_grainTimer.setFrequency(m_closestDescriptor.frequency);
 
                m_sampleEngine->setIndicatorRPM(m_closestDescriptor.frequency * 60.f);
 
                m_startIndexSearched = static_cast<float>(static_cast<double>(m_closestDescriptor.audioIndex) /
                                                          static_cast<double>(m_length));
            }
        }
 
        float mix = m_channelCrossfade.processSample(jmap<float>(m_crossfadeValue, 0.f, 1.f,
                                                                 m_parameters[GranularParam::MixST][m_sampleIndex],
                                                                 m_parameters[GranularParam::MixDY][m_sampleIndex]));
 
        float smoothedDirectionGating = m_directionGatingSmoother.processSample(m_directionGating);
        m_sampleEngine->setIndicator2(smoothedDirectionGating);
 
        m_sampleEngine->setGrainLimit(
                static_cast<int>(m_parameters[GranularParam::GrainLim]
                                             [m_sampleIndex])); // TODO: this could be done further up the hierarchy
 
        // Update the phase of this entire voice - all playing grains in this voice are synchronised to this
        m_grainTimer.nextPhase();
 
        // If m_voice phase loop divider has wrapped, then it is time to launch a new sustain grain
        if (m_grainTimer.hasLooped())
        {
            m_grainTimer.setLoopSize(int(m_parameters[GranularParam::DivST][m_sampleIndex]));
            launchGrain(m_parameters[GranularParam::SizeST][m_sampleIndex], m_startIndexSearched,
                        m_parameters[GranularParam::SprayST][m_sampleIndex], Grain::Flavour::vehicleStatic);
        }
 
        // If m_voice phase loop has wrapped past 360 degrees, then it is time to launch a new moving grain
        if (m_grainTimer.hasLooped2())
        {
            m_grainTimer.setLoopSize2(int(m_parameters[GranularParam::DivDY][m_sampleIndex]));
            launchGrain(m_parameters[GranularParam::SizeDY][m_sampleIndex], m_startIndexSearched,
                        m_parameters[GranularParam::SprayDY][m_sampleIndex], Grain::Flavour::vehicleMoving);
        }
 
        // Sum and return the audio signals from all the playing grains
        int grainIndex = static_cast<int>(m_activeGrains.size()) - 1;
        while (grainIndex >= 0)
        {
            Grain* playingGrain = m_activeGrains[size_t(grainIndex)];
 
            // Fetch the audio from the sample buffer using the selected interpolation method
            // StereoSample sample = m_sampleEngine->getInterpolatedSample(playingGrain->playHead);
            StereoSample sample = m_sampleEngine->getSampleFromGrainPhase(playingGrain->playHead);
 
            // Calculate shape envelope  (TODO: add more shape calculation methodology - cosine ? other ? -
            // pre-calculate to save CPU ?)
 
            float grainProgress =
                    playingGrain->grainWindow; // Pick the value off before we increment to allow it to start from 0
 
            playingGrain->grainWindow += playingGrain->windowDelta; // Increment the grain window - track progress
                                                                    // through grain from 0 to 1 as grain plays
 
            if (grainProgress > 0.5f)
                grainProgress = 1.0f - grainProgress;
            grainProgress *= 2.0f; // Scale so it peaks at 1 - shape now looks like a triangle
            float shape = jmax(m_parameters[GranularParam::Shape][m_sampleIndex],
                               0.02f); // Don't let shape get too square or it will click / generate NANs
            grainProgress /= shape;
            grainProgress = jmin(grainProgress, 1.0f);                      // Clamp to 1
            float shapeEnvelope = 1.0f - cube(fabsf(1.0f - grainProgress)); // Curve the straight lines
            shapeEnvelope *=
                    1.f + shape * AMPLITUDE_FIDDLE_FACTOR; // Compensate for loss of amplitude as shape gets less square
            playingGrain->envelope = shapeEnvelope;        // Copy here for use by the grain display
 
            // Do width calculation
            float width = m_parameters[GranularParam::Width][m_sampleIndex];
            float widthInv = 1.0f - width;
            float mono = widthInv * 0.5f * (sample.left + sample.right);
            float left = sample.left * width + mono;
            float right = sample.right * width + mono;
 
            // Accumulate audio from all the playing grains
            float gain = playingGrain->gainRand * shapeEnvelope;
            float pan = (1.f - m_parameters[GranularParam::Pan][m_sampleIndex]) * 0.5f;
            StereoSample result;
 
            result.left = gain * left * powf(pan * 0.8f, 0.5f);
            result.right = gain * right * powf(0.8f - pan * 0.8f, 0.5f);
 
            if (playingGrain->flavour == Grain::Flavour::vehicleMoving)
            {
                sampleAccumulatorMoving += result;
                playingGrain->mix = playingGrain->gainRand * mix;
            }
            else
            {
                sampleAccumulatorSustained += result;
                playingGrain->mix = playingGrain->gainRand * (1.0f - mix);
            }
 
            // Move the playhead forwards, synchronising with the voice phase
            m_grainTimer.synchronise(playingGrain->playHead);
 
            // Has the grain come to the end of its life ?
            if (playingGrain->grainWindow >= 1.0f)
            {
                // If so, return it to the pool
                m_sampleEngine->freeGrain(playingGrain);
                // and remove it from our local list of active grains
                m_activeGrains.erase(m_activeGrains.begin() + grainIndex);
            }
 
            grainIndex--;
        }
 
        float gain = Decibels::decibelsToGain(m_parameters[GranularParam::Level][m_sampleIndex]);
        StereoSample output = (sampleAccumulatorMoving * mix + sampleAccumulatorSustained * (1.f - mix)) * gain;
 
        output = output * m_parameters[GranularParam::LevelMod][m_sampleIndex];
        output = output * smoothedDirectionGating;
 
        killNANs(output);
        return output;
    }
 
    StereoSample GranularOscillator::getNextStereoGranular()
    {
        // The main routine for Granular mode
 
        StereoSample sampleAccumulator;
 
        // Calculate Pitch playBack
        m_detuneModVal = m_parameters[GranularParam::DetuneMod][m_sampleIndex];
        float detuneVal = m_parameters[GranularParam::Detune][m_sampleIndex];
        float playbackHzDetunedMod;
        if (m_detuneModVal == 0)
            playbackHzDetunedMod = m_playbackHz;
        else
            playbackHzDetunedMod =
                    (m_playbackHz * powf(2.0, m_detuneModVal / static_cast<float>(SEMITONES_PER_OCTAVE)));
 
        if (detuneVal == 0)
            m_playbackHzDetuned = playbackHzDetunedMod;
        else
            m_playbackHzDetuned =
                    playbackHzDetunedMod * powf(2.0, detuneVal / static_cast<float>(SEMITONES_PER_OCTAVE));
 
        // Tick the grain timer
        m_grainTimer.nextPhase();
 
        // It is time to launch a new grain if m_grainTimer has wrapped and we can obtain a granular slot
        // m_grainTimer is an instance of the class PhaseGenerator which can be used to keep track of
        // the progression in time though the samples that comprise a complete cycle of a waveform.
        // It is used here simply as a timer to regulate the rate of grain generation.
        // Every sample time the phase is incremented by a delta based on the RATE setting.
        // When the phase angle reaches 1, it wraps back to 0, and sets a flag which
        // can be read by the hasWrapped() method. This is the signal to launch a new grain
        // The sample engine has a finite number of slots available for playing grains, so allocateGrain()
        // can return with a null pointer if all slots are busy. In this case the launching of a new grain
        // is aborted.
        Grain* newGrain = nullptr;
 
        if (m_grainTimer.hasWrapped()) // Time for new grain
        {
            bool shouldLaunchNewGrain = false;
            if (m_isDrone)
            {
                if (m_autoplayEnabled)
                {
                    shouldLaunchNewGrain = true;
                }
            }
            else
            {
                shouldLaunchNewGrain = true;
            }
 
            if (shouldLaunchNewGrain)
            {
                m_sampleEngine->setGrainLimit(static_cast<int>(
                        m_parameters[GranularParam::GrainLim]
                                    [m_sampleIndex])); // TODO: this could be done further up the hierarchy
 
                if (m_keyDown || bool(m_parameters[GranularParam::Quench][m_sampleIndex]) ==
                                         false) // If key is up, quench mode disables new grain generation
                {
                    newGrain = m_sampleEngine->allocateGrain(); // Ask the sample engine for a free grain slot
                    setLoopEnableFlag();
                }
            }
        }
 
        if (newGrain)
        {
            // New flux value is generated every new grain time
            // Slider names: Rate of grain generation - RATE, Randomisation of grain rate - FLUX
            float rand = m_rand.nextFloat() - 0.5f; // rand varies between +- 0.5
            rand *= powf(m_parameters[GranularParam::RateRand][m_sampleIndex],
                         0.3f); // scaled by FLUX parameter, skewed for more action lower down
            if (rand > 0.0f)
            {
                m_fluxFactor = 1.0f + rand * 6.0f; // scaling ranges between 1.0 -> 4.0
            }
            else
            {
                m_fluxFactor = 1.0f + rand * 1.5f; // scaling ranges between 1.0 -> 0.25
            }
        }
 
        if (m_loopingEnable)
        {
            m_grainRate = 0.f;
            m_grainTimer.setFrequency(0.f);
        }
        else
        {
            // The grain launch timer is updated when GranularParam::Rate value changes or isNewGrainTime
            if (newGrain || (m_parameters[GranularParam::Rate][m_sampleIndex] != m_grainRate))
            {
                m_grainRate = m_parameters[GranularParam::Rate][m_sampleIndex];
                m_grainTimer.setFrequency(m_grainRate * m_fluxFactor);
            }
        }
 
        // Time to launch a grain ?
        if (newGrain) // If non-null, means a free grain slot was found and returned
        {
            // The segment index is not incremented in granular mode, but it can be set to a specific index to allow
            // choosing which segment to play.
            int selectedSegment = m_sampleEngine->getNextSegmentIndex();
            int selectionLength = jmax<int>(1, m_sampleEngine->getAudioSelectionLengthInSamples(selectedSegment));
            int segmentLength = jmax<int>(1, m_sampleEngine->getAudioSegmentLengthInSamples(selectedSegment));
 
            m_activeGrains.push_back(newGrain); // We keep our own personal reference to the grains we are playing
 
            // Populate all the properties of the grain ...
 
            // Set the pan randomisation per grain - ranges from -1 to +1
            newGrain->panRand = (m_rand.nextFloat() * 2.f - 1.f) * m_parameters[GranularParam::PanRand][m_sampleIndex];
 
            // Set the width randomisation per grain - ranges from 0 to 1 when full up, to 1 when turned to 0
            newGrain->widthRand = 1.f - m_rand.nextFloat() * m_parameters[GranularParam::WidthRand][m_sampleIndex];
 
            // Calculate start and spray
            // If the combination of start and spray take the spray range off the edge of the sample ...
            // .. then the spray range is shifted forwards or backwards to keep it inside the sample while preserving
            // the spray range size eg if spray is set to 1, start will have no effect whatsoever, as the spray range
            // already covers the entire sample Conversely if spray is set to 0, start will be effective throughout its
            // entire range
 
            int startPositionInSamples =
                    m_sampleEngine->getAudioSelectionStartPosition(selectedSegment) +
                    int(m_parameters[GranularParam::Start][m_sampleIndex] * 0.01f * selectionLength);
 
            int halfSpray = int(0.5f * m_parameters[GranularParam::StartRand][m_sampleIndex] * segmentLength);
 
            Range<int> sprayRange(int(startPositionInSamples - halfSpray), int(startPositionInSamples + halfSpray));
 
            Range<int> constraintRange(m_sampleEngine->getAudioSelectionStartPosition(selectedSegment),
                                       m_sampleEngine->getAudioSelectionStartPosition(selectedSegment) +
                                               m_sampleEngine->getAudioSelectionLengthInSamples(selectedSegment));
 
            Range<int> useableRange = constraintRange.constrainRange(sprayRange);
            newGrain->playHead = (useableRange.getStart() + m_rand.nextFloat() * useableRange.getLength());
 
            newGrain->playHeadStart = static_cast<int>(newGrain->playHead); // For display
 
            int segmentSampleRate = m_sampleEngine->getAudioSegmentSampleRate(selectedSegment);
 
            float gainNormalisationFactor =
                    jmap<float>(m_parameters[GranularParam::Normalise][m_sampleIndex], 1.f,
                                m_sampleEngine->getAudioSegmentNormalisationFactor(selectedSegment));
 
            float resampleRatio = static_cast<float>(segmentSampleRate) /
                                  m_sampleEngine->getSampleRate(); // Calculate the ratio between the DAW sample rate
                                                                   // and the source sample rate
            newGrain->resampleRatio =
                    resampleRatio /
                    m_sampleEngine->getNativeNoteFrequency(); // Compensate by the frequency of the sampled note
 
            // Calculate grain lifetime
            float density = 1.0f - m_parameters[GranularParam::SizeRand][m_sampleIndex] * m_rand.nextFloat();
            int userAdjustedGrainSize = int(m_parameters[GranularParam::Size][m_sampleIndex] * 0.01 * segmentLength);
 
            int grainLength = int(density * userAdjustedGrainSize);
            if (grainLength < 1)
                grainLength = 1;
            if (grainLength > selectionLength)
                grainLength = selectionLength;
 
            // For display
            newGrain->length = grainLength;
 
            newGrain->windowDelta =
                    1.f / float(grainLength); // Calculate the increment needed to go from 0->1 during lifetime of grain
            newGrain->grainWindow = 0.f;      // Reset the window value
 
            // Calculate drift (pitch randomisation)
            newGrain->pitchRand =
                    1.0f + m_parameters[GranularParam::DetuneRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
 
            // Calculate jitter - this implementation is an amplitude variation factor of +-1 centered around 1
            float gain =
                    1.0f + 2.f * m_parameters[GranularParam::LevelRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
            newGrain->gainRand = gain * gain * gainNormalisationFactor;
 
            if (m_isDrone)
            {
                newGrain->flavour = Grain::Flavour::background;
            }
            else
            {
                newGrain->flavour = Grain::Flavour::foreground;
            }
 
            newGrain->voiceIndex = m_voiceIndex;
        }
 
        generateGrainsGranular(sampleAccumulator);
 
        killNANs(sampleAccumulator);
 
        return sampleAccumulator;
    }
 
    StereoSample GranularOscillator::getNextStereoSampler()
    {
        // The main routine for Sampler mode
 
        StereoSample sampleAccumulator;
 
        // Calculate Pitch playBack
        m_detuneModVal = m_parameters[GranularParam::DetuneMod][m_sampleIndex];
        float detuneVal = m_parameters[GranularParam::Detune][m_sampleIndex];
        float playbackHzDetunedMod;
        if (m_detuneModVal == 0)
        {
            playbackHzDetunedMod = m_playbackHz;
        }
        else
        {
            playbackHzDetunedMod =
                    (m_playbackHz * powf(2.0, m_detuneModVal / static_cast<float>(SEMITONES_PER_OCTAVE)));
        }
 
        if (detuneVal == 0)
        {
            m_playbackHzDetuned = playbackHzDetunedMod;
        }
        else
        {
            m_playbackHzDetuned =
                    playbackHzDetunedMod * powf(2.0, detuneVal / static_cast<float>(SEMITONES_PER_OCTAVE));
        }
 
        // Tick the grain timer
        m_grainTimer.nextPhase();
 
        /* It is time to launch a new sample if m_grainTimer has wrapped and we can obtain a granular slot
        m_grainTimer is an instance of the class PhaseGenerator which can be used to keep track of
        the progression in time though the samples that comprise a complete cycle of a waveform.
        It is used here simply as a timer to regulate the rate of sample generation.
        Every sample time the phase is incremented by a delta based on the RATE setting.
        When the phase angle reaches 1, it wraps back to 0, and sets a flag which
        can be read by the hasWrapped() method. This is the signal to launch a new grain
        The sample engine has a finite number of slots available for playing grains, so allocateGrain()
        can return with a null pointer if all slots are busy. In this case the launching of a new grain
        is aborted. */
 
        Grain* newGrain = nullptr;
 
        if (m_grainTimer.hasWrapped()) // Time for new grain
        {
            // Only launch new grains for a drone when autoplay is enabled.
            bool shouldLaunchNewGrain = !m_isDrone || m_autoplayEnabled;
 
            if (shouldLaunchNewGrain)
            {
                m_sampleEngine->setGrainLimit(static_cast<int>(
                        m_parameters[GranularParam::GrainLim]
                                    [m_sampleIndex])); // TODO: this could be done further up the hierarchy
 
                // If key is up, quench mode disables new grain generation
                if (m_keyDown || m_parameters[GranularParam::Quench][m_sampleIndex] <= PARAMETER_TRUE_THRESHOLD)
                {
                    newGrain = m_sampleEngine->allocateGrain(); // Ask the sample engine for a free grain slot
                    setLoopEnableFlag();
                }
            }
        }
 
        if (newGrain)
        {
            // New flux value is generated every new grain time
            // Slider names: Rate of grain generation - RATE, Randomisation of grain rate - FLUX
            float rand = m_rand.nextFloat() - 0.5f; // rand varies between +- 0.5
 
            // scaled by FLUX parameter, skewed for more action lower down
            rand *= powf(m_parameters[GranularParam::RateRand][m_sampleIndex], FLUX_PARAM_SKEW);
 
            // Seperate scaling depending on the sign of rand
            m_fluxFactor = 1.0f + rand * rand > 0.0f ? FLUX_SCALING_POSITIVE : FLUX_SCALING_NEGATIVE;
        }
 
        if (m_loopingEnable)
        {
            m_grainRate = 0.f;
            m_grainTimer.setFrequency(0.f);
        }
        else
        {
            // The grain launch timer is updated when GranularParam::Rate value changes or isNewGrainTime
            if (newGrain || (m_parameters[GranularParam::Rate][m_sampleIndex] != m_grainRate))
            {
                m_grainRate = m_parameters[GranularParam::Rate][m_sampleIndex];
                m_grainTimer.setFrequency(m_grainRate * m_fluxFactor);
            }
        }
 
        // Time to launch a grain ?
        if (newGrain) // If non-null, means a free grain slot was found and returned
        {
            int segmentIndex = m_sampleEngine->getNextSegmentIndex();
 
            // Calculate the next segment index in advance. It can be set externally via setNextSegmentIndex, to allow
            // for user cueing.
            m_sampleEngine->prepareNextSegmentIndex(
                    static_cast<bool>(m_parameters[GranularParam::Robin][m_sampleIndex]));
 
            m_allowAudiosegmentIncrement = false;
 
            m_activeGrains.push_back(newGrain); // We keep our own personal reference to the grains we are playing
 
            // Populate all the properties of the grain ...
 
            // Set the pan randomisation per grain - ranges from -1 to +1
            newGrain->panRand = (m_rand.nextFloat() * 2.f - 1.f) * m_parameters[GranularParam::PanRand][m_sampleIndex];
 
            newGrain->widthRand = 1.f; // Sampler uses no width randomisation
 
            // Calculate start
            newGrain->segmentIndex = segmentIndex;
 
            int segmentSampleRate = m_sampleEngine->getAudioSegmentSampleRate(segmentIndex);
 
            // Calculate the ratio between the DAW sample rate and the source sample rate
            const float resampleRatio = static_cast<float>(segmentSampleRate) / m_sampleEngine->getSampleRate();
 
            m_rampSamples = static_cast<int>(m_samplerate * RAMP_LENGTH_SECONDS);
            m_rampInc = 1.f / static_cast<float>(m_rampSamples) * resampleRatio;
 
            newGrain->resampleRatio =
                    resampleRatio /
                    m_sampleEngine->getNativeNoteFrequency(); // Compensate by the frequency of the sampled note
 
            float gainNormalisationFactor =
                    jmap<float>(m_parameters[GranularParam::Normalise][m_sampleIndex], 1.f,
                                m_sampleEngine->getAudioSegmentNormalisationFactor(segmentIndex));
            // Calculate jitter - this implementation is an amplitude variation factor of +-1 centered around 1
            float gain =
                    1.0f + 2.f * m_parameters[GranularParam::LevelRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
            newGrain->gainRand = gain * gain * gainNormalisationFactor;
 
            newGrain->flavour = m_isDrone ? Grain::Flavour::background : Grain::Flavour::foreground;
 
            newGrain->voiceIndex = m_voiceIndex;
 
            setGrainData(newGrain);
        }
 
        generateGrainsSampler(sampleAccumulator);
 
        killNANs(sampleAccumulator);
 
        return sampleAccumulator;
    }
 
    void GranularOscillator::setGrainData(Grain* playingGrain)
    {
        playingGrain->playHeadStart = m_sampleEngine->getAudioSelectionStartPosition(playingGrain->segmentIndex);
        playingGrain->playHead = static_cast<double>(playingGrain->playHeadStart);
        playingGrain->length =
                jlimit(1, m_length, m_sampleEngine->getAudioSelectionLengthInSamples(playingGrain->segmentIndex));
        // Reset the window value
        playingGrain->grainWindow = 0.f;
        // Calculate the increment needed to go from 0->1 during lifetime of grain
        playingGrain->windowDelta = 1.f / static_cast<float>(playingGrain->length);
        // Calculate drift (pitch randomisation)
        playingGrain->pitchRand =
                1.0f + m_parameters[GranularParam::DetuneRand][m_sampleIndex] * (m_rand.nextFloat() - 0.5f);
        playingGrain->ramp = 0.f;
    }
 
    void GranularOscillator::generateGrainsSampler(StereoSample& sampleAccumulator)
    {
        float gainMod = m_parameters[GranularParam::LevelMod][m_sampleIndex];
        float masterGain = gainMod * Decibels::decibelsToGain(m_parameters[GranularParam::Level][m_sampleIndex]);
        float pan = m_parameters[GranularParam::Pan][m_sampleIndex];
        int grainIndex = static_cast<int>(m_activeGrains.size()) - 1;
 
        // This is the loop which generates the grains.
        // Everything inside will be called per grain, so we have pre-calculated as much as possible before entry (& a
        // bit more can be done in this respect)
        while (grainIndex >= 0)
        {
            Grain* playingGrain = m_activeGrains[size_t(grainIndex)];
            float increment = m_playbackHzDetuned * playingGrain->resampleRatio;
            float randomisedPan = 0.5f * (1.f + jlimit<float>(-1.f, 1.f, pan + playingGrain->panRand));
            playingGrain->envelope = 1.f; // Full amplitude most of the time, only set < 1 when applying shape
 
            float rampVal = 1.f;
            if (m_loopingEnable)
            {
                // Are we ramping down ?
                if (playingGrain->playHead >=
                    static_cast<double>(playingGrain->playHeadStart + playingGrain->length - m_rampSamples))
                {
                    playingGrain->ramp -= m_rampInc;
                    if (playingGrain->ramp < 0.f)
                    {
                        playingGrain->ramp = 0.f;
                    }
                }
                else // Ramping up
                {
                    playingGrain->ramp += m_rampInc;
                    if (playingGrain->ramp > 1.f)
                    {
                        playingGrain->ramp = 1.f;
                    }
                }
 
                // Dont waste an expensive cosf if ramp is 1.0
                if (playingGrain->ramp != 1.f)
                {
                    rampVal = (cosf((1.f - playingGrain->ramp) * MathConstants<float>::pi) + 1.f) * 0.5f;
                }
            }
            else
            {
                // Ensure we are always starting with silence
                // (prevents clicking if user switching looping on and off)
                playingGrain->ramp = 0.f;
            }
 
            // Accumulate audio from all the playing grains
            StereoSample newSample = m_sampleEngine->getInterpolatedSample(playingGrain->playHead);
            sampleAccumulator += newSample.panSine(randomisedPan) * masterGain * playingGrain->gainRand * rampVal;
 
            // Has the grain come to the end of its life ?
            if (playingGrain->playHead >= static_cast<double>(playingGrain->playHeadStart + playingGrain->length))
            {
                setLoopEnableFlag(); // Set here to enable looping to be switched on and off while playing
                if (m_loopingEnable)
                {
                    setGrainData(playingGrain); // Loop back to the start of the selection
                }
                else
                {
                    // If so, release the grain to the sample engine's central pool of grains
                    m_sampleEngine->freeGrain(playingGrain);
                    // then remove its entry from our local list of playing grains
                    m_activeGrains.erase(m_activeGrains.begin() + grainIndex);
                }
            }
            else // If the grain is still playing, we increment the playhead and grain window
            {
                float playheadIncrement = increment * playingGrain->pitchRand;
                playingGrain->playHead += playheadIncrement;                           // Advance the playhead
                playingGrain->grainWindow += playheadIncrement / playingGrain->length; // Keep the grain window in sync
            }
            playingGrain->gainMod = gainMod;
            playingGrain->pitchMod = m_detuneModVal / static_cast<float>(SEMITONES_PER_OCTAVE);
            grainIndex--;
        }
    }
 
    void GranularOscillator::generateGrainsGranular(StereoSample& sampleAccumulator)
    {
        float gainMod = m_parameters[GranularParam::LevelMod][m_sampleIndex];
        float masterGain = gainMod * Decibels::decibelsToGain(m_parameters[GranularParam::Level][m_sampleIndex]);
        float pan = m_parameters[GranularParam::Pan][m_sampleIndex];
        float width = m_parameters[GranularParam::Width][m_sampleIndex];
        float fadePoint = jmax(m_parameters[GranularParam::Shape][m_sampleIndex] * 0.5f, FADE_POINT_MIN);
        int grainIndex = static_cast<int>(m_activeGrains.size()) - 1;
 
        int minGrainsBeforeRampUp = 0;
        if (m_granularOscillatorType == GranularPlaybackMode::MSampler)
        {
            minGrainsBeforeRampUp = 1; // In sampler the first loop when looping does not ramp up, this allows for a
                                       // hard attack from the ADSR if so set
            fadePoint = 0.2f; // Fadepoint hard wired presently for sampler mode - we may expose the "shape" slider at
                              // some point
            width = 1.f; // Sampler uses max width
        }
 
        // This is the loop which generates the grains.
        // Everything inside will be called per grain, so we have pre-calculated as much as possible before entry (& a
        // bit more can be done in this respect)
        while (grainIndex >= 0)
        {
            Grain* playingGrain = m_activeGrains[size_t(grainIndex)];
            float increment = m_playbackHzDetuned * playingGrain->resampleRatio;
            float randomisedPan = 0.5f * (1.f + jlimit<float>(-1.f, 1.f, pan + playingGrain->panRand));
            playingGrain->envelope = 1.f; // Full amplitude most of the time, only set < 1 when ramping up or down.
                                          // Expensive sinf() called only during ramp
 
            if ((playingGrain->grainWindow < fadePoint) &&
                (m_activeGrains.size() > minGrainsBeforeRampUp)) // Are we ramping up ? Dont ramp if this is the first
                                                                 // loop to play (allow full attack)
            {
                // Sine law here provides for equal power crossfading when looping
                playingGrain->envelope = sinf(jmap<float>(playingGrain->grainWindow, 0.f, fadePoint, 0.f, 1.f) *
                                              MathConstants<float>::halfPi);
            }
            else if (playingGrain->grainWindow >= 1.f - fadePoint) // Are we ramping down ?
            {
                playingGrain->envelope = sinf(jmap<float>(playingGrain->grainWindow, 1.f - fadePoint, 1.f, 1.f, 0.f) *
                                              MathConstants<float>::halfPi);
                if ((m_activeGrains.size() < 2) && m_loopingEnable) // We acheive cross-dissolved looping by triggering
                                                                    // a second grain wwhen we start ramping down
                {
                    m_grainTimer.triggerNewGrain(); // Trigger a new grain
                }
            }
 
            // Accumulate audio from all the playing grains
            StereoSample newSample = m_sampleEngine->getInterpolatedSample(playingGrain->playHead);
            sampleAccumulator += newSample.panSine(randomisedPan).width(width * playingGrain->widthRand) * masterGain *
                                 playingGrain->gainRand * playingGrain->envelope;
 
            if (playingGrain->grainWindow >= 1.f) // Has the grain come to the end of its life ?
            {
                m_sampleEngine->freeGrain(
                        playingGrain); // If so, release the grain to the sample engine's central pool of grains
                m_activeGrains.erase(m_activeGrains.begin() +
                                     grainIndex); // then remove its entry from our local list of playing grains
            }
            else // If the grain is still playing, we increment the playhead and grain window
            {
                float playheadIncrement = increment * playingGrain->pitchRand;
                playingGrain->playHead += playheadIncrement;                           // Advance the playhead
                playingGrain->grainWindow += playheadIncrement / playingGrain->length; // Keep the grain window in sync
            }
            playingGrain->gainMod = gainMod;
            playingGrain->pitchMod = m_detuneModVal / static_cast<float>(SEMITONES_PER_OCTAVE);
            grainIndex--;
        }
    }
 
    inline float GranularOscillator::getFrequency() { return m_playbackHz; }
 
    inline double GranularOscillator::getSampleRate() { return m_samplerate; }
 
    inline int GranularOscillator::getNumActiveGrains() { return static_cast<int>(m_activeGrains.size()); }
} // namespace krotos