NodeBuffer.cpp

Go to the documentation of this file.

#include "NodeBuffer.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
#include "MayaFlux/Nodes/Node.hpp"
 
namespace MayaFlux::Buffers {
NodeSourceProcessor::NodeSourceProcessor(std::shared_ptr<Nodes::Node> node, float mix, bool clear_before_process)
    : m_node(std::move(node))
    , m_mix(mix)
    , m_clear_before_process(clear_before_process)
{
}
 
void NodeSourceProcessor::processing_function(std::shared_ptr<Buffer> buffer)
{
    if (!m_node) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing, "NodeSourceProcessor has null node. Skipping processing.");
        return;
    }
 
    try {
        auto& buffer_data = std::dynamic_pointer_cast<AudioBuffer>(buffer)->get_data();
 
        bool should_clear = m_clear_before_process;
        if (auto node_buffer = std::dynamic_pointer_cast<NodeBuffer>(buffer)) {
            should_clear = node_buffer->get_clear_before_process();
        }
 
        if (should_clear) {
            buffer->clear();
        }
 
        update_buffer(buffer_data);
 
    } catch (const std::exception& e) {
        error_rethrow(Journal::Component::Buffers, Journal::Context::BufferProcessing, std::source_location::current(), "Error processing node: {}", e.what());
    }
}
 
std::vector<double> NodeSourceProcessor::get_node_data(uint32_t num_samples)
{
    std::vector<double> output(num_samples);
    const auto& state = m_node->m_state.load();
 
    if (state == Utils::NodeState::INACTIVE) {
        for (size_t i = 0; i < num_samples; i++) {
            output[i] = m_node->process_sample(0.F);
        }
    } else {
        m_node->save_state();
        for (size_t i = 0; i < num_samples; i++) {
            output[i] = m_node->process_sample(0.F);
        }
        m_node->restore_state();
    }
 
    return output;
}
 
void NodeSourceProcessor::update_buffer(std::vector<double>& buffer_data)
{
    const auto& state = m_node->m_state.load();
    if (state == Utils::NodeState::INACTIVE) {
        for (double& i : buffer_data) {
            i += m_node->process_sample(0.F) * m_mix;
        }
        return;
    }
    m_node->save_state();
 
    for (double& i : buffer_data) {
        i += m_node->process_sample(0.F) * m_mix;
    }
    m_node->restore_state();
}
 
NodeBuffer::NodeBuffer(uint32_t channel_id, uint32_t num_samples, std::shared_ptr<Nodes::Node> source, bool clear_before_process)
    : AudioBuffer(channel_id, num_samples)
    , m_source_node(std::move(source))
    , m_clear_before_process(clear_before_process)
{
    m_default_processor = create_default_processor();
}
 
void NodeBuffer::process_default()
{
    if (m_clear_before_process) {
        clear();
    }
    m_default_processor->process(shared_from_this());
}
 
std::shared_ptr<BufferProcessor> NodeBuffer::create_default_processor()
{
    return std::make_shared<NodeSourceProcessor>(m_source_node);
}
}