Method process

src/extended/RecorderNode.cpp:53–120

void RecorderNode::process(ContextRenderLock & r, int bufferSize)
{
    AudioBus * outputBus = output(0)->bus(r);
    AudioBus * inputBus = input(0)->bus(r);

    bool has_input = inputBus != nullptr && input(0)->isConnected() && inputBus->numberOfChannels() > 0;
    if ((!isInitialized() || !has_input) && outputBus)
    {
        outputBus->zero();
    }

    if (!has_input)
    {
        // nothing to record.
        if (outputBus)
            outputBus->zero();
        return;
    }

    // the recorder will conform the number of output channels to the number of input
    // in order that it can function as a pass-through node.
    const int inputBusNumChannels = inputBus->numberOfChannels();
    int outputBusNumChannels = inputBusNumChannels;
    if (outputBus)
    {
        outputBusNumChannels = outputBus->numberOfChannels();

        if (inputBusNumChannels != outputBusNumChannels)
        {
            output(0)->setNumberOfChannels(r, inputBusNumChannels);
            outputBusNumChannels = inputBusNumChannels;
            outputBus = output(0)->bus(r);
        }
    }

    if (m_recording)
    {
        const int numChannels = std::min(inputBusNumChannels, outputBusNumChannels);

        std::vector<const float*> channels;
        for (int i = 0; i < numChannels; ++i)
        {
            channels.push_back(inputBus->channel(i)->data());
        }

        if (m_data.size() < numChannels)
        {
            // allocate the recording buffers lazily when the number of input channels is finally known
            for (int i = 0; i < numChannels; ++i)
            {
                m_data.emplace_back(std::vector<float>());
                m_data[i].reserve(1024 * 1024);
            }
        }

        // copy the output. @TODO this should be a memcpy
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        for (int c = 0; c < numChannels; ++c)