Method process

src/core/ConvolverNode.cpp:238–305

}

void ConvolverNode::process(ContextRenderLock & r, int bufferSize)
{
    if (_swap_ready) {
        // this could cause an audio hiccough when swapping, but it's necessary to avoid a race
        std::unique_lock<std::mutex> kernel_guard(_kernel_mutex);
        _swap_ready = false;
        std::swap(_kernels, _pending_kernels);
        _pending_kernels.clear();
    }

    AudioBus * outputBus = output(0)->bus(r);
    AudioBus * inputBus = input(0)->bus(r);

    if (!isInitialized() || !outputBus || !inputBus || !inputBus->numberOfChannels() || !_kernels.size())
    {
        outputBus->zero();
        return;
    }

    // if the user never specified the number of output channels, make it match the input
    if (!outputBus->numberOfChannels())
    {
        output(0)->setNumberOfChannels(r, inputBus->numberOfChannels());
        outputBus = output(0)->bus(r);  // set number of channels invalidates the pointer
    }

    int quantumFrameOffset = _scheduler._renderOffset;
    int nonSilentFramesToProcess = _scheduler._renderLength;

    int numInputChannels = static_cast<int>(inputBus->numberOfChannels());
    int numOutputChannels = static_cast<int>(outputBus->numberOfChannels());
    int numReverbChannels = static_cast<int>(_kernels.size());

    if (!nonSilentFramesToProcess)
    {
        outputBus->zero();
        return;
    }

    /// @todo should a situation such as 1:2:1 be invalid, or should it be powersum(1:1:1, 1:2:1)?
    /// at the moment, this routine trivially does 1:1:1 only.

    for (int i = 0; i < numOutputChannels; ++i)
    {
        int kernel = i < numReverbChannels ? i : numReverbChannels - 1;
        lab::sp_conv * conv = _kernels[kernel].conv;
        float* destP = outputBus->channel(i)->mutableData() + _scheduler._renderOffset;

        // Start rendering at the correct offset.
        destP += quantumFrameOffset;
        {
            AudioBus * input_bus = input(0)->bus(r);
            int in_channel = i < numInputChannels ? i : numInputChannels - 1;
            float const* data = input_bus->channel(in_channel)->data() + quantumFrameOffset;
            size_t c = input_bus->channel(in_channel)->length();
            for (int j = 0; j < _scheduler._renderLength; ++j)
            {
                lab::SPFLOAT in = j < c ? data[j] : 0.f;  // don't read off the end of the input buffer