process_audio_networks()

std::vector< std::vector< double > > MayaFlux::Nodes::NodeGraphManager::process_audio_networks	(	ProcessingToken	token,
		uint32_t	num_samples,
		uint32_t	channel = 0
	)

Process audio networks for a specific channel.

Parameters

token	Processing domain (should be AUDIO_RATE)
num_samples	Number of samples/frames to process
channel	Channel index within that domain

Returns

Vector of processed audio data from all networks for that channel

Processes all audio-sink networks registered to the specified channel and returns their combined output data.

Definition at line 123 of file NodeGraphManager.cpp.

{
    if (!preprocess_networks(token)) {
        return {};
    }
 
    std::vector<std::vector<double>> all_network_outputs;
 
    auto audio_it = m_audio_networks.find(token);
    if (audio_it != m_audio_networks.end()) {
        for (auto& network : audio_it->second) {
            if (!network || !network->is_enabled()) {
                continue;
            }
 
            if (!network->is_registered_on_channel(channel)) {
                continue;
            }
 
            if (!network->is_processed_this_cycle()) {
                network->mark_processing(true);
                network->process_batch(num_samples);
                network->mark_processing(false);
                network->mark_processed(true);
            }
 
            const auto& net_buffer = network->get_audio_buffer();
            if (net_buffer && network->get_output_mode() == Network::OutputMode::AUDIO_SINK) {
                if (network->needs_channel_routing()) {
                    double scale = network->get_routing_state().amount[channel];
                    if (scale == 0.0)
                        continue;
 
                    if (scale == 1.0) {
                        all_network_outputs.push_back(*net_buffer);
                    } else {
                        std::vector<double> scaled_buffer = *net_buffer;
                        for (auto& sample : scaled_buffer)
                            sample *= scale;
 
                        all_network_outputs.push_back(std::move(scaled_buffer));
                    }
                } else {
                    all_network_outputs.push_back(*net_buffer);
                }
            }
        }
    }
 
    postprocess_networks(token, channel);
    return all_network_outputs;
}

References MayaFlux::Nodes::Network::AUDIO_SINK, m_audio_networks, postprocess_networks(), and preprocess_networks().

Here is the call graph for this function: