processing_function()

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

overridevirtual

Processes a buffer by combining tributary buffers and node network output.

Parameters

buffer

Buffer to process (should be the root buffer)

This method implements a hierarchical data aggregation algorithm:

1. Processes all tributary buffers to ensure current data
2. Combines their outputs into the root buffer using a weighted averaging algorithm
3. Incorporates node network output if present

The combination algorithm can be customized in the implementation.

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 11 of file RootAudioBuffer.cpp.

{
 
    auto root_audio_buffer = std::dynamic_pointer_cast<RootAudioBuffer>(buffer);
    if (!root_audio_buffer || root_audio_buffer != m_root_buffer) {
        return;
    }
 
    auto& output_data = root_audio_buffer->get_data();
    const size_t buffer_size = output_data.size();
    std::ranges::fill(output_data, 0.0);
 
    if (root_audio_buffer->has_node_output()) {
        const auto& node_output = root_audio_buffer->get_node_output();
        const size_t node_size = node_output.size();
        const size_t add_size = std::min(buffer_size, node_size);
 
        for (size_t i = 0; i < add_size; ++i) {
            output_data[i] += node_output[i];
        }
    }
 
    std::vector<std::shared_ptr<AudioBuffer>> buffers_to_remove;
    for (auto& child : m_root_buffer->get_child_buffers()) {
        if (child->needs_removal()) {
            buffers_to_remove.push_back(child);
        }
    }
 
    uint32_t active_buffers = 0;
    for (auto& child : m_root_buffer->get_child_buffers()) {
        if (child->has_data_for_cycle() && !child->needs_removal() && !child->is_internal_only()) {
            active_buffers++;
        }
    }
 
    if (active_buffers > 0) {
        const double divisor = m_root_buffer->is_mix_normalized() ? active_buffers : 1.0;
 
        for (auto& child : m_root_buffer->get_child_buffers()) {
            if (child->has_data_for_cycle() && !child->needs_removal() && !child->is_internal_only()) {
                double scale = 1.0;
                if (child->needs_routing()) {
                    const auto& state = child->get_routing_state();
                    if (state.from_channel == m_root_buffer->get_channel_id()) {
                        scale = state.from_amount;
                    }
                }
                const auto& child_data = child->get_data();
                for (size_t i = 0; i < std::min(child_data.size(), output_data.size()); i++) {
                    output_data[i] += (child_data[i] * scale) / divisor;
                }
            }
        }
    }
 
    for (auto& child : buffers_to_remove) {
        m_root_buffer->remove_child_buffer(child);
    }
}

References buffer, and m_root_buffer.