IRConvolver.cpp

Go to the documentation of this file.

namespace krotos
{
    IRConvolver::IRConvolver() : m_headBlockSize(0), m_tailBlockSize(0), m_irBuffer(nullptr) {}
 
    IRConvolver::~IRConvolver() {}
 
    FloatBuffer::Ptr IRConvolver::getImpulseResponse() const { return m_irBuffer; }
 
    void IRConvolver::clearImpulseResponse()
    {
        clearConvolver();
        m_irBuffer.reset();
    }
 
    Convolver* IRConvolver::getConvolver() { return m_convolver.get(); }
 
    void IRConvolver::setConvolver(Convolver* convolver)
    {
        std::unique_ptr<Convolver> conv{convolver};
        {
            ScopedLock convolverLock(m_convolverMutex);
            m_convolver.swap(conv);
        }
    }
 
    void IRConvolver::resetConvolver() { resetConvolver(m_irBuffer, m_headBlockSize, m_tailBlockSize); }
 
    void IRConvolver::resetConvolver(FloatBuffer::Ptr irBuffer, float headBlockSize, float tailBlockSize)
    {
        jassert(headBlockSize > 0 && tailBlockSize > 0);
        m_headBlockSize = headBlockSize;
        m_tailBlockSize = tailBlockSize;
        if (m_irBuffer != irBuffer)
            m_irBuffer = irBuffer;
 
        auto convolver = std::make_unique<Convolver>();
        const bool successInit = convolver->init(static_cast<size_t>(headBlockSize), static_cast<size_t>(tailBlockSize),
                                                 m_irBuffer->data(), m_irBuffer->getSize());
        if (successInit != true)
        {
            jassert(true);
        }
 
        setConvolver(convolver.release());
    }
 
    void IRConvolver::clearConvolver() { setConvolver(nullptr); }
 
    void IRConvolver::process(const float* input, float* output, int len)
    {
        // This is the hopefully one and only rare exception where we need to
        // lock a mutex in the realtime audio thread :-/ (however, the according
        // convolver mutex is locked somewhere else only once for a very short and
        // rare swapping operation, so this shouldn't be a problem, and most operating
        // systems internally try spinning before performing an expensive context switch,
        // so we will never give up the context here probably).
        juce::ScopedLock convolverLock(m_convolverMutex);
 
        if (m_convolver != nullptr)
            m_convolver->process(input, output, static_cast<size_t>(len));
 
        else
            std::memset(output, 0, static_cast<size_t>(static_cast<unsigned long>(len) * sizeof(float)));
    }
} // namespace krotos