juce_DelayLine.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
namespace dsp
{
 
//==============================================================================
namespace DelayLineInterpolationTypes
{
    struct None {};

    struct Linear {};

    struct Lagrange3rd {};

    struct Thiran {};
}
 
//==============================================================================
template <typename SampleType, typename InterpolationType = DelayLineInterpolationTypes::Linear>
class DelayLine
{
public:
    //==============================================================================
    DelayLine();

    explicit DelayLine (int maximumDelayInSamples);
 
    //==============================================================================
    void setDelay (SampleType newDelayInSamples);

    SampleType getDelay() const;
 
    //==============================================================================
    void prepare (const ProcessSpec& spec);

    void setMaximumDelayInSamples (int maxDelayInSamples);

    int getMaximumDelayInSamples() const noexcept       { return totalSize - 1; }

    void reset();
 
    //==============================================================================
    void pushSample (int channel, SampleType sample);

    SampleType popSample (int channel, SampleType delayInSamples = -1, bool updateReadPointer = true);
 
    //==============================================================================
    template <typename ProcessContext>
    void process (const ProcessContext& context) noexcept
    {
        const auto& inputBlock = context.getInputBlock();
        auto& outputBlock      = context.getOutputBlock();
        const auto numChannels = outputBlock.getNumChannels();
        const auto numSamples  = outputBlock.getNumSamples();
 
        jassert (inputBlock.getNumChannels() == numChannels);
        jassert (inputBlock.getNumChannels() == writePos.size());
        jassert (inputBlock.getNumSamples()  == numSamples);
 
        if (context.isBypassed)
        {
            outputBlock.copyFrom (inputBlock);
            return;
        }
 
        for (size_t channel = 0; channel < numChannels; ++channel)
        {
            auto* inputSamples = inputBlock.getChannelPointer (channel);
            auto* outputSamples = outputBlock.getChannelPointer (channel);
 
            for (size_t i = 0; i < numSamples; ++i)
            {
                pushSample ((int) channel, inputSamples[i]);
                outputSamples[i] = popSample ((int) channel);
            }
        }
    }
 
private:
    //==============================================================================
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::None>::value, SampleType>::type
    interpolateSample (int channel) const
    {
        auto index = (readPos[(size_t) channel] + delayInt) % totalSize;
        return bufferData.getSample (channel, index);
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Linear>::value, SampleType>::type
    interpolateSample (int channel) const
    {
        auto index1 = readPos[(size_t) channel] + delayInt;
        auto index2 = index1 + 1;
 
        if (index2 >= totalSize)
        {
            index1 %= totalSize;
            index2 %= totalSize;
        }
 
        auto value1 = bufferData.getSample (channel, index1);
        auto value2 = bufferData.getSample (channel, index2);
 
        return value1 + delayFrac * (value2 - value1);
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Lagrange3rd>::value, SampleType>::type
    interpolateSample (int channel) const
    {
        auto index1 = readPos[(size_t) channel] + delayInt;
        auto index2 = index1 + 1;
        auto index3 = index2 + 1;
        auto index4 = index3 + 1;
 
        if (index4 >= totalSize)
        {
            index1 %= totalSize;
            index2 %= totalSize;
            index3 %= totalSize;
            index4 %= totalSize;
        }
 
        auto* samples = bufferData.getReadPointer (channel);
 
        auto value1 = samples[index1];
        auto value2 = samples[index2];
        auto value3 = samples[index3];
        auto value4 = samples[index4];
 
        auto d1 = delayFrac - 1.f;
        auto d2 = delayFrac - 2.f;
        auto d3 = delayFrac - 3.f;
 
        auto c1 = -d1 * d2 * d3 / 6.f;
        auto c2 = d2 * d3 * 0.5f;
        auto c3 = -d1 * d3 * 0.5f;
        auto c4 = d1 * d2 / 6.f;
 
        return value1 * c1 + delayFrac * (value2 * c2 + value3 * c3 + value4 * c4);
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Thiran>::value, SampleType>::type
    interpolateSample (int channel)
    {
        auto index1 = readPos[(size_t) channel] + delayInt;
        auto index2 = index1 + 1;
 
        if (index2 >= totalSize)
        {
            index1 %= totalSize;
            index2 %= totalSize;
        }
 
        auto value1 = bufferData.getSample (channel, index1);
        auto value2 = bufferData.getSample (channel, index2);
 
        auto output = delayFrac == 0 ? value1 : value2 + alpha * (value1 - v[(size_t) channel]);
        v[(size_t) channel] = output;
 
        return output;
    }
 
    //==============================================================================
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::None>::value, void>::type
    updateInternalVariables()
    {
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Linear>::value, void>::type
    updateInternalVariables()
    {
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Lagrange3rd>::value, void>::type
    updateInternalVariables()
    {
        if (delayInt >= 1)
        {
            delayFrac++;
            delayInt--;
        }
    }
 
    template <typename T = InterpolationType>
    typename std::enable_if <std::is_same <T, DelayLineInterpolationTypes::Thiran>::value, void>::type
    updateInternalVariables()
    {
        if (delayFrac < (SampleType) 0.618 && delayInt >= 1)
        {
            delayFrac++;
            delayInt--;
        }
 
        alpha = (1 - delayFrac) / (1 + delayFrac);
    }
 
    //==============================================================================
    double sampleRate;
 
    //==============================================================================
    AudioBuffer<SampleType> bufferData;
    std::vector<SampleType> v;
    std::vector<int> writePos, readPos;
    SampleType delay = 0.0, delayFrac = 0.0;
    int delayInt = 0, totalSize = 4;
    SampleType alpha = 0.0;
};
 
} // namespace dsp
} // namespace juce