audiopin.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Std includes
#include <set>
#include <mutex>
 
// RTTI includes
#include <rtti/rtti.h>
 
// Audio includes
#include <audio/utility/audiotypes.h>
 
 
namespace nap
{
    namespace audio
    {
 
        // Forward declarations
        class Node;
        class InputPin;
        class OutputPin;
 
 
        class NAPAPI InputPinBase
        {
            RTTI_ENABLE()
        public:
            InputPinBase(Node* node);
 
            virtual ~InputPinBase();
 
            virtual void connect(OutputPin& input) = 0;
 
            virtual void disconnect(OutputPin& input) = 0;
 
            virtual void disconnectAll() = 0;
 
            virtual bool isConnected() const = 0;
 
            void enqueueConnect(OutputPin& pin);
 
            void enqueueDisconnect(OutputPin& pin);
 
            Node& getNode() { return *mNode; }
 
        private:
            // The node that owns this input
            Node* mNode = nullptr;
        };
 
 
        class NAPAPI InputPin final : public InputPinBase
        {
            RTTI_ENABLE(InputPinBase)
 
            friend class OutputPin;
 
        public:
            InputPin(Node* node) : InputPinBase(node) { }
 
            virtual ~InputPin() override;
 
            SampleBuffer* pull();
 
            void connect(OutputPin& input) override;
 
 
            void disconnect(OutputPin& input) override;
 
 
            void disconnectAll() override;
 
            bool isConnected() const override { return mInput != nullptr; }
 
        private:
            /*
             * The audio output connected to this input.
             * When it is a nullptr this input is not connected.
             */
            OutputPin* mInput = nullptr;
        };
 
 
        class NAPAPI MultiInputPin final : public InputPinBase
        {
            RTTI_ENABLE(InputPinBase)
 
        public:
            MultiInputPin(Node* node, unsigned int reservedInputCount = 2);
 
            virtual ~MultiInputPin() override;
 
            void pull(std::vector<SampleBuffer*>& result);
 
            void connect(OutputPin& input) override;
 
            void disconnect(OutputPin& input) override;
 
            void disconnectAll() override;
 
            bool isConnected() const override { return !mInputs.empty(); }
 
            void reserveInputs(unsigned int inputCount);
 
        private:
            std::vector<OutputPin*> mInputs;
            std::vector<OutputPin*> mInputsCache;
        };
 
 
        class NAPAPI OutputPin final
        {
            RTTI_ENABLE()
 
            friend class Node;
            friend class InputPinBase;
            friend class InputPin;
            friend class MultiInputPin;
 
        public:
            OutputPin(Node* node);
 
            ~OutputPin();
 
            void disconnectAll();
 
            bool isConnected() const
            { return !mOutputs.empty(); }
 
            SampleBuffer* pull();
 
            Node& getNode() { return *mNode; }
 
        protected:
            SampleBuffer mBuffer; 
 
        private:
            // Used by the NodeManager to resize the internal buffers when necessary
            void setBufferSize(int bufferSize);
 
            // The node that owns this output
            Node* mNode = nullptr;
 
            // The inputs that this output is connected to
            // This list is kept so the connections can be broken on destruction.
            std::set<InputPinBase*> mOutputs;
        };
 
    }
 
}