AudioSampleCircularBuffer.cpp

Go to the documentation of this file.

namespace krotos
{
    AudioSampleCircularBuffer::AudioSampleCircularBuffer(const int numSamples, const long sampleRate) noexcept
        : m_head(0), m_useInterpolation(true), m_size(numSamples), m_sizeAsFloat(static_cast<float>(numSamples)),
          m_sizeMultiple(numSamples * BUFFER_MULTIPLE_FOR_NEG_MODULUS_CALC),
          m_sizeMultipleAsFloat(static_cast<float>(m_sizeMultiple))
    {
        m_circularDelayBuffer = std::make_unique<AudioSampleBuffer>(1, numSamples);
 
        if (numSamples < sampleRate)
        {
            // if the buffer is short set the read position to be the last sample of the delay line.
            m_readPosition = float(numSamples);
        }
        else
        {
            // set the read position to be one seconds worth of samples (at the default rate) inside the buffer.
            m_readPosition = float(m_size - sampleRate);
        }
 
        // NOTE! The length of the buffer should really be updated to reflect the current sample rate.
        // The best place to do this seems to be in prepareToPlay().
 
        m_circularDelayBuffer->clear();
    }
 
    void AudioSampleCircularBuffer::setSize(int numSamples) noexcept
    {
        m_circularDelayBuffer->setSize(1, numSamples);
        m_circularDelayBuffer->clear();
    }
 
    void AudioSampleCircularBuffer::fillWithZeroes()
    {
        FloatVectorOperations::fill(m_circularDelayBuffer->getWritePointer(0), 0.0f,
                                    m_circularDelayBuffer->getNumSamples());
        m_head = 0;
    }
 
    // set the read position - if it moves outside the bounds of the buffer reset it to 0 (to make the buffer circular)
    void AudioSampleCircularBuffer::setReadPosition(float index) noexcept
    {
        m_readPosition = m_head - index;
        m_readPosition = wrapFloatValue(m_readPosition);
    }
 
    // set the read position - if it moves outside the bounds of the buffer reset it to 0 (to make the buffer circular)
    void AudioSampleCircularBuffer::incrementReadPosition() noexcept
    {
        m_readPosition++;
        m_readPosition = wrapFloatValue(m_readPosition);
    }
 
    // copy a block of samples into the buffer
    void AudioSampleCircularBuffer::copySamples(AudioSampleBuffer& source, int numSamples) noexcept
    {
        // if the number of samples will fit inside the buffer without overrunning then just copy them in, and increment
        // m_head and tail:
        float* bufferPointer = m_circularDelayBuffer->getWritePointer(0);
 
        if ((m_head + numSamples) < m_size)
        {
            FloatVectorOperations::fill(bufferPointer + m_head, 0.0f, numSamples);
            m_circularDelayBuffer->copyFrom(0, m_head, source, 0, 0, numSamples);
            m_head += numSamples;
        }
 
        // otherwise we need to copy some samples into the end of the buffer and the remaining samples into the start
        // (to make the buffer circular)
        else
        {
            int numSamplesToReadToEnd = m_size - m_head;
 
            int numSamplesToReadToStart = numSamples - numSamplesToReadToEnd;
 
            FloatVectorOperations::fill(bufferPointer + m_head, 0.0f, numSamplesToReadToEnd);
            FloatVectorOperations::fill(bufferPointer, 0.0f, numSamplesToReadToStart);
 
            m_circularDelayBuffer->copyFrom(0, m_head, source, 0, 0, numSamplesToReadToEnd);
            m_circularDelayBuffer->copyFrom(0, 0, source, 0, numSamplesToReadToEnd, numSamplesToReadToStart);
 
            // we also need to check if the m_head is at zero so we know if we need to manually set the poisition of
            // tail to the end of the buffer
            m_head = (m_head + numSamples) - m_size;
        }
    }
 
    // copy a sample into the buffer
    void AudioSampleCircularBuffer::copySample(float source) noexcept
    {
        m_circularDelayBuffer->setSample(0, m_head, source);
 
        m_head++;
 
        if (m_head >= m_size)
        {
            m_head = m_head - m_size;
        }
    }
 
    void AudioSampleCircularBuffer::addSample(int indexOffset, float newSample) noexcept
    {
        m_circularDelayBuffer->addSample(0, static_cast<int>(wrapFloatValue(float(indexOffset))), newSample);
    }
 
    AudioSampleCircularBuffer::MU::MU(float val)
    {
        index = static_cast<int>(val);
        mu = val - static_cast<float>(index);
        nmu = 1.0f - mu;
    }
 
    float AudioSampleCircularBuffer::fract(float input)
    {
        float retVal = input - static_cast<float>(static_cast<int>(input));
        jassert((retVal >= 0.0f) && (retVal <= 1.0f));
        return retVal;
    }
 
    float AudioSampleCircularBuffer::getSample(float sampleToRead) noexcept
    {
        MU sampleIndex1(wrapFloatValue(sampleToRead));
 
        int sampleIndex2 = sampleIndex1.index + 1;
        if (sampleIndex2 >= m_size)
            sampleIndex2 -= m_size;
 
        const float* delayBufferData = m_circularDelayBuffer->getReadPointer(0);
        float y1 = delayBufferData[sampleIndex1.index];
        float y2 = delayBufferData[sampleIndex2];
 
        float retVal{0.0f};
 
        switch (m_interpolationType)
        {
        case InterpolationType::linear: {
            retVal = y1 * sampleIndex1.nmu + y2 * sampleIndex1.mu;
            break;
        }
 
        // Interpolation method from http://paulbourke.net/miscellaneous/interpolation/
        case InterpolationType::cosine: {
            float mu2 = (1.0f - cosf(sampleIndex1.mu * juce::MathConstants<float>::pi)) / 2;
            retVal = y1 * (1.0f - mu2) + y2 * mu2;
            break;
        }
 
        // Interpolation method from http://paulbourke.net/miscellaneous/interpolation/
        case InterpolationType::cubic: // This is the dodgy one which sounds bad
        {
            int sampleIndex0 = sampleIndex1.index - 1;
            if (sampleIndex0 < 0)
                sampleIndex0 += m_size;
            int sampleIndex3 = sampleIndex2 + 1;
            if (sampleIndex3 >= m_size)
                sampleIndex3 -= m_size;
            float y0 = delayBufferData[sampleIndex0];
            float y3 = delayBufferData[sampleIndex3];
            float mu2 = sampleIndex1.mu * sampleIndex1.mu;
 
            float a0 = y3 - y2 - y0 + y1;
            float a1 = y0 - y1 - a0;
            float a2 = y2 - y0;
            float a3 = y1;
            retVal = a0 * sampleIndex1.mu * mu2 + a1 * mu2 + a2 * sampleIndex1.mu + a3;
            break;
        }
 
        // Interpolation method from http://paulbourke.net/miscellaneous/interpolation/
        case InterpolationType::cubic3d: {
            int sampleIndex0 = sampleIndex1.index - 1;
            if (sampleIndex0 < 0)
                sampleIndex0 += m_size;
            int sampleIndex3 = sampleIndex2 + 1;
            if (sampleIndex3 >= m_size)
                sampleIndex3 -= m_size;
            float y0 = delayBufferData[sampleIndex0];
            float y3 = delayBufferData[sampleIndex3];
            float mu2 = sampleIndex1.mu * sampleIndex1.mu;
 
            float a0 = -0.5f * y0 + 1.5f * y1 - 1.5f * y2 + 0.5f * y3;
            float a1 = y0 - 2.5f * y1 + 2.f * y2 - 0.5f * y3;
            float a2 = -0.5f * y0 + 0.5f * y2;
            float a3 = y1;
            retVal = a0 * sampleIndex1.mu * mu2 + a1 * mu2 + a2 * sampleIndex1.mu + a3;
            break;
        }
        }
 
        return retVal;
    }
} // namespace krotos