process.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 <vector>
 
// RTTI includes
#include <rtti/rtti.h>
 
// Nap includes
#include <utility/threading.h>
 
// Audio includes
#include <audio/utility/asyncobserver.h>
#include <audio/utility/audiotypes.h>
#include <audio/utility/safeptr.h>
 
namespace nap
{
    namespace audio
    {
 
        // Forward declarations
        class NodeManager;
        class Node;
        class ParentProcess;
 
        class NAPAPI Process
        {
            RTTI_ENABLE()
 
            friend class NodeManager;
 
        public:
            Process(NodeManager& nodeManager);
 
            Process(ParentProcess& parent);
 
            /*
             * We need to delete these so that the compiler doesn't try to use them. Otherwise we get compile errors on vector<unique_ptr>.
             */
            Process(const Process&) = delete;
            Process& operator=(const Process&) = delete;
 
            virtual ~Process();
 
            /*
             * Invoked by OutputPin::pull() methods and by parent processes.
             * Makes sure all the output pins of this node are filled with a sample buffer up to the current time stamp.
             * In practice calls process() call if the process is not up to date.
             */
            void update();
 
            NodeManager& getNodeManager() const { return *mNodeManager; }
 
            int getBufferSize() const;
 
            float getSampleRate() const;
 
            DiscreteTimeValue getSampleTime() const;
 
        protected:
            virtual void sampleRateChanged(float sampleRate) { }
 
            virtual void bufferSizeChanged(int bufferSize) { }
 
            bool isRegisteredWithNodeManager() const { return mRegisteredWithNodeManager.load(); }
 
        private:
            virtual void process() = 0;
 
            /*
             * Used by the node manager to notify the node that the buffer size has changed.
             * @param bufferSize the new value
             */
            virtual void setBufferSize(int bufferSize) { bufferSizeChanged(bufferSize); }
 
            /*
             * Used by the node manager to notify the node that the sample rate has changed.
             * @param sampleRate: the new value
             */
            void setSampleRate(float sampleRate) { sampleRateChanged(sampleRate); }
 
            NodeManager* mNodeManager = nullptr; // The node manager that this process is processed on
            DiscreteTimeValue mLastCalculatedSample = 0; // The time stamp of the latest calculated sample by this node
 
            // Set to true when the node has made itself known with the node manager. This registration is deferred to the audio thread so it has to be tracked by this boolean.
            std::atomic<bool> mRegisteredWithNodeManager = { false };
        };
 
 
        class NAPAPI ParentProcess : public Process
        {
            RTTI_ENABLE(Process)
 
        public:
            enum class Mode
            {
                Sequential, Parallel
            };
 
        public:
            ParentProcess(NodeManager& nodeManager, ThreadPool& threadPool, AsyncObserver& observer) : Process(
                    nodeManager), mThreadPool(threadPool), mAsyncObserver(observer)
            {}
 
            ParentProcess(ParentProcess& parent) : Process(parent), mThreadPool(parent.mThreadPool),
                                                   mAsyncObserver(parent.mAsyncObserver)
            { }
 
            void addChild(Process& child);
 
            void removeChild(Process& child);
 
            void processParallel();
 
            void processSequential();
 
            void process() override;
 
            void setMode(Mode mode) { mMode.store(mode); }
 
            Mode getMode() const { return mMode.load(); }
 
        private:
            ThreadPool& mThreadPool;
            AsyncObserver& mAsyncObserver;
            std::vector<Process*> mChildren;
            std::atomic<Mode> mMode = {Mode::Sequential};
        };
 
 
    }
}