processing_function()

void MayaFlux::Buffers::NetworkAudioProcessor::processing_function ( const std::shared_ptr< Buffer > &  buffer )

overridevirtual

Drives or reads network batch output into the buffer.

Parameters

buffer

Target buffer to fill with network batch data

If the network has not been processed this cycle, drives process_batch() with the buffer's sample count. If another context is currently processing, returns immediately without writing data.

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 27 of file NetworkAudioBuffer.cpp.

{
    if (!m_network) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "NetworkAudioSourceProcessor has null network");
        return;
    }
 
    auto output_mode = m_network->get_output_mode();
    if (output_mode != Nodes::Network::OutputMode::AUDIO_SINK
        && output_mode != Nodes::Network::OutputMode::AUDIO_COMPUTE) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "NetworkAudioSourceProcessor: network is not an audio sink (mode={})",
            static_cast<int>(output_mode));
        return;
    }
 
    if (!m_network->is_enabled()) {
        MF_RT_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "NetworkAudioSourceProcessor: network is disabled");
        return;
    }
 
    auto audio_buffer = std::dynamic_pointer_cast<AudioBuffer>(buffer);
    if (!audio_buffer) {
        return;
    }
 
    bool should_clear = m_clear_before_process;
    if (auto net_buf = std::dynamic_pointer_cast<NetworkAudioBuffer>(buffer)) {
        should_clear = net_buf->get_clear_before_process();
    }
 
    if (should_clear) {
        buffer->clear();
    }
 
    if (!m_network->is_processed_this_cycle()) {
        if (m_network->is_processing()) {
            return;
        }
 
        m_self_processing = true;
        m_network->add_channel_usage(audio_buffer->get_channel_id());
        m_network->mark_processing(true);
        m_network->process_batch(audio_buffer->get_num_samples());
        m_network->mark_processing(false);
        m_network->mark_processed(true);
    }
 
    const auto net_output = m_network->get_audio_buffer();
    if (!net_output) {
        return;
    }
 
    auto& buffer_data = audio_buffer->get_data();
    const auto& network_data = *net_output;
 
    auto scale = static_cast<double>(m_mix);
 
    if (m_self_processing) {
        if (m_network->needs_channel_routing()) {
            uint32_t channel = audio_buffer->get_channel_id();
            double routing_amount = m_network->get_routing_state().amount[channel];
            scale *= routing_amount;
        }
    }
 
    if (scale == 0.0) {
        return;
    }
 
    const size_t copy_size = std::min(buffer_data.size(), network_data.size());
 
    if (should_clear && scale == 1.0) {
        std::copy_n(network_data.begin(), copy_size, buffer_data.begin());
    } else {
        for (size_t i = 0; i < copy_size; ++i) {
            buffer_data[i] += network_data[i] * scale;
        }
    }
 
    if (m_self_processing) {
        m_self_processing = false;
        m_network->request_reset_from_channel(audio_buffer->get_channel_id());
    }
}

References MayaFlux::Nodes::Network::AUDIO_COMPUTE, MayaFlux::Nodes::Network::AUDIO_SINK, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, m_clear_before_process, m_mix, m_network, m_self_processing, MF_RT_DEBUG, and MF_RT_ERROR.