AudioProcessorGraph.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the Water library.
   Copyright (c) 2015 ROLI Ltd.
   Copyright (C) 2017-2022 Filipe Coelho <falktx@falktx.com>
 
   Permission is granted to use this software under the terms of the GNU
   General Public License as published by the Free Software Foundation;
   either version 2 of the License, or any later version.
 
   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
   For a full copy of the GNU General Public License see the doc/GPL.txt file.
 
  ==============================================================================
*/
 
#ifndef WATER_AUDIOPROCESSORGRAPH_H_INCLUDED
#define WATER_AUDIOPROCESSORGRAPH_H_INCLUDED
 
#include "AudioProcessor.h"
#include "../containers/OwnedArray.h"
#include "../containers/ReferenceCountedArray.h"
#include "../midi/MidiBuffer.h"
 
namespace water {
 
//==============================================================================
class AudioProcessorGraph   : public AudioProcessor
{
public:
    //==============================================================================
    AudioProcessorGraph();

    ~AudioProcessorGraph();
 
    //==============================================================================
    class Node   : public ReferenceCountedObject
    {
    public:
        //==============================================================================
        const uint32 nodeId;

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

        struct Properties {
            bool isAudio;
            bool isCV;
            bool isMIDI;
            bool isOSC;
            bool isOutput;
            bool isPlugin;
            uint32_t pluginId;
 
            struct Position {
                int x1, x2, y1, y2;
                bool valid;
 
                Position() noexcept
                    : x1(0),
                      x2(0),
                      y1(0),
                      y2(0),
                      valid(false) {}
            } position;
 
            Properties() noexcept
                : isAudio(false),
                  isCV(false),
                  isMIDI(false),
                  isOSC(false),
                  isOutput(false),
                  isPlugin(false),
                  pluginId(0),
                  position() {}
        } properties;
 
        //==============================================================================
        typedef ReferenceCountedObjectPtr<Node> Ptr;
 
    private:
        //==============================================================================
        friend class AudioProcessorGraph;
 
        const CarlaScopedPointer<AudioProcessor> processor;
        bool isPrepared;
 
        Node (uint32 nodeId, AudioProcessor*) noexcept;
 
        void setParentGraph (AudioProcessorGraph*) const;
        void prepare (double newSampleRate, int newBlockSize, AudioProcessorGraph*);
        void unprepare();
 
        CARLA_DECLARE_NON_COPYABLE (Node)
    };
 
    //==============================================================================
    struct Connection
    {
    public:
        //==============================================================================
        Connection (ChannelType channelType,
                    uint32 sourceNodeId, uint sourceChannelIndex,
                    uint32 destNodeId, uint destChannelIndex) noexcept;
 
        //==============================================================================
        ChannelType channelType;

        uint32 sourceNodeId;

        uint sourceChannelIndex;

        uint32 destNodeId;

        uint destChannelIndex;
    };
 
    //==============================================================================
    void clear();

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

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

    Node* getNodeForId (const uint32 nodeId) const;

    Node* addNode (AudioProcessor* newProcessor, uint32 nodeId = 0);

    bool removeNode (uint32 nodeId);

    bool removeNode (Node* node);
 
    //==============================================================================
    size_t getNumConnections() const                                    { return connections.size(); }

    const Connection* getConnection (size_t index) const                { return connections [index]; }

    const Connection* getConnectionBetween (ChannelType channelType,
                                            uint32 sourceNodeId,
                                            uint sourceChannelIndex,
                                            uint32 destNodeId,
                                            uint destChannelIndex) const;

    bool isConnected (uint32 possibleSourceNodeId,
                      uint32 possibleDestNodeId) const;

    bool canConnect (ChannelType channelType,
                     uint32 sourceNodeId, uint sourceChannelIndex,
                     uint32 destNodeId, uint destChannelIndex) const;

    bool addConnection (ChannelType channelType,
                        uint32 sourceNodeId, uint sourceChannelIndex,
                        uint32 destNodeId, uint destChannelIndex);

    void removeConnection (int index);

    bool removeConnection (ChannelType channelType,
                           uint32 sourceNodeId, uint sourceChannelIndex,
                           uint32 destNodeId, uint destChannelIndex);

    bool disconnectNode (uint32 nodeId);

    bool isConnectionLegal (const Connection* connection) const;

    bool removeIllegalConnections();
 
    //==============================================================================
    static const uint midiChannelIndex;
 
 
    //==============================================================================
    class AudioGraphIOProcessor     : public AudioProcessor
    {
    public:
        enum IODeviceType
        {
            audioInputNode,     
            audioOutputNode,    
            midiInputNode,      
            midiOutputNode,     
            cvInputNode, cvOutputNode,
        };
 
        //==============================================================================
        IODeviceType getType() const noexcept                       { return type; }

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

        bool isInput() const noexcept;
        bool isOutput() const noexcept;
 
        //==============================================================================
        AudioGraphIOProcessor (const IODeviceType type);
        ~AudioGraphIOProcessor();
 
        const String getName() const override;
        void prepareToPlay (double newSampleRate, int estimatedSamplesPerBlock) override;
        void releaseResources() override;
        void processBlockWithCV (AudioSampleBuffer& audioBuffer,
                                 const AudioSampleBuffer& cvInBuffer,
                                 AudioSampleBuffer& cvOutBuffer,
                                 MidiBuffer& midiMessages) override;
 
        bool acceptsMidi() const override;
        bool producesMidi() const override;

        void setParentGraph (AudioProcessorGraph*);
 
    private:
        const IODeviceType type;
        AudioProcessorGraph* graph;
 
        //==============================================================================
        //void processAudio (AudioSampleBuffer& buffer, MidiBuffer& midiMessages);
        void processAudioAndCV (AudioSampleBuffer& audioBuffer,
                                const AudioSampleBuffer& cvInBuffer,
                                AudioSampleBuffer& cvOutBuffer,
                                MidiBuffer& midiMessages);
 
        CARLA_DECLARE_NON_COPYABLE (AudioGraphIOProcessor)
    };
 
    //==============================================================================
    const String getName() const override;
    void prepareToPlay (double, int) override;
    void releaseResources() override;
    //void processBlock (AudioSampleBuffer&,  MidiBuffer&) override;
    void processBlockWithCV (AudioSampleBuffer& audioBuffer,
                             const AudioSampleBuffer& cvInBuffer,
                             AudioSampleBuffer& cvOutBuffer,
                             MidiBuffer& midiMessages) override;
 
    void reset() override;
    void setNonRealtime (bool) noexcept override;
 
    bool acceptsMidi() const override;
    bool producesMidi() const override;
 
    void reorderNowIfNeeded();
    const CarlaRecursiveMutex& getReorderMutex() const;
 
private:
    //==============================================================================
    // void processAudio (AudioSampleBuffer& audioBuffer, MidiBuffer& midiMessages);
    void processAudioAndCV (AudioSampleBuffer& audioBuffer,
                            const AudioSampleBuffer& cvInBuffer,
                            AudioSampleBuffer& cvOutBuffer,
                            MidiBuffer& midiMessages);
 
    //==============================================================================
    ReferenceCountedArray<Node> nodes;
    OwnedArray<Connection> connections;
    uint32 lastNodeId;
    OwnedArray<MidiBuffer> midiBuffers;
    Array<void*> renderingOps;
 
    friend class AudioGraphIOProcessor;
    struct AudioProcessorGraphBufferHelpers;
    CarlaScopedPointer<AudioProcessorGraphBufferHelpers> audioAndCVBuffers;
 
    MidiBuffer* currentMidiInputBuffer;
    MidiBuffer currentMidiOutputBuffer;
 
    bool isPrepared, needsReorder;
    CarlaRecursiveMutex reorderMutex;
 
public:
    void clearRenderingSequence();
    void buildRenderingSequence();
    bool isAnInputTo (uint32 possibleInputId, uint32 possibleDestinationId, int recursionCheck) const;
 
    CARLA_DECLARE_NON_COPYABLE (AudioProcessorGraph)
};
 
}
 
#endif // WATER_AUDIOPROCESSORGRAPH_H_INCLUDED