ConvolutionReverb.cpp

Go to the documentation of this file.

namespace krotos
{
    ConvolutionReverb::ConvolutionReverb()
    {
        for (int i = 0; i < 4; i++)
            m_convolvers.add(new IRConvolver());
    }
 
    ConvolutionReverb::~ConvolutionReverb() {}
 
    void ConvolutionReverb::prepareNextBlock(const float* const* buffer, int numSamples, int numChannels)
    {
        // TODO: make this class optionally mono
        jassert(numChannels == 2);
 
        m_dryBuffer.copyFrom(LEFT, 0, buffer[LEFT], numSamples);
        m_dryBuffer.copyFrom(RIGHT, 0, buffer[RIGHT], numSamples);
 
        std::fill(m_convolutionBufferLL.begin(), m_convolutionBufferLL.end(), 0.0f);
        std::fill(m_convolutionBufferLR.begin(), m_convolutionBufferLR.end(), 0.0f);
        std::fill(m_convolutionBufferRL.begin(), m_convolutionBufferRL.end(), 0.0f);
        std::fill(m_convolutionBufferRR.begin(), m_convolutionBufferRR.end(), 0.0f);
 
        for (int i = 0; i < numSamples; i++)
            for (int j = 0; j < numChannels; j++)
                m_wetBuffer.setSample(j, i, 0.0f);
 
        IRConvolver* convolverLL = m_convolvers[0];
        IRConvolver* convolverLR = m_convolvers[1];
        IRConvolver* convolverRL = m_convolvers[2];
        IRConvolver* convolverRR = m_convolvers[3];
 
        if (convolverLL && convolverLL->getConvolver())
        {
            convolverLL->process(buffer[LEFT], &m_convolutionBufferLL[0], numSamples);
            m_wetBuffer.addFrom(0, 0, &m_convolutionBufferLL[0], numSamples);
        }
 
        if (convolverLR && convolverLR->getConvolver())
        {
            convolverLR->process(buffer[LEFT], &m_convolutionBufferLR[0], numSamples);
            m_wetBuffer.addFrom(1, 0, &m_convolutionBufferLR[0], numSamples);
        }
 
        if (convolverRL && convolverRL->getConvolver())
        {
            convolverRL->process(buffer[RIGHT], &m_convolutionBufferRL[0], numSamples);
            m_wetBuffer.addFrom(0, 0, &m_convolutionBufferRL[0], numSamples);
        }
 
        if (convolverRR && convolverRR->getConvolver())
        {
            convolverRR->process(buffer[RIGHT], &m_convolutionBufferRR[0], numSamples);
            m_wetBuffer.addFrom(1, 0, &m_convolutionBufferRR[0], numSamples);
        }
    }
 
    float ConvolutionReverb::getNextSample(int sampleIdx, int channelIdx)
    {
        float wetSample = m_wetBuffer.getSample(channelIdx, sampleIdx);
        float drySample = m_dryBuffer.getSample(channelIdx, sampleIdx);
        auto predelayPtr = m_predelayBuffers[channelIdx];
 
        predelayPtr->copySample(wetSample);
        float idx = predelayPtr->getHead() - m_predelay - 1.0f;
        wetSample = m_outputGain * predelayPtr->getSample(idx);
 
        return m_mix.dry() * drySample + m_mix.wet() * wetSample;
    }
 
    void ConvolutionReverb::processBlock(AudioBuffer<float>& buffer)
    {
        auto bufferPtr = buffer.getArrayOfWritePointers();
        int numSamples = buffer.getNumSamples();
        int numChannels = buffer.getNumChannels();
 
        prepareNextBlock(bufferPtr, numSamples, numChannels);
 
        for (int i = 0; i < numSamples; i++)
            for (int j = 0; j < numChannels; j++)
                bufferPtr[j][i] = getNextSample(i, j);
    }
 
    double ConvolutionReverb::getSampleRate() const
    {
        juce::ScopedLock convolverLock(m_convolverMutex);
        return m_sampleRate;
    }
 
    void ConvolutionReverb::setSampleRate(double newSampleRate)
    {
        {
            juce::ScopedLock convolverLock(m_convolverMutex);
            m_sampleRate = newSampleRate;
        }
 
        reset();
    }
 
    void ConvolutionReverb::setMix(float mix) { m_mix = mix; }
 
    void ConvolutionReverb::setOutputGainDb(float gainDb) { m_outputGain = std::pow(10.0f, gainDb / 20.0f); }
 
    void ConvolutionReverb::setPredelayMs(float predelayMs)
    {
        m_predelay = static_cast<float>(predelayMs * m_sampleRate / 1e3f);
    }
 
    void ConvolutionReverb::reset()
    {
        int predelayBufferSize = static_cast<int>(m_maxPredelayMs * m_sampleRate / 1e3f);
        for (int i = 0; i < m_numOutputChannels; i++)
            m_predelayBuffers.set(i,
                                  new AudioSampleCircularBuffer(predelayBufferSize, static_cast<long>(m_sampleRate)));
    }
 
    void ConvolutionReverb::prepareToPlay(double sampleRate, int samplesPerBlock)
    {
        if (m_sampleRate != sampleRate)
            setSampleRate(sampleRate);
 
        {
            juce::ScopedLock convolverLock(m_convolverMutex);
            m_convolverHeadBlockSize = 1;
            while (m_convolverHeadBlockSize < static_cast<size_t>(samplesPerBlock))
            {
                m_convolverHeadBlockSize *= 2;
            }
            m_convolverTailBlockSize = std::max(size_t(8192), 2 * m_convolverHeadBlockSize);
        }
 
        m_wetBuffer.setSize(m_numOutputChannels, samplesPerBlock);
        m_dryBuffer.setSize(m_numOutputChannels, samplesPerBlock);
        m_convolutionBufferLL.resize(static_cast<size_t>(samplesPerBlock));
        m_convolutionBufferLR.resize(static_cast<size_t>(samplesPerBlock));
        m_convolutionBufferRL.resize(static_cast<size_t>(samplesPerBlock));
        m_convolutionBufferRR.resize(static_cast<size_t>(samplesPerBlock));
 
        updateConvolvers();
    }
 
    const OwnedArray<IRConvolver>& ConvolutionReverb::getConvolvers() const
    {
        juce::ScopedLock convolverLock(m_convolverMutex);
        return m_convolvers;
    }
 
    void ConvolutionReverb::updateConvolvers()
    {
        juce::ScopedLock irCalculationlock(m_irCalculationMutex);
        if (m_irCalculation)
        {
            m_irCalculation->stopThread(-1);
            m_irCalculation = nullptr;
        }
        m_irCalculation.reset(new ConvolutionComputationThread(*this));
    }
 
    void ConvolutionReverb::clearConvolvers()
    {
        for (int i = 0; i < m_convolvers.size(); i++)
            m_convolvers[i]->clearConvolver();
    }
 
    size_t ConvolutionReverb::getConvolverHeadBlockSize() const
    {
        juce::ScopedLock convolverLock(m_convolverMutex);
        return m_convolverHeadBlockSize;
    }
 
    size_t ConvolutionReverb::getConvolverTailBlockSize() const
    {
        juce::ScopedLock convolverLock(m_convolverMutex);
        return m_convolverTailBlockSize;
    }
 
    String ConvolutionReverb::getImpulseResponseFilePath() const
    {
        juce::ScopedLock convolverLock(m_convolverMutex);
        return m_impulseResponseFilePath;
    }
 
    void ConvolutionReverb::setImpulseResponseFilePath(const String& impulseResponseFilePath)
    {
        {
            juce::ScopedLock convolverLock(m_convolverMutex);
            m_impulseResponseFilePath = impulseResponseFilePath;
        }
        updateConvolvers();
    }
} // namespace krotos