OscillatorUtils.cpp

Go to the documentation of this file.

/*
  ==============================================================================
 
    OscillatorUtils.cpp
    Author:  sandy
 
  ==============================================================================
*/
 
namespace krotos
{
    void Grain::setLifetime(int grainPlaybackLength)
    {
        // For display and calculation of grain lifetime
        length = grainPlaybackLength;
 
        // Calculate the increment needed to take grainWindow from 0 to 1 during lifetime of grain
        windowDelta = 1.f / static_cast<float>(grainPlaybackLength);
 
        // Reset the window value
        grainWindow = 0.f;
    }
 
    inline void PhaseGenerator::nextPhase()
    {
        m_phase += m_delta;
        if (m_phase >= 1.0f) // Phase wrap around ?
        {
            m_phase -= 1.0f;
 
            m_loopPhaseCounter++;
            if (m_loopPhaseCounter >= m_loopSize) // Loop wrap around ?
            {
                m_loopPhaseCounter = 0;
                m_newLoop = true;
            }
            else
            {
                m_newLoop = false;
            }
 
            m_loopPhaseCounter2++;
            if (m_loopPhaseCounter2 >= m_loopSize2) // Loop wrap around ?
            {
                m_loopPhaseCounter2 = 0;
                m_newLoop2 = true;
            }
            else
            {
                m_newLoop2 = false;
            }
 
            m_newCycle = true;
        }
        else if (m_phase < 0.0f) // Wrap around backwards ?
        {
            m_phase += 1.0f;
            m_newCycle = false;
        }
        else
        {
            m_newCycle = false;
            m_newLoop = false;
            m_newLoop2 = false;
        }
    }
 
    inline float PhaseGenerator::getPhase() { return m_phase; }
 
    inline float PhaseGenerator::getDelta() { return m_delta; }
 
    inline void PhaseGenerator::setPhaseDelta(float val) { m_delta = val; }
 
    inline void PhaseGenerator::setLoopSize(int val) { m_loopSize = val; }
 
    inline void PhaseGenerator::setLoopSize2(int val) { m_loopSize2 = val; }
 
    inline void PhaseGenerator::setFrequency(float val)
    {
        setPhaseDelta(val * m_sampleRateReciprocal);
        m_frequency = val;
    }
 
    inline float PhaseGenerator::getFrequency() { return m_frequency; }
 
    inline void PhaseGenerator::setPhase(float val)
    {
        m_phase = val;
        m_newCycle = true;
    }
 
    inline void PhaseGenerator::triggerNewGrain()
    {
        setPhase(1.0f); // Reset grain timer to trigger a wraparound, and new grain
    }
 
    inline void PhaseGenerator::mixPhase(float val) { m_phase = (m_phase + val * 2.0f) * 0.3333333333f; }
 
    inline bool PhaseGenerator::hasWrapped() { return m_newCycle; }
 
    inline bool PhaseGenerator::hasLooped() { return m_newLoop; }
 
    inline bool PhaseGenerator::hasLooped2() { return m_newLoop2; }
 
    inline void PhaseGenerator::setSampleRate(float val)
    {
        m_sampleRate = val;
        m_sampleRateReciprocal = 1.0f / m_sampleRate;
    }
 
    // Randomiser
 
    inline bool Randomiser::randomiseIf(bool enable)
    {
        if (enable)
        {
            if (m_range >= 2)
            {
                m_value = (std::rand() % m_range) - m_range / 2;
            }
            else
            {
                m_value = 0;
            }
        }
        return enable;
    }
 
    inline void Randomiser::setRange(int val) { m_range = val; }
 
    inline int Randomiser::getValue() { return m_value; }
 
    // DeClicker
 
    inline float DeClicker::processSample(float sample) // Inline for speed
    {
        float difference = sample - m_previousSample;
 
        if (m_triggered) // Has de-click been triggered ?
        {
            m_ramp = -difference;
            m_delta = difference / m_length;
            m_triggered = false;
        }
 
        float retval = sample + m_ramp;
 
        m_ramp += m_delta;
        if ((m_delta > 0.0f && m_ramp > 0.0f) || (m_delta < 0.0f && m_ramp < 0.0f))
        {
            m_ramp = m_delta = 0.0f;
        }
 
        m_previousSample = retval; // We keep a copy of the result for comparison next time around
 
        return retval; // and return the result
    }
 
    inline float DeClicker::getRamp() // Inline for speed
    {
        if (m_triggered) // Has de-click been triggered ?
        {
            m_ramp = 1.0f;
            m_delta = m_ramp / m_length;
            m_triggered = false;
        }
 
        m_ramp -= m_delta;
 
        if (m_ramp < 0.0f)
        {
            m_ramp = 0.0f;
            m_delta = 0.0f;
        }
 
        return m_ramp; // and return the result
    }
 
    inline void DeClicker::setLength(float val) { m_length = val; }
 
    inline void DeClicker::trigger() { m_triggered = true; }
 
    inline bool DeClicker::triggerIf(bool enable)
    {
        if (enable)
        {
            m_triggered = true;
        }
        return enable;
    }
 
    inline bool DeClicker::isActive() { return (m_delta != 0.0f) || m_triggered; }
 
    // SlewLimiter
 
    inline float SlewLimiter::processSample(float sample) // Inline for speed
    {
        float difference = sample - m_previousSample;
 
        if (difference > m_maxSlewPosative) // Are we getting bigger at a rate faster than max slew posative ?
        {
            sample = m_previousSample + m_maxSlewPosative; // ... if yes, we get bigger only by max slew posative
        }
        else if (difference <
                 m_maxSlewNegative) // Else are we getting smaller at a rate faster than max slew negative ?
        {
            sample = m_previousSample + m_maxSlewNegative; // ... if yes, we get smaller only by max slew negative
        }
 
        // Otherwise we do not change the input sample at all
 
        m_previousSample = sample; // We keep a copy of the result for comparison next time around
        return sample;             // and return the result
    }
 
    inline float SlewLimiter::processSample(float sample, bool enable) // Inline for speed
    {
        float difference = sample - m_previousSample;
 
        if (enable)
        {
            if (difference > m_maxSlewPosative) // Are we getting bigger at a rate faster than max slew posative ?
            {
                sample = m_previousSample + m_maxSlewPosative; // ... if yes, we get bigger only by max slew posative
            }
            else if (difference <
                     m_maxSlewNegative) // Else are we getting smaller at a rate faster than max slew negative ?
            {
                sample = m_previousSample + m_maxSlewNegative; // ... if yes, we get smaller only by max slew negative
            }
        }
        // Otherwise we do not change the input sample at all
 
        m_previousSample = sample; // We keep a copy of the result for comparison next time around
        return sample;             // and return the result
    }
 
    void SlewLimiter::setMaxSlewRate(float val)
    {
        m_maxSlewPosative = val;
        m_maxSlewNegative = -val;
    }
 
    void SlewLimiter::setMaxSlewRates(float valPosative, float valNegative)
    {
        m_maxSlewPosative = valPosative;
        m_maxSlewNegative = valNegative;
    }
 
    void MouseVelocityExtractor::process()
    {
        // Everything which can be done on a per-block basis
        m_velocity = fabs(m_input - m_previousInput) * m_calibration;
        m_previousInput = m_input;
        m_smoothedVelocity.setTarget(m_samplesPerBlock, m_velocity);
    }
 
    void MouseVelocityExtractor::setInput(float val) { m_input = val; }
 
    float MouseVelocityExtractor::getOutput()
    {
        auto ret = jmax<float>(jmin<float>(m_smoother.processSample(m_smoothedVelocity.getSmoothedValue()), 1.f), 0.f);
 
        if (ret == 0.f)
        {
            m_smoother.reset(); // Kill bounce
        }
        return ret;
    }
 
    void MouseVelocityExtractor::prepare(double sampleRate, int samplesPerBlock)
    {
        m_sampleRate = sampleRate;
        m_samplesPerBlock = samplesPerBlock;
        m_blockRateHZ = static_cast<float>(m_sampleRate) / static_cast<float>(samplesPerBlock);
        m_calibration = CALIBRATION_FACTOR * m_blockRateHZ;
        m_smoother.coefficients =
                dsp::IIR::Coefficients<float>::makeLowPass(sampleRate, VELOCITY_LP_FILTER_HZ, VELOCITY_LP_FILTER_Q);
    }
 
} // namespace krotos