NodeGraphManager.cpp

Go to the documentation of this file.

#include "NodeGraphManager.hpp"
 
#include "Network/NodeNetwork.hpp"
#include "NodeStructure.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace MayaFlux::Nodes {
 
NodeGraphManager::NodeGraphManager()
{
    ensure_root_exists(ProcessingToken::AUDIO_RATE, 0);
}
 
void NodeGraphManager::add_to_root(const std::shared_ptr<Node>& node,
    ProcessingToken token,
    unsigned int channel)
{
    set_channel_mask(node, channel);
 
    auto& root = get_root_node(token, channel);
    root.register_node(node);
}
 
void NodeGraphManager::remove_from_root(const std::shared_ptr<Node>& node,
    ProcessingToken token,
    unsigned int channel)
{
    unset_channel_mask(node, channel);
 
    auto& root = get_root_node(token, channel);
    root.unregister_node(node);
}
 
void NodeGraphManager::register_token_processor(ProcessingToken token,
    std::function<void(std::span<RootNode*>)> processor)
{
    m_token_processors[token] = std::move(processor);
}
 
const std::unordered_map<unsigned int, std::shared_ptr<RootNode>>& NodeGraphManager::get_all_channel_root_nodes(ProcessingToken token) const
{
    static std::unordered_map<unsigned int, std::shared_ptr<RootNode>> audio_roots;
    audio_roots.clear();
 
    auto it = m_token_roots.find(token);
    if (it != m_token_roots.end()) {
        for (const auto& [channel, root] : it->second) {
            audio_roots[channel] = root;
        }
    }
    return audio_roots;
}
 
bool NodeGraphManager::preprocess_networks(ProcessingToken token)
{
    auto& processing_flag = m_token_network_processing[token];
 
    bool expected = false;
    return processing_flag.compare_exchange_strong(
        expected, true,
        std::memory_order_acquire,
        std::memory_order_relaxed);
}
 
void NodeGraphManager::process_token(ProcessingToken token, unsigned int num_samples)
{
    auto roots = get_all_root_nodes(token);
 
    if (auto it = m_token_processors.find(token); it != m_token_processors.end()) {
        it->second(std::span<RootNode*>(roots.data(), roots.size()));
        return;
    }
 
    if (!preprocess_networks(token)) {
        return;
    }
 
    auto it = m_token_networks.find(token);
    if (it != m_token_networks.end()) {
        for (auto& network : it->second) {
            if (!network || !network->is_enabled()) {
                continue;
            }
 
            if (!network->is_processed_this_cycle()) {
                network->mark_processing(true);
                network->process_batch(num_samples);
                network->mark_processing(false);
                network->mark_processed(true);
            }
        }
    }
 
    postprocess_networks(token, std::nullopt);
 
    if (token == ProcessingToken::AUDIO_RATE) {
        for (auto* root : roots) {
            root->process_batch(num_samples);
        }
    } else if (token == ProcessingToken::VISUAL_RATE) {
        for (auto* root : roots) {
            root->process_batch_frame(num_samples);
        }
    }
}
 
std::vector<std::vector<double>> NodeGraphManager::process_audio_networks(ProcessingToken token, uint32_t num_samples, uint32_t channel)
{
    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()) {
        auto channel_it = audio_it->second.find(channel);
        if (channel_it != audio_it->second.end()) {
            for (auto& network : channel_it->second) {
                if (!network || !network->is_enabled()) {
                    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) {
                    all_network_outputs.push_back(*net_buffer);
                }
            }
        }
    }
 
    postprocess_networks(token, channel);
    return all_network_outputs;
}
 
void NodeGraphManager::postprocess_networks(ProcessingToken token, std::optional<uint32_t> channel)
{
    if (token == ProcessingToken::AUDIO_RATE && channel.has_value()) {
        auto ch = channel.value_or(0U);
        reset_audio_network_state(token, ch);
    } else if (auto it = m_token_networks.find(token); it != m_token_networks.end()) {
        for (auto& network : it->second) {
            if (network && network->is_enabled()) {
                network->mark_processed(false);
            }
        }
    }
 
    m_token_network_processing[token].store(false, std::memory_order_release);
}
 
void NodeGraphManager::reset_audio_network_state(ProcessingToken token, uint32_t channel)
{
    auto audio_it = m_audio_networks.find(token);
    if (audio_it != m_audio_networks.end()) {
        auto channel_it = audio_it->second.find(channel);
        if (channel_it != audio_it->second.end()) {
            for (auto& network : channel_it->second) {
                if (network) {
                    network->mark_processed(false);
                }
            }
        }
    }
}
 
void NodeGraphManager::register_token_channel_processor(ProcessingToken token,
    TokenChannelProcessor processor)
{
    m_token_channel_processors[token] = std::move(processor);
}
 
void NodeGraphManager::register_token_sample_processor(ProcessingToken token,
    TokenSampleProcessor processor)
{
    m_token_sample_processors[token] = std::move(processor);
}
 
std::vector<double> NodeGraphManager::process_channel(ProcessingToken token,
    unsigned int channel, unsigned int num_samples)
{
    if (channel == 0) {
        reset_audio_network_state(token);
    }
 
    auto& root = get_root_node(token, channel);
 
    if (auto it = m_token_channel_processors.find(token); it != m_token_channel_processors.end()) {
        return it->second(&root, num_samples);
    }
 
    std::vector<double> samples = root.process_batch(num_samples);
 
    uint32_t normalize_coef = root.get_node_size();
    for (double& sample : samples) {
        normalize_sample(sample, normalize_coef);
    }
    return samples;
}
 
double NodeGraphManager::process_sample(ProcessingToken token, uint32_t channel)
{
    auto& root = get_root_node(token, channel);
 
    if (auto it = m_token_sample_processors.find(token); it != m_token_sample_processors.end()) {
        return it->second(&root, channel);
    }
 
    double sample = root.process_sample();
    normalize_sample(sample, root.get_node_size());
    return sample;
}
 
void NodeGraphManager::normalize_sample(double& sample, uint32_t num_nodes)
{
    if (num_nodes == 0)
        return;
 
    sample /= std::sqrt(static_cast<double>(num_nodes));
 
    const double threshold = 0.95;
    const double knee = 0.1;
    const double abs_sample = std::abs(sample);
 
    if (abs_sample > threshold) {
        const double excess = abs_sample - threshold;
        const double compressed_excess = std::tanh(excess / knee) * knee;
        const double limited_abs = threshold + compressed_excess;
        sample = std::copysign(limited_abs, sample);
    }
}
 
std::unordered_map<unsigned int, std::vector<double>> NodeGraphManager::process_token_with_channel_data(
    ProcessingToken token, unsigned int num_samples)
{
    std::unordered_map<unsigned int, std::vector<double>> channel_data;
 
    auto channels = get_all_channels(token);
 
    for (unsigned int channel : channels) {
        channel_data[channel] = process_channel(token, channel, num_samples);
    }
 
    return channel_data;
}
 
unsigned int NodeGraphManager::get_channel_count(ProcessingToken token) const
{
    auto channels = get_all_channels(token);
    return static_cast<unsigned int>(channels.size());
}
 
std::vector<RootNode*> NodeGraphManager::get_all_root_nodes(ProcessingToken token)
{
    std::vector<RootNode*> roots;
 
    auto it = m_token_roots.find(token);
    if (it != m_token_roots.end()) {
        for (auto& [channel, root] : it->second) {
            roots.push_back(root.get());
        }
    }
 
    return roots;
}
 
void NodeGraphManager::process_all_tokens(unsigned int num_samples)
{
    for (auto token : get_active_tokens()) {
        process_token(token, num_samples);
    }
}
 
RootNode& NodeGraphManager::get_root_node(ProcessingToken token, unsigned int channel)
{
    ensure_root_exists(token, channel);
    return *m_token_roots[token][channel];
}
 
void NodeGraphManager::ensure_root_exists(ProcessingToken token, unsigned int channel)
{
    if (m_token_roots[token].find(channel) == m_token_roots[token].end()) {
        m_token_roots[token][channel] = std::make_shared<RootNode>(token, channel);
    }
}
 
void NodeGraphManager::ensure_token_exists(ProcessingToken token, uint32_t num_channels)
{
    for (uint32_t ch = 0; ch < num_channels; ++ch) {
        ensure_root_exists(token, ch);
    }
}
 
void NodeGraphManager::register_global(const std::shared_ptr<Node>& node)
{
    if (!is_node_registered(node)) {
        std::stringstream ss;
        ss << "node_" << node.get();
        std::string generated_id = ss.str();
        m_Node_registry[generated_id] = node;
    }
}
 
void NodeGraphManager::set_channel_mask(const std::shared_ptr<Node>& node, uint32_t channel_id)
{
    register_global(node);
    node->register_channel_usage(channel_id);
}
 
void NodeGraphManager::unregister_global(const std::shared_ptr<Node>& node)
{
    for (const auto& pair : m_Node_registry) {
        if (pair.second == node) {
            m_Node_registry.erase(pair.first);
            break;
        }
    }
}
 
void NodeGraphManager::unset_channel_mask(const std::shared_ptr<Node>& node, uint32_t channel_id)
{
    unregister_global(node);
    node->unregister_channel_usage(channel_id);
}
 
std::vector<ProcessingToken> NodeGraphManager::get_active_tokens() const
{
    std::vector<ProcessingToken> tokens;
    for (const auto& [token, channels] : m_token_roots) {
        if (!channels.empty()) {
            tokens.push_back(token);
        }
    }
    return tokens;
}
 
std::vector<unsigned int> NodeGraphManager::get_all_channels(ProcessingToken token) const
{
    std::vector<unsigned int> channels;
    auto it = m_token_roots.find(token);
    if (it != m_token_roots.end()) {
        for (const auto& [channel, root] : it->second) {
            channels.push_back(channel);
        }
    }
    return channels;
}
 
size_t NodeGraphManager::get_node_count(ProcessingToken token) const
{
    size_t count = 0;
    auto it = m_token_roots.find(token);
    if (it != m_token_roots.end()) {
        for (const auto& [channel, root] : it->second) {
            count += root->get_node_size();
        }
    }
    return count;
}
 
void NodeGraphManager::print_summary() const
{
    MF_PRINT(Journal::Component::Nodes,
        Journal::Context::NodeProcessing,
        "=== NodeGraphManager Summary ===");
 
    for (auto token : get_active_tokens()) {
        auto channels = get_all_channels(token);
        size_t total_nodes = get_node_count(token);
 
        MF_PRINT(Journal::Component::Nodes,
            Journal::Context::NodeProcessing,
            "Token {}: {} nodes across {} channels",
            static_cast<int>(token), total_nodes, channels.size());
 
        for (auto channel : channels) {
            auto& root = const_cast<NodeGraphManager*>(this)->get_root_node(token, channel);
            auto networks = get_networks(token, channel);
 
            MF_PRINT(Journal::Component::Nodes,
                Journal::Context::NodeProcessing,
                "  Channel {}: {} nodes, {} networks",
                channel, root.get_node_size(), networks.size());
 
            for (const auto& network : networks) {
                if (network) {
                    MF_PRINT(Journal::Component::Nodes,
                        Journal::Context::NodeProcessing,
                        "    Network: {} internal nodes, mode={}, enabled={}",
                        network->get_node_count(),
                        static_cast<int>(network->get_output_mode()),
                        network->is_enabled());
                }
            }
        }
    }
}
 
std::shared_ptr<Node> NodeGraphManager::get_node(const std::string& id)
{
    auto it = m_Node_registry.find(id);
 
    if (it != m_Node_registry.end()) {
        return it->second;
    }
    return nullptr;
}
 
bool NodeGraphManager::is_node_registered(const std::shared_ptr<Node>& node)
{
    return std::ranges::any_of(m_Node_registry,
        [&node](const auto& pair) { return pair.second == node; });
}
 
void NodeGraphManager::connect(const std::string& source_id, const std::string& target_id)
{
    auto source = get_node(source_id);
    auto target = get_node(target_id);
 
    if (source && target) {
        source >> target;
    }
}
 
//-----------------------------------------------------------------------------
// NodeNetwork Management
//-----------------------------------------------------------------------------
 
void NodeGraphManager::add_network(const std::shared_ptr<NodeNetwork>& network,
    ProcessingToken token)
{
    if (!network) {
        return;
    }
 
    register_network_global(network);
 
    network->set_enabled(true);
 
    if (network->get_output_mode() == NodeNetwork::OutputMode::AUDIO_SINK) {
        uint32_t channel_mask = network->get_channel_mask();
 
        if (channel_mask == 0) {
            channel_mask = 1;
            network->add_channel_usage(0);
        }
 
        auto channels = network->get_registered_channels();
        for (auto ch : channels) {
            ensure_root_exists(token, ch);
            m_audio_networks[token][ch].push_back(network);
 
            MF_INFO(Journal::Component::Nodes,
                Journal::Context::NodeProcessing,
                "Added audio network to token {} channel {}: {} nodes",
                static_cast<int>(token), ch, network->get_node_count());
        }
 
    } else {
        m_token_networks[token].push_back(network);
 
        MF_INFO(Journal::Component::Nodes,
            Journal::Context::NodeProcessing,
            "Added network to token {}: {} nodes, mode={}",
            static_cast<int>(token),
            network->get_node_count(),
            static_cast<int>(network->get_output_mode()));
    }
}
 
void NodeGraphManager::remove_network(const std::shared_ptr<NodeNetwork>& network,
    ProcessingToken token)
{
    if (!network) {
        return;
    }
 
    if (network->get_output_mode() == NodeNetwork::OutputMode::AUDIO_SINK) {
        auto token_it = m_audio_networks.find(token);
        if (token_it != m_audio_networks.end()) {
            for (auto& [channel, networks] : token_it->second) {
                networks.erase(
                    std::remove(networks.begin(), networks.end(), network),
                    networks.end());
            }
        }
    } else {
        auto it = m_token_networks.find(token);
        if (it != m_token_networks.end()) {
            auto& networks = it->second;
            networks.erase(
                std::remove(networks.begin(), networks.end(), network),
                networks.end());
        }
    }
 
    unregister_network_global(network);
}
 
std::vector<std::shared_ptr<NodeNetwork>>
NodeGraphManager::get_networks(ProcessingToken token, unsigned int channel) const
{
    auto token_it = m_audio_networks.find(token);
    if (token_it != m_audio_networks.end()) {
        auto channel_it = token_it->second.find(channel);
        if (channel_it != token_it->second.end()) {
            return channel_it->second;
        }
    }
    return {};
}
 
std::vector<std::shared_ptr<NodeNetwork>>
NodeGraphManager::get_all_networks(ProcessingToken token) const
{
    std::vector<std::shared_ptr<NodeNetwork>> all_networks;
 
    auto audio_it = m_audio_networks.find(token);
    if (audio_it != m_audio_networks.end()) {
        for (const auto& [channel, networks] : audio_it->second) {
            all_networks.insert(all_networks.end(), networks.begin(), networks.end());
        }
    }
 
    auto token_it = m_token_networks.find(token);
    if (token_it != m_token_networks.end()) {
        all_networks.insert(all_networks.end(),
            token_it->second.begin(),
            token_it->second.end());
    }
 
    return all_networks;
}
 
size_t NodeGraphManager::get_network_count(ProcessingToken token) const
{
    size_t count = 0;
 
    auto audio_it = m_audio_networks.find(token);
    if (audio_it != m_audio_networks.end()) {
        for (const auto& [channel, networks] : audio_it->second) {
            count += networks.size();
        }
    }
 
    auto token_it = m_token_networks.find(token);
    if (token_it != m_token_networks.end()) {
        count += token_it->second.size();
    }
 
    return count;
}
 
void NodeGraphManager::clear_networks(ProcessingToken token)
{
    m_audio_networks.erase(token);
    m_token_networks.erase(token);
}
 
void NodeGraphManager::register_network_global(const std::shared_ptr<NodeNetwork>& network)
{
    if (!is_network_registered(network)) {
        std::stringstream ss;
        ss << "network_" << network.get();
        std::string generated_id = ss.str();
        m_network_registry[generated_id] = network;
    }
}
 
void NodeGraphManager::unregister_network_global(const std::shared_ptr<NodeNetwork>& network)
{
    for (const auto& pair : m_network_registry) {
        if (pair.second == network) {
            m_network_registry.erase(pair.first);
            break;
        }
    }
}
 
bool NodeGraphManager::is_network_registered(const std::shared_ptr<NodeNetwork>& network)
{
    return std::ranges::any_of(m_network_registry,
        [&network](const auto& pair) { return pair.second == network; });
}
 
}