tracktion_SummingNode.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
#pragma once
 
namespace tracktion { inline namespace graph
{
 
//==============================================================================
//==============================================================================
class SummingNode final : public Node
{
public:
    SummingNode() = default;
 
    SummingNode (std::vector<std::unique_ptr<Node>> inputs)
        : ownedNodes (std::move (inputs))
    {
        for (auto& ownedNode : ownedNodes)
            nodes.push_back (ownedNode.get());
 
        assert (std::find (nodes.begin(), nodes.end(), nullptr) == nodes.end());
    }
 
    SummingNode (std::vector<Node*> inputs)
        : nodes (std::move (inputs))
    {
        assert (std::find (nodes.begin(), nodes.end(), nullptr) == nodes.end());
    }
 
    SummingNode (std::vector<std::unique_ptr<Node>> ownedInputs,
                 std::vector<Node*> referencedInputs)
        : SummingNode (std::move (ownedInputs))
    {
        nodes.insert (nodes.begin(), referencedInputs.begin(), referencedInputs.end());
        assert (std::find (nodes.begin(), nodes.end(), nullptr) == nodes.end());
    }
 
    //==============================================================================
    void addInput (std::unique_ptr<Node> newInput)
    {
        assert (newInput != nullptr);
        nodes.push_back (newInput.get());
        ownedNodes.push_back (std::move (newInput));
    }
 
    void setDoubleProcessingPrecision (bool shouldSumInDoublePrecision)
    {
        useDoublePrecision = shouldSumInDoublePrecision;
    }
 
    //==============================================================================
    NodeProperties getNodeProperties() override
    {
        if (cachedNodeProperties)
            return *cachedNodeProperties;
 
        NodeProperties props;
        props.hasAudio = false;
        props.hasMidi = false;
        props.numberOfChannels = 0;
        props.latencyNumSamples = nodes.empty() ? 0 : std::numeric_limits<int>::min();
 
        for (auto& node : nodes)
        {
            auto nodeProps = node->getNodeProperties();
            props.hasAudio = props.hasAudio || nodeProps.hasAudio;
            props.hasMidi = props.hasMidi || nodeProps.hasMidi;
            props.numberOfChannels = std::max (props.numberOfChannels, nodeProps.numberOfChannels);
            props.latencyNumSamples = std::max (props.latencyNumSamples, nodeProps.latencyNumSamples);
            hash_combine (props.nodeID, nodeProps.nodeID);
        }
 
        cachedNodeProperties = props;
 
        return props;
    }
 
    std::vector<Node*> getDirectInputNodes() override
    {
        return nodes;
    }
 
    TransformResult transform (Node&, const std::vector<Node*>&, TransformCache&) override
    {
        const bool hasFlattened = flattenSummingNodes();
        const bool hasCreatedLatency = createLatencyNodes();
 
        if (hasFlattened)
            return TransformResult::nodesDeleted;
 
        if (hasCreatedLatency)
            return TransformResult::connectionsMade;
 
        return TransformResult::none;
    }
 
    void prepareToPlay (const PlaybackInitialisationInfo& info) override
    {
        useDoublePrecision = useDoublePrecision && nodes.size() > 1;
 
        if (useDoublePrecision)
            tempDoubleBuffer.resize ({ (choc::buffer::ChannelCount) getNodeProperties().numberOfChannels,
                                       (choc::buffer::FrameCount) info.blockSize });
 
        isPrepared = true;
    }
 
    bool isReadyToProcess() override
    {
        for (auto& node : nodes)
            if (! node->hasProcessed())
                return false;
 
        return true;
    }
 
    void process (ProcessContext& pc) override
    {
        if (useDoublePrecision)
            processDoublePrecision (pc);
        else
            processSinglePrecision (pc);
    }
 
private:
    //==============================================================================
    std::vector<std::unique_ptr<Node>> ownedNodes;
    std::vector<Node*> nodes;
 
    std::optional<NodeProperties> cachedNodeProperties;
    bool isPrepared = false;
 
    bool useDoublePrecision = false;
    choc::buffer::ChannelArrayBuffer<double> tempDoubleBuffer;
 
    static void sortByTimestampUnstable (tracktion_engine::MidiMessageArray& messages) noexcept
    {
        std::sort (messages.begin(), messages.end(), [] (const juce::MidiMessage& a, const juce::MidiMessage& b)
        {
            auto t1 = a.getTimeStamp();
            auto t2 = b.getTimeStamp();
 
            if (t1 == t2)
            {
                if (a.isNoteOff() && b.isNoteOn()) return true;
                if (a.isNoteOn() && b.isNoteOff()) return false;
            }
            return t1 < t2;
        });
    }
 
    //==============================================================================
    void processSinglePrecision (const ProcessContext& pc)
    {
        const auto numChannels = pc.buffers.audio.getNumChannels();
 
        int nodesWithMidi = pc.buffers.midi.isEmpty() ? 0 : 1;
 
        // Get each of the inputs and add them to dest
        for (auto& node : nodes)
        {
            auto inputFromNode = node->getProcessedOutput();
 
            if (auto numChannelsToAdd = std::min (inputFromNode.audio.getNumChannels(), numChannels))
                add (pc.buffers.audio.getFirstChannels (numChannelsToAdd),
                     inputFromNode.audio.getFirstChannels (numChannelsToAdd));
 
            if (inputFromNode.midi.isNotEmpty())
                nodesWithMidi++;
 
            pc.buffers.midi.mergeFrom (inputFromNode.midi);
        }
 
        if (nodesWithMidi > 1)
            sortByTimestampUnstable (pc.buffers.midi);
    }
 
    void processDoublePrecision (const ProcessContext& pc)
    {
        const auto numChannels = pc.buffers.audio.getNumChannels();
        auto doubleView = tempDoubleBuffer.getView().getStart (pc.buffers.audio.getNumFrames());
        doubleView.clear();
 
        int nodesWithMidi = pc.buffers.midi.isEmpty() ? 0 : 1;
 
        // Get each of the inputs and add them to dest
        for (auto& node : nodes)
        {
            auto inputFromNode = node->getProcessedOutput();
 
            if (auto numChannelsToAdd = std::min (inputFromNode.audio.getNumChannels(), numChannels))
                add (doubleView.getFirstChannels (numChannelsToAdd),
                     inputFromNode.audio.getFirstChannels (numChannelsToAdd));
 
            if (inputFromNode.midi.isNotEmpty())
                nodesWithMidi++;
 
            pc.buffers.midi.mergeFrom (inputFromNode.midi);
        }
 
        assert (doubleView.getNumChannels() == (choc::buffer::ChannelCount) numChannels);
 
        if (numChannels != 0)
            add (pc.buffers.audio.getFirstChannels (numChannels), doubleView);
 
        if (nodesWithMidi > 1)
            sortByTimestampUnstable (pc.buffers.midi);
    }
 
    //==============================================================================
    bool flattenSummingNodes()
    {
        bool hasChanged = false;
 
        std::vector<std::unique_ptr<Node>> ownedNodesToAdd;
        std::vector<Node*> nodesToAdd, nodesToErase;
 
        for (auto& n : ownedNodes)
        {
            if (auto summingNode = dynamic_cast<SummingNode*> (n.get()))
            {
                for (auto& ownedNodeToAdd : summingNode->ownedNodes)
                    ownedNodesToAdd.push_back (std::move (ownedNodeToAdd));
 
                for (auto& nodeToAdd : summingNode->nodes)
                    nodesToAdd.push_back (std::move (nodeToAdd));
 
                nodesToErase.push_back (n.get());
                hasChanged = true;
            }
        }
 
        for (auto& n : ownedNodesToAdd)
            ownedNodes.push_back (std::move (n));
 
        for (auto& n : nodesToAdd)
            nodes.push_back (std::move (n));
 
        ownedNodes.erase (std::remove_if (ownedNodes.begin(), ownedNodes.end(),
                                          [&] (auto& n) { return std::find (nodesToErase.begin(), nodesToErase.end(), n.get()) != nodesToErase.end(); }),
                          ownedNodes.end());
 
        nodes.erase (std::remove_if (nodes.begin(), nodes.end(),
                                     [&] (auto& n) { return std::find (nodesToErase.begin(), nodesToErase.end(), n) != nodesToErase.end(); }),
                     nodes.end());
 
        return hasChanged;
    }
 
    bool createLatencyNodes()
    {
        bool topologyChanged = false;
        const int maxLatency = getNodeProperties().latencyNumSamples;
        std::vector<std::unique_ptr<Node>> ownedNodesToAdd;
 
        for (auto& node : nodes)
        {
            auto props = node->getNodeProperties();
            const int nodeLatency = props.latencyNumSamples;
            const int latencyToAdd = subtractNoWrap (maxLatency, nodeLatency);
 
            if (latencyToAdd <= 0)
                continue;
 
            auto getOwnedNode = [this] (auto nodeToFind)
            {
                for (auto& ownedN : ownedNodes)
                {
                    if (ownedN.get() == nodeToFind)
                    {
                        auto nodeToReturn = std::move (ownedN);
                        ownedN.reset();
                        return nodeToReturn;
                    }
                }
 
                return std::unique_ptr<Node>();
            };
 
            auto ownedNode = getOwnedNode (node);
            auto latencyNode = ownedNode != nullptr ? makeNode<LatencyNode> (std::move (ownedNode), latencyToAdd)
                                                    : makeNode<LatencyNode> (node, latencyToAdd);
            ownedNodesToAdd.push_back (std::move (latencyNode));
            node = nullptr;
            topologyChanged = true;
            cachedNodeProperties = std::nullopt;
        }
 
        // Take ownership of any new nodes and also ensure they're reference in the raw array
        for (auto& newNode : ownedNodesToAdd)
        {
            nodes.push_back (newNode.get());
            ownedNodes.push_back (std::move (newNode));
        }
 
        nodes.erase (std::remove_if (nodes.begin(), nodes.end(),
                                     [] (auto& n) { return n == nullptr; }),
                     nodes.end());
 
        ownedNodes.erase (std::remove_if (ownedNodes.begin(), ownedNodes.end(),
                                          [] (auto& n) { return n == nullptr; }),
                          ownedNodes.end());
 
        return topologyChanged;
    }
};
 
 
static inline std::unique_ptr<SummingNode> makeSummingNode (std::initializer_list<Node*> nodes)
{
    std::vector<std::unique_ptr<Node>> nodeVector;
 
    for (auto node : nodes)
        nodeVector.push_back (std::unique_ptr<Node> (node));
 
    return std::make_unique<SummingNode> (std::move (nodeVector));
}
 
}}