Method handlePreRenderTasks

src/core/AudioContext.cpp:271–396

}

void AudioContext::handlePreRenderTasks(ContextRenderLock & r)
{
    // these may be null during application exit.
    if (!r.context() || !m_audioContextInterface)
        return;

    // At the beginning of every render quantum, update the graph.

    m_audioContextInterface->_currentTime = currentTime();

    // check for pending connections
    if (m_internal->pendingParamConnections.size_approx() > 0 ||
        m_internal->pendingNodeConnections.size_approx() > 0)
    {
        // take a graph lock until the queues are cleared
        ContextGraphLock gLock(this, "AudioContext::handlePreRenderTasks()");

        // resolve parameter connections
        PendingParamConnection param_connection;
        while (m_internal->pendingParamConnections.try_dequeue(param_connection))
        {
            if (param_connection.type == ConnectionOperationKind::Connect)
            {
                AudioParam::connect(gLock,
                                    param_connection.destination,
                                    param_connection.source->output(param_connection.destIndex));

                // if unscheduled, the source should start to play as soon as possible
                if (!param_connection.source->isScheduledNode())
                    param_connection.source->_scheduler.start(0);
            }
            else
                AudioParam::disconnect(gLock,
                                       param_connection.destination,
                                       param_connection.source->output(param_connection.destIndex));
        }

        // resolve node connections
        PendingNodeConnection node_connection;
        std::vector<PendingNodeConnection> requeued_connections;
        while (m_internal->pendingNodeConnections.try_dequeue(node_connection))
        {
            switch (node_connection.type)
            {
                case ConnectionOperationKind::Connect:
                {
                    AudioNodeInput::connect(gLock,
                                            node_connection.destination->input(node_connection.destIndex),
                                            node_connection.source->output(node_connection.srcIndex));

                    if (!node_connection.source->isScheduledNode())
                        node_connection.source->_scheduler.start(0);
                }
                break;

                case ConnectionOperationKind::Disconnect:
                {
                    node_connection.type = ConnectionOperationKind::FinishDisconnect;