process_batch()

void MayaFlux::Nodes::Network::ResonatorNetwork::process_batch ( unsigned int  num_samples )

overridevirtual

Processes num_samples through all resonators and accumulates output.

Parameters

num_samples

Number of audio samples to compute

For each sample, each resonator draws from its individual exciter (or the network-level exciter, or zero if none) and processes one sample. All resonator outputs are summed and normalised into m_last_audio_buffer.

Implements MayaFlux::Nodes::Network::NodeNetwork.

Definition at line 205 of file ResonatorNetwork.cpp.

{
    if (m_resonators.empty()) {
        while (m_audio_buffer_lock.test_and_set(std::memory_order_acquire))
            std::this_thread::yield();
 
        m_last_audio_buffer.assign(num_samples, 0.0);
        m_audio_buffer_lock.clear(std::memory_order_release);
        return;
    }
 
    update_mapped_parameters();
 
    thread_local std::vector<double> scratch;
    scratch.assign(num_samples, 0.0);
 
    const double norm = 1.0 / static_cast<double>(m_resonators.size());
 
    m_node_buffers.assign(m_resonators.size(), {});
    for (auto& nb : m_node_buffers)
        nb.reserve(num_samples);
 
    std::vector<std::optional<std::span<const double>>> net_exc_bufs;
    if (m_network_exciter) {
        net_exc_bufs.reserve(m_resonators.size());
        for (size_t ri = 0; ri < m_resonators.size(); ++ri)
            net_exc_bufs.push_back(m_network_exciter->get_node_audio_buffer(ri));
    }
 
    for (size_t s = 0; s < num_samples; ++s) {
        for (size_t ri = 0; ri < m_resonators.size(); ++ri) {
            auto& r = m_resonators[ri];
            double excitation = 0.0;
 
            if (r.exciter) {
                excitation = r.exciter->process_sample(0.0);
            } else if (!net_exc_bufs.empty() && net_exc_bufs[ri] && s < net_exc_bufs[ri]->size()) {
                excitation = (*net_exc_bufs[ri])[s];
            } else if (m_exciter) {
                excitation = m_exciter->process_sample(0.0);
            }
 
            const double out = r.filter->process_sample(excitation) * r.gain;
            r.last_output = out;
            m_node_buffers[ri].push_back(out);
            scratch[s] += out * norm;
        }
    }
 
    while (m_audio_buffer_lock.test_and_set(std::memory_order_acquire))
        std::this_thread::yield();
 
    m_last_audio_buffer.assign(scratch.begin(), scratch.end());
    apply_output_scale();
    m_audio_buffer_lock.clear(std::memory_order_release);
}

References MayaFlux::Nodes::Network::NodeNetwork::apply_output_scale(), MayaFlux::Nodes::Network::NodeNetwork::m_audio_buffer_lock, m_exciter, m_last_audio_buffer, m_network_exciter, m_node_buffers, m_resonators, and update_mapped_parameters().

Here is the call graph for this function: