juce_AudioProcessorGraph.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
class JUCE_API  AudioProcessorGraph   : public AudioProcessor,
                                        public ChangeBroadcaster,
                                        private AsyncUpdater
{
public:
    //==============================================================================
    AudioProcessorGraph();

    ~AudioProcessorGraph() override;

    struct NodeID
    {
        NodeID() {}
        explicit NodeID (uint32 i) : uid (i) {}
 
        uint32 uid = 0;
 
        bool operator== (const NodeID& other) const noexcept    { return uid == other.uid; }
        bool operator!= (const NodeID& other) const noexcept    { return uid != other.uid; }
        bool operator<  (const NodeID& other) const noexcept    { return uid <  other.uid; }
    };
 
    //==============================================================================
    enum { midiChannelIndex = 0x1000 };
 
    //==============================================================================
    struct NodeAndChannel
    {
        NodeID nodeID;
        int channelIndex;
 
        bool isMIDI() const noexcept                                    { return channelIndex == midiChannelIndex; }
 
        bool operator== (const NodeAndChannel& other) const noexcept    { return nodeID == other.nodeID && channelIndex == other.channelIndex; }
        bool operator!= (const NodeAndChannel& other) const noexcept    { return ! operator== (other); }
    };
 
    //==============================================================================
    class JUCE_API  Node   : public ReferenceCountedObject
    {
    public:
        //==============================================================================
        const NodeID nodeID;

        AudioProcessor* getProcessor() const noexcept           { return processor.get(); }

        NamedValueSet properties;
 
        //==============================================================================
        bool isBypassed() const noexcept;

        void setBypassed (bool shouldBeBypassed) noexcept;
 
        //==============================================================================
        using Ptr = ReferenceCountedObjectPtr<Node>;
 
    private:
        //==============================================================================
        friend class AudioProcessorGraph;
        template <typename Float>
        friend struct GraphRenderSequence;
        template <typename Float>
        friend struct RenderSequenceBuilder;
 
        struct Connection
        {
            Node* otherNode;
            int otherChannel, thisChannel;
 
            bool operator== (const Connection&) const noexcept;
        };
 
        std::unique_ptr<AudioProcessor> processor;
        Array<Connection> inputs, outputs;
        bool isPrepared = false;
        std::atomic<bool> bypassed { false };
 
        Node (NodeID, std::unique_ptr<AudioProcessor>) noexcept;
 
        void setParentGraph (AudioProcessorGraph*) const;
        void prepare (double newSampleRate, int newBlockSize, AudioProcessorGraph*, ProcessingPrecision);
        void unprepare();
 
        template <typename Sample>
        void callProcessFunction (AudioBuffer<Sample>& audio,
                                  MidiBuffer& midi,
                                  void (AudioProcessor::* function) (AudioBuffer<Sample>&, MidiBuffer&))
        {
            const ScopedLock lock (processorLock);
            (processor.get()->*function) (audio, midi);
        }
 
        template <typename Sample>
        void processBlock (AudioBuffer<Sample>& audio, MidiBuffer& midi)
        {
            callProcessFunction (audio, midi, &AudioProcessor::processBlock);
        }
 
        template <typename Sample>
        void processBlockBypassed (AudioBuffer<Sample>& audio, MidiBuffer& midi)
        {
            callProcessFunction (audio, midi, &AudioProcessor::processBlockBypassed);
        }
 
        CriticalSection processorLock;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Node)
    };
 
    //==============================================================================
    struct JUCE_API  Connection
    {
        //==============================================================================
        Connection() = default;
        Connection (NodeAndChannel source, NodeAndChannel destination) noexcept;
 
        Connection (const Connection&) = default;
        Connection& operator= (const Connection&) = default;
 
        bool operator== (const Connection&) const noexcept;
        bool operator!= (const Connection&) const noexcept;
        bool operator<  (const Connection&) const noexcept;
 
        //==============================================================================
        NodeAndChannel source { {}, 0 };

        NodeAndChannel destination { {}, 0 };
    };
 
    //==============================================================================
    void clear();

    const ReferenceCountedArray<Node>& getNodes() const noexcept    { return nodes; }

    int getNumNodes() const noexcept                                { return nodes.size(); }

    Node::Ptr getNode (int index) const noexcept                    { return nodes[index]; }

    Node* getNodeForId (NodeID) const;

    Node::Ptr addNode (std::unique_ptr<AudioProcessor> newProcessor, NodeID nodeId = {});

    Node::Ptr removeNode (NodeID);

    Node::Ptr removeNode (Node*);

    std::vector<Connection> getConnections() const;

    bool isConnected (const Connection&) const noexcept;

    bool isConnected (NodeID possibleSourceNodeID, NodeID possibleDestNodeID) const noexcept;

    bool isAnInputTo (Node& source, Node& destination) const noexcept;

    bool canConnect (const Connection&) const;

    bool addConnection (const Connection&);

    bool removeConnection (const Connection&);

    bool disconnectNode (NodeID);

    bool isConnectionLegal (const Connection&) const;

    bool removeIllegalConnections();
 
    //==============================================================================
    class JUCE_API  AudioGraphIOProcessor     : public AudioPluginInstance
    {
    public:
        enum IODeviceType
        {
            audioInputNode,     
            audioOutputNode,    
            midiInputNode,      
            midiOutputNode      
        };
 
        //==============================================================================
        IODeviceType getType() const noexcept                       { return type; }

        AudioProcessorGraph* getParentGraph() const noexcept        { return graph; }

        bool isInput() const noexcept;
        bool isOutput() const noexcept;
 
        //==============================================================================
        AudioGraphIOProcessor (IODeviceType);
        ~AudioGraphIOProcessor() override;
 
        const String getName() const override;
        void fillInPluginDescription (PluginDescription&) const override;
        void prepareToPlay (double newSampleRate, int estimatedSamplesPerBlock) override;
        void releaseResources() override;
        void processBlock (AudioBuffer<float>& , MidiBuffer&) override;
        void processBlock (AudioBuffer<double>&, MidiBuffer&) override;
        bool supportsDoublePrecisionProcessing() const override;
 
        double getTailLengthSeconds() const override;
        bool acceptsMidi() const override;
        bool producesMidi() const override;
 
       #if ! JUCE_AUDIOPROCESSOR_NO_GUI
        bool hasEditor() const override;
        AudioProcessorEditor* createEditor() override;
       #endif
 
        int getNumPrograms() override;
        int getCurrentProgram() override;
        void setCurrentProgram (int) override;
        const String getProgramName (int) override;
        void changeProgramName (int, const String&) override;
 
        void getStateInformation (juce::MemoryBlock& destData) override;
        void setStateInformation (const void* data, int sizeInBytes) override;

        void setParentGraph (AudioProcessorGraph*);
 
    private:
        const IODeviceType type;
        AudioProcessorGraph* graph = nullptr;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioGraphIOProcessor)
    };
 
    //==============================================================================
    const String getName() const override;
    void prepareToPlay (double, int) override;
    void releaseResources() override;
    void processBlock (AudioBuffer<float>&,  MidiBuffer&) override;
    void processBlock (AudioBuffer<double>&, MidiBuffer&) override;
    bool supportsDoublePrecisionProcessing() const override;
 
    void reset() override;
    void setNonRealtime (bool) noexcept override;
 
    double getTailLengthSeconds() const override;
    bool acceptsMidi() const override;
    bool producesMidi() const override;
 
   #if ! JUCE_AUDIOPROCESSOR_NO_GUI
    bool hasEditor() const override                         { return false; }
    AudioProcessorEditor* createEditor() override           { return nullptr; }
   #endif
    int getNumPrograms() override                           { return 0; }
    int getCurrentProgram() override                        { return 0; }
    void setCurrentProgram (int) override                   { }
    const String getProgramName (int) override              { return {}; }
    void changeProgramName (int, const String&) override    { }
    void getStateInformation (juce::MemoryBlock&) override;
    void setStateInformation (const void* data, int sizeInBytes) override;
 
private:
    struct PrepareSettings
    {
        ProcessingPrecision precision = ProcessingPrecision::singlePrecision;
        double sampleRate             = 0.0;
        int blockSize                 = 0;
        bool valid                    = false;
 
        using Tied = std::tuple<const ProcessingPrecision&,
                                const double&,
                                const int&,
                                const bool&>;
 
        Tied tie() const noexcept { return std::tie (precision, sampleRate, blockSize, valid); }
 
        bool operator== (const PrepareSettings& other) const noexcept { return tie() == other.tie(); }
        bool operator!= (const PrepareSettings& other) const noexcept { return tie() != other.tie(); }
    };
 
    //==============================================================================
    ReferenceCountedArray<Node> nodes;
    NodeID lastNodeID = {};
 
    struct RenderSequenceFloat;
    struct RenderSequenceDouble;
    std::unique_ptr<RenderSequenceFloat> renderSequenceFloat;
    std::unique_ptr<RenderSequenceDouble> renderSequenceDouble;
 
    PrepareSettings prepareSettings;
 
    friend class AudioGraphIOProcessor;
 
    std::atomic<bool> isPrepared { false };
 
    void topologyChanged();
    void unprepare();
    void handleAsyncUpdate() override;
    void clearRenderingSequence();
    void buildRenderingSequence();
    bool anyNodesNeedPreparing() const noexcept;
    bool isConnected (Node* src, int sourceChannel, Node* dest, int destChannel) const noexcept;
    bool isAnInputTo (Node& src, Node& dst, int recursionCheck) const noexcept;
    bool canConnect (Node* src, int sourceChannel, Node* dest, int destChannel) const noexcept;
    bool isLegal (Node* src, int sourceChannel, Node* dest, int destChannel) const noexcept;
    static void getNodeConnections (Node&, std::vector<Connection>&);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioProcessorGraph)
};
 
} // namespace juce