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
{
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 };
 
    //==============================================================================
    class NodeAndChannel
    {
        auto tie() const { return std::tie (nodeID, channelIndex); }
 
    public:
        NodeID nodeID;
        int channelIndex;
 
        bool isMIDI() const noexcept                                    { return channelIndex == midiChannelIndex; }
 
        bool operator== (const NodeAndChannel& other) const noexcept    { return tie() == other.tie(); }
        bool operator!= (const NodeAndChannel& other) const noexcept    { return tie() != other.tie(); }
        bool operator<  (const NodeAndChannel& other) const noexcept    { return tie() <  other.tie(); }
    };
 
    //==============================================================================
    class JUCE_API  Node   : public ReferenceCountedObject
    {
    public:
        //==============================================================================
        const NodeID nodeID;
 
        AudioProcessor* getProcessor() const noexcept           { return processor.get(); }
 
        NamedValueSet properties;
 
        //==============================================================================
        bool isBypassed() const noexcept
        {
            if (processor != nullptr)
            {
                if (auto* bypassParam = processor->getBypassParameter())
                    return ! approximatelyEqual (bypassParam->getValue(), 0.0f);
            }
 
            return bypassed;
        }
 
        void setBypassed (bool shouldBeBypassed) noexcept
        {
            if (processor != nullptr)
            {
                if (auto* bypassParam = processor->getBypassParameter())
                    bypassParam->setValueNotifyingHost (shouldBeBypassed ? 1.0f : 0.0f);
            }
 
            bypassed = shouldBeBypassed;
        }
 
        //==============================================================================
        using Ptr = ReferenceCountedObjectPtr<Node>;
 
        bool userRequestedBypass() const { return bypassed; }
 
        Node (NodeID n, std::unique_ptr<AudioProcessor> p) noexcept
            : nodeID (n), processor (std::move (p))
        {
            jassert (processor != nullptr);
        }
 
    private:
        //==============================================================================
        std::unique_ptr<AudioProcessor> processor;
        std::atomic<bool> bypassed { false };
 
        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 };
    };
 
    //==============================================================================
    enum class UpdateKind
    {
        sync,   
        async,  
        none    
    };
 
    //==============================================================================
    void clear (UpdateKind = UpdateKind::sync);
 
    const ReferenceCountedArray<Node>& getNodes() const noexcept;
 
    int getNumNodes() const noexcept                                { return getNodes().size(); }
 
    Node::Ptr getNode (int index) const noexcept                    { return getNodes()[index]; }
 
    Node* getNodeForId (NodeID) const;
 
    Node::Ptr addNode (std::unique_ptr<AudioProcessor> newProcessor, std::optional<NodeID> nodeId = std::nullopt, UpdateKind = UpdateKind::sync);
 
    Node::Ptr removeNode (NodeID, UpdateKind = UpdateKind::sync);
 
    Node::Ptr removeNode (Node*, UpdateKind = UpdateKind::sync);
 
    std::vector<Connection> getConnections() const;
 
    bool isConnected (const Connection&) const noexcept;
 
    bool isConnected (NodeID possibleSourceNodeID, NodeID possibleDestNodeID) const noexcept;
 
    bool isAnInputTo (const Node& source, const Node& destination) const noexcept;
 
    bool isAnInputTo (NodeID source, NodeID destination) const noexcept;
 
    bool canConnect (const Connection&) const;
 
    bool addConnection (const Connection&, UpdateKind = UpdateKind::sync);
 
    bool removeConnection (const Connection&, UpdateKind = UpdateKind::sync);
 
    bool disconnectNode (NodeID, UpdateKind = UpdateKind::sync);
 
    bool isConnectionLegal (const Connection&) const;
 
    bool removeIllegalConnections (UpdateKind = UpdateKind::sync);
 
    void rebuild();
 
    //==============================================================================
    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;
 
        bool hasEditor() const override;
        AudioProcessorEditor* createEditor() override;
 
        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;
 
    bool hasEditor() const override                         { return false; }
    AudioProcessorEditor* createEditor() override           { return nullptr; }
    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:
    class Pimpl;
    std::unique_ptr<Pimpl> pimpl;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioProcessorGraph)
};
 
} // namespace juce