ConvolutionComputationThread.cpp

Go to the documentation of this file.

namespace krotos
{
    class FloatBufferSource : public AudioSource
    {
      public:
        explicit FloatBufferSource(const FloatBuffer::Ptr& sourceBuffer)
            : juce::AudioSource(), m_sourceBuffer(sourceBuffer), m_pos(0)
        {
        }
 
        virtual void prepareToPlay(int /*samplesPerBlockExpected*/, double /*sampleRate*/) { m_pos = 0; }
 
        virtual void releaseResources() { m_pos = 0; }
 
        virtual void getNextAudioBlock(const AudioSourceChannelInfo& bufferToFill)
        {
            AudioSampleBuffer* destBuffer = bufferToFill.buffer;
            const int len = std::min(bufferToFill.numSamples, static_cast<int>(m_sourceBuffer->getSize() - m_pos));
            if (destBuffer)
            {
                for (int channel = 0; channel < destBuffer->getNumChannels(); ++channel)
                {
                    if (channel == 0 && m_sourceBuffer)
                    {
                        destBuffer->copyFrom(channel, bufferToFill.startSample, m_sourceBuffer->data() + m_pos, len);
                        if (len < bufferToFill.numSamples)
                        {
                            const int startClear = bufferToFill.startSample + len;
                            const int lenClear = bufferToFill.numSamples - len;
                            destBuffer->clear(startClear, lenClear);
                        }
                    }
                    else
                    {
                        destBuffer->clear(channel, bufferToFill.startSample, bufferToFill.numSamples);
                    }
                }
            }
            m_pos += static_cast<size_t>(len);
        }
 
      private:
        const FloatBuffer::Ptr& m_sourceBuffer;
        size_t m_pos;
 
        FloatBufferSource(const FloatBufferSource&);
        FloatBufferSource& operator=(const FloatBufferSource&);
    };
 
    // ===================================================================
 
    ConvolutionComputationThread::ConvolutionComputationThread(ConvolutionReverb& processor)
        : juce::Thread("ConvolutionComputationThread"), m_processor(processor)
    {
        startThread();
    }
 
    ConvolutionComputationThread::~ConvolutionComputationThread() { stopThread(-1); }
 
    void ConvolutionComputationThread::run()
    {
        if (threadShouldExit() || m_processor.getImpulseResponseFilePath() == "")
        {
            return;
        }
 
        File irFile{m_processor.getImpulseResponseFilePath()};
        if (!irFile.existsAsFile())
            return;
 
        const auto& convolvers = m_processor.getConvolvers();
        int numConvolvers = convolvers.size();
 
        std::vector<FloatBuffer::Ptr> buffers;
 
        juce::AudioFormatManager formatManager;
        formatManager.registerBasicFormats();
        std::unique_ptr<AudioFormatReader> reader(formatManager.createReaderFor(irFile));
        double fileSampleRate = reader->sampleRate;
 
        // add an audio buffer for each convolver
        int fileChannels = static_cast<int>(reader->numChannels);
        if (fileChannels < 1 || fileChannels > 2) // only mono & stereo IR's are supported currently
            return;
 
        bool isMono = fileChannels == 1;
        for (int i = 0; i < numConvolvers; ++i)
            if (!threadShouldExit())
                buffers.push_back(importChannelFromAudioFile(reader.get(), isMono ? 0 : i % 2));
 
        // resample the buffers to the current sample rate
        const double convolverSampleRate = m_processor.getSampleRate();
        if (convolverSampleRate < 1.0)
            return;
 
        for (int i = 0; i < numConvolvers; ++i)
            if (!threadShouldExit())
                buffers[static_cast<size_t>(i)] =
                        changeSampleRate(buffers[static_cast<size_t>(i)], fileSampleRate, convolverSampleRate);
 
        // Unify buffer size
        unifyBufferSize(buffers);
        if (threadShouldExit())
        {
            return;
        }
 
        // Normalise the IR levels
        normaliseImpulseResponses(buffers);
        if (threadShouldExit())
        {
            return;
        }
 
        // Update convolvers
        const float headBlockSize = static_cast<float>(m_processor.getConvolverHeadBlockSize());
        const float tailBlockSize = static_cast<float>(m_processor.getConvolverTailBlockSize());
        if (headBlockSize > 0 && tailBlockSize > 0)
            for (int i = 0; i < convolvers.size(); i++)
                convolvers[i]->resetConvolver(buffers[static_cast<size_t>(i)], headBlockSize, tailBlockSize);
    }
 
    FloatBuffer::Ptr ConvolutionComputationThread::importChannelFromAudioFile(AudioFormatReader* reader,
                                                                              int fileChannel) const
    {
        if (!reader || reader->sampleRate < 0.0001)
            return {};
 
        const int fileChannels = static_cast<int>(reader->numChannels);
        const int fileLen = static_cast<int>(reader->lengthInSamples);
 
        if (static_cast<int>(fileChannel) >= fileChannels)
            return {};
 
        FloatBuffer::Ptr buffer(new FloatBuffer(static_cast<size_t>(fileLen)));
        AudioFormatReaderSource audioFormatReaderSource(reader, false);
        juce::AudioSampleBuffer importBuffer(fileChannels, 8192);
        auto bufferPtr = buffer->data();
        auto importBufferPtr = importBuffer.getReadPointer(fileChannel);
        int pos = 0;
        while (pos < fileLen)
        {
            if (threadShouldExit())
            {
                return {};
            }
 
            const int loading = std::min(importBuffer.getNumSamples(), static_cast<int>(fileLen - pos));
            AudioSourceChannelInfo info;
            info.buffer = &importBuffer;
            info.startSample = 0;
            info.numSamples = loading;
            audioFormatReaderSource.getNextAudioBlock(info);
            ::memcpy(bufferPtr + pos, importBufferPtr,
                     static_cast<size_t>(static_cast<unsigned int>(loading) * sizeof(float)));
            pos += static_cast<int>(loading);
        }
 
        return buffer;
    }
 
    FloatBuffer::Ptr ConvolutionComputationThread::changeSampleRate(const FloatBuffer::Ptr& inputBuffer,
                                                                    double inputSampleRate,
                                                                    double outputSampleRate) const
    {
        if (!inputBuffer)
        {
            return {};
        }
 
        if (std::fabs(outputSampleRate - inputSampleRate) < 0.0000001)
        {
            return inputBuffer;
        }
 
        jassert(inputSampleRate >= 1.0);
        jassert(outputSampleRate >= 1.0);
 
        const double samplesInPerOutputSample = inputSampleRate / outputSampleRate;
        const int inputSampleCount = static_cast<int>(inputBuffer->getSize());
        const int outputSampleCount =
                static_cast<int>(::ceil(static_cast<double>(inputSampleCount) / samplesInPerOutputSample));
        const int blockSize = 8192;
 
        FloatBufferSource inputSource(inputBuffer);
        ResamplingAudioSource resamplingSource(&inputSource, false, 1);
        resamplingSource.setResamplingRatio(samplesInPerOutputSample);
        resamplingSource.prepareToPlay(blockSize, outputSampleRate);
 
        FloatBuffer::Ptr outputBuffer(new FloatBuffer(static_cast<size_t>(outputSampleCount)));
        AudioSampleBuffer blockBuffer(1, blockSize);
        int processed = 0;
        while (processed < outputSampleCount)
        {
            if (threadShouldExit())
            {
                return {};
            }
 
            const int remaining = outputSampleCount - processed;
            const int processing = std::min(blockSize, remaining);
 
            juce::AudioSourceChannelInfo info;
            info.buffer = &blockBuffer;
            info.startSample = 0;
            info.numSamples = processing;
            resamplingSource.getNextAudioBlock(info);
            ::memcpy(outputBuffer->data() + processed, blockBuffer.getReadPointer(0),
                     static_cast<size_t>(static_cast<unsigned long>(processing) * sizeof(float)));
            processed += processing;
        }
 
        resamplingSource.releaseResources();
 
        return outputBuffer;
    }
 
    void ConvolutionComputationThread::unifyBufferSize(std::vector<FloatBuffer::Ptr>& buffers) const
    {
        size_t bufferSize = 0;
        for (size_t i = 0; i < buffers.size(); ++i)
        {
            if (buffers[i] != nullptr)
            {
                bufferSize = std::max(bufferSize, buffers[i]->getSize());
            }
        }
        for (size_t i = 0; i < buffers.size(); ++i)
        {
            if (threadShouldExit())
            {
                return;
            }
            if (buffers[i] && buffers[i]->getSize() < bufferSize)
            {
                FloatBuffer::Ptr buffer(new FloatBuffer(bufferSize));
                const size_t copySize = buffers[i]->getSize();
                const size_t padSize = bufferSize - copySize;
                ::memcpy(buffer->data(), buffers[i]->data(), copySize * sizeof(float));
                ::memset(buffer->data() + copySize, 0, padSize * sizeof(float));
                buffers[i] = buffer;
            }
        }
    }
 
    void ConvolutionComputationThread::normaliseImpulseResponses(const std::vector<FloatBuffer::Ptr>& buffers) const
    {
        // Normalize IRs based on RMS (method used by old convolution reverb)
        if (threadShouldExit())
            return;
 
        auto buffer = buffers[0]->data();
        auto len = buffers[0]->getSize();
 
        float rms = 0.0f;
        for (size_t i = 0; i < len; ++i)
            rms += buffer[i] * buffer[i];
        rms = std::sqrt(rms / static_cast<float>(len));
 
        const float idealRms = 1e-3f;
        float gain = idealRms / rms;
        for (auto& buff : buffers)
            if (buff != nullptr)
                for (int i = 0; i < static_cast<int>(buff->getSize()); i++)
                    buff->data()[i] *= gain;
    }
} // namespace krotos