ReformerOscillator.cpp

Go to the documentation of this file.

/*
==============================================================================
 
        ReformerOscillator.cpp
        Sample based oscillator / reformer engine
        Author: Sandy
        Date: 19/08/2020
 
==============================================================================
*/
 
namespace krotos
{
    ReformerOscillator::ReformerOscillator() { m_parameters.resize(GranularParam::NUM_PARAMS); }
 
    void ReformerOscillator::setGranularParameter(size_t paramIndex, const float* newValue)
    {
        jassert(paramIndex >= 0 && paramIndex < GranularParam::NUM_PARAMS);
        m_parameters[paramIndex] = newValue;
    }
 
    inline void ReformerOscillator::setGranularParameters(std::vector<const float*>& newParams)
    {
        jassert(newParams.size() == m_parameters.size());
        m_parameters = newParams;
    }
 
    inline void ReformerOscillator::setSampleRate(double sampleRate)
    {
        m_samplerate = sampleRate;
        m_voicePhase.setSampleRate(static_cast<float>(m_samplerate));
        m_voicePhase.setFrequency(100.0f);
        m_popcornTimer.setSampleRate(static_cast<float>(m_samplerate));
        m_popcornTimer.setFrequency(100.0f);
        m_channelCrossfade.setMaxSlewRate(2.f / static_cast<float>(sampleRate));
    }
 
    void ReformerOscillator::setSampleData(SampleEngine* sampleEngine) { m_sampleEngine = sampleEngine; }
 
    // Remove all playing grains from the active grains list
    void ReformerOscillator::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 ReformerOscillator::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 ReformerOscillator::cube(float val) { return val * val * val; }
 
    void ReformerOscillator::startNote(int midiNote, float velocity, int voiceIndex)
    {
        m_voiceIndex = voiceIndex; // Used finally merely to indicate on the UX the
                                   // voice index of each playhead
 
        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;
 
        setFrequency(static_cast<float>(MidiMessage::getMidiNoteInHertz(midiNote & MIDI_NOTE_MASK)));
        m_voicePhase.triggerNewGrain(); // Trigger a new grain
    }
 
    void ReformerOscillator::stopNote() { m_keyDown = false; }
 
    const float ReformerOscillator::getVelocity() { return m_velocity; }
 
    void ReformerOscillator::clearNote()
    {
        m_keyDown = false;
        if (!m_stopped)
        {
            m_stopped = true;
            flushGranular();
        }
    }
 
    inline void ReformerOscillator::setTaggingType(bool isOn) { m_taggingType = isOn; }
 
    inline void ReformerOscillator::setTrackingEnable(bool isOn) { m_trackingEnable = isOn; }
 
    inline void ReformerOscillator::setHardLoopEnable(bool isOn) { m_loopingEnable = isOn; }
 
    inline void ReformerOscillator::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
    }
 
    double ReformerOscillator::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* ReformerOscillator::launchGrain(float paramSize, float paramStart, float paramSpray, Grain::Flavour flavour,
                                           float gain)
    {
        const float minimumGrainLength{0.1f};
 
        bool checkGrain = false;
        if (m_isDrone)
        {
            if (m_autoplayEnabled)
            {
                checkGrain = true;
            }
        }
        else
        {
            checkGrain = true;
        }
 
        if (checkGrain)
        {
            // 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 =
                        static_cast<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->gainRand = gain * gain;
                newGrain->pitchRand = pitchRand;
                newGrain->flavour = flavour;
            }
 
            return newGrain;
        }
 
        return nullptr;
    }
 
    inline StereoSample ReformerOscillator::getNextStereoSample(size_t sampleIndex)
    {
        if (m_sampleEngine == nullptr)
        {
            return StereoSample{}; // Return silence if no sample data
        }
 
        if (!m_sampleEngine->analysisResultsAreValid()) // If analysis isn't valid
        {
            return StereoSample{}; // Return silence
        }
 
        if (m_stopped)
        {
            return StereoSample{}; // Return silence if engine stopped
        }
 
        if (m_sampleEngine->getProgressTracker().isLoading())
        {
            return StereoSample{}; // Return silence if sample engine is loading
        }
 
        m_autoplayEnabled = bool(m_parameters[GranularParam::Autoplay][0] > 0.5f);
 
        m_sampleIndex = sampleIndex;
        m_length = m_sampleEngine->getNumSamples();
 
        return getNextStereoGranularSample();
    }
 
    inline int clamp(int val, int min, int max) { return jmin<int>(jmax<int>(val, min), max); }
 
    inline float ReformerOscillator::getRateRandFactor()
    {
        // A new m_rateRandFactor value is generated every new grain time
        float rand = m_rand.nextFloat() - 0.5f; // rand varies between +- 0.5
        // scaled by Rate parameter, skewed for more action lower down
        rand *= powf(m_parameters[GranularParam::RateRand][m_sampleIndex], 0.3f);
        if (rand > 0.0f)
            return 1.0f + rand * 6.0f;
        else
            return 1.0f + rand * 1.5f;
    }
 
    int debugCounter = 0;
 
    inline StereoSample ReformerOscillator::getNextStereoGranularSample()
    {
        StereoSample sampleAccumulator;
 
        int segmentIndex = 0;
 
        bool popcornMode = false;
        if (m_parameters[GranularParam::Popcorn] != NULL)
            popcornMode = static_cast<bool>(m_parameters[GranularParam::Popcorn][0]);
 
        if (m_parameters[GranularParam::Proximity] != NULL)
        {
            m_proximityMode = static_cast<bool>(m_parameters[GranularParam::Proximity][0]);
        }
 
        setHardLoopEnable(bool(m_parameters[GranularParam::SALoop][m_sampleIndex] > 0.5f));
 
        m_puckPosition = Point<float>{m_parameters[GranularParam::PuckX][0], m_parameters[GranularParam::PuckY][0]};
 
        // 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_voicePhase.nextPhase();
 
        Grain* newGrain = nullptr;
        // It is time to launch a new grain if m_grainTimer has wrapped and we can obtain a granular slot
        if (m_voicePhase.hasWrapped()) // Time for new grain
        {
            if (!m_isDrone || (m_isDrone && m_autoplayEnabled))
            {
                // If key is up, quench mode disables new grain generation
                if (m_keyDown || bool(m_parameters[GranularParam::Quench][m_sampleIndex]) == false)
                {
                    bool inhibitGrainGeneration = false;
 
                    if (popcornMode)
                    {
                        auto nearestGrainIndex =
                                m_sampleEngine->getNearestNeighbour2D(m_puckPosition.x, m_puckPosition.y);
                        if (m_nearestGrainIndex == nearestGrainIndex)
                        {
                            inhibitGrainGeneration = true;
                        }
                        m_nearestGrainIndex = nearestGrainIndex;
                    }
                    else if (m_proximityMode)
                    {
                        const float radius = m_parameters[GranularParam::Radius][m_sampleIndex];
                        const auto nearestIndexes =
                                m_sampleEngine->getNearestNeighbour2D(m_puckPosition.x, m_puckPosition.y, radius);
                        if ((!nearestIndexes.empty()) && (!m_proximityTrigger))
                        {
                            m_nearestGrainIndex = nearestIndexes[rand() % nearestIndexes.size()];
                        }
                        else
                        {
                            inhibitGrainGeneration = true;
                        }
                        m_proximityTrigger = !nearestIndexes.empty();
                    }
                    else
                    {
                        // return this many nearest grains
                        size_t n = static_cast<size_t>(m_parameters[GranularParam::Nearest][m_sampleIndex]);
                        auto nearestIndexes =
                                m_sampleEngine->getNearestNeighbour2D(m_puckPosition.x, m_puckPosition.y, n);
                        m_nearestGrainIndex = nearestIndexes[rand() % nearestIndexes.size()];
                    }
 
                    if (!inhibitGrainGeneration)
                    {
                        m_sampleEngine->setGrainLimit(
                                static_cast<int>(m_parameters[GranularParam::GrainLim][m_sampleIndex]));
                        // Ask the sample engine for a free grain slot
                        newGrain = m_sampleEngine->allocateGrain();
                    }
                }
            }
        }
 
        // Detect the case where looping and popcorn are enabled and
        // grains have stop playing because the crossfade has played out
        // and the puck is static
        if (m_loopingEnable && popcornMode && !m_activeGrains.size())
        {
            // Tick the popcorn timer
            m_popcornTimer.nextPhase();
            // This is done on a timer - otherwise it would happen at sample rate
            if (m_popcornTimer.hasWrapped())
            {
                // Triggering a new grain here gives the popcorn mechanism
                // an opportunity to test for a new nearest neighbour
                // without that, we are stuck with no sound forever
                m_voicePhase.triggerNewGrain();
            }
        }
 
        // The grain launch timer is updated when GranularParam::Rate value changes or isNewGrainTime
        float newGrainRate = m_parameters[GranularParam::Rate][m_sampleIndex];
        bool grainRateChanged = m_grainRate != newGrainRate;
        m_grainRate = newGrainRate;
        if (newGrain || grainRateChanged)
        {
            if (m_loopingEnable)
            {
                m_grainRate = 0.f;
                m_voicePhase.setFrequency(0.f);
            }
            else
            {
                float grainRate = m_grainRate * getRateRandFactor();
                m_voicePhase.setFrequency(grainRate);
                m_popcornTimer.setFrequency(grainRate);
            }
        }
 
        // Time to launch a grain ?
        if (newGrain) // If non-null, means a free grain slot was found and returned
        {
            m_activeGrains.push_back(newGrain); // We keep a local 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->getGrainDescriptionByTime()[m_nearestGrainIndex].audioIndex;
            newGrain->principalX = m_sampleEngine->getGrainDescriptionByTime()[m_nearestGrainIndex].principalX;
            newGrain->principalY = m_sampleEngine->getGrainDescriptionByTime()[m_nearestGrainIndex].principalY;
            newGrain->principalZ = m_sampleEngine->getGrainDescriptionByTime()[m_nearestGrainIndex].principalZ;
            newGrain->principalQ = m_sampleEngine->getGrainDescriptionByTime()[m_nearestGrainIndex].principalQ;
            newGrain->grainSize = m_sampleEngine->getGrainDescriptionByTime()[m_nearestGrainIndex].grainSize;
 
            int halfSpray = static_cast<int>(0.5f * m_parameters[GranularParam::StartRand][m_sampleIndex] * m_length);
            Range<int> sprayRange(static_cast<int>(startPositionInSamples - halfSpray),
                                  static_cast<int>(startPositionInSamples + halfSpray));
            Range<int> constraintRange(0, m_length);
            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 = static_cast<int>(m_samplerate);
            segmentSampleRate = m_sampleEngine->getAudioSegmentSampleRate(segmentIndex);
 
            float gainNormalisationFactor = m_sampleEngine->getAudioSegmentNormalisationFactor(segmentIndex);
 
            gainNormalisationFactor =
                    jmap<float>(m_parameters[GranularParam::Normalise][m_sampleIndex], 1.f, gainNormalisationFactor);
 
            // Calculate the ratio between the DAW sample rate and the source sample rate
            float resampleRatio = static_cast<float>(segmentSampleRate) / m_sampleEngine->getSampleRate();
 
            // Compensate by the frequency of the sampled note
            newGrain->resampleRatio = resampleRatio / m_sampleEngine->getNativeNoteFrequency();
 
            // Calculate variations in grain size - sizeRandomiser will fluctuate between 0 and 1
            float sizeRandomiser = 1.0f - m_parameters[GranularParam::SizeRand][m_sampleIndex] * m_rand.nextFloat();
            float grainSizeInSamples = m_parameters[GranularParam::Size][m_sampleIndex] * 0.01f * newGrain->grainSize;
            newGrain->setLifetime(clamp(static_cast<int>(sizeRandomiser * grainSizeInSamples), 1, m_length));
 
            // 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;
 
            m_isDrone ? newGrain->flavour = Grain::Flavour::background : newGrain->flavour = Grain::Flavour::foreground;
 
            newGrain->voiceIndex = m_voiceIndex;
        }
 
        generateGrains(sampleAccumulator);
 
        killNANs(sampleAccumulator);
 
        return sampleAccumulator;
    }
 
    void ReformerOscillator::generateGrains(StereoSample& sampleAccumulator)
    {
        float gainMod = m_parameters[GranularParam::LevelMod][m_sampleIndex];
        float masterGain = gainMod * Decibels::decibelsToGain(m_parameters[GranularParam::Level][m_sampleIndex]);
        masterGain *= Decibels::decibelsToGain(m_parameters[GranularParam::GranularLevel][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;
 
        // 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) // Are we ramping up ?
            {
                // 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_voicePhase.triggerNewGrain(); // Trigger a new grain
                }
            }
 
            if (m_proximityMode)
            {
                // use a rectangular window for one-shot grains
                playingGrain->envelope = 1.0f;
            }
 
            // 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 ReformerOscillator::getFrequency() { return m_playbackHz; }
 
    inline double ReformerOscillator::getSampleRate() { return m_samplerate; }
 
    inline int ReformerOscillator::getNumActiveGrains() { return static_cast<int>(m_activeGrains.size()); }
} // namespace krotos