audionodemanager.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 <mutex>
#include <set>
 
// Nap includes
#include <utility/threading.h>
#include <nap/signalslot.h>
 
// Audio includes
#include <audio/utility/audiotypes.h>
#include <audio/core/process.h>
 
namespace nap
{
    namespace audio
    {
 
        // Forward declarations
        class Node;
 
        class NAPAPI NodeManager final
        {
            friend class Process;
            friend class OutputNode;
            friend class InputNode;
 
        public:
            using OutputMapping = std::vector<std::vector<SampleBuffer*>>;
 
        public:
            NodeManager(DeletionQueue& deletionQueue) : mDeletionQueue(deletionQueue) { }
 
            ~NodeManager();
 
            void process(float** inputBuffer, float** outputBuffer, unsigned long framesPerBuffer);
 
            void process(std::vector<SampleBuffer*>& inputBuffer, std::vector<SampleBuffer*>& outputBuffer,
                         unsigned long framesPerBuffer);
 
            Signal<DiscreteTimeValue> mUpdateSignal;
 
            void enqueueTask(nap::TaskQueue::Task task);
 
            int getInputChannelCount() const { return mInputChannelCount; }
 
            int getOutputChannelCount() const { return mOutputChannelCount; }
 
            float getSampleRate() const { return mSampleRate; }
 
            float getSamplesPerMillisecond() const { return mSamplesPerMillisecond; }
 
            int getInternalBufferSize() const { return mInternalBufferSize; }
 
            const DiscreteTimeValue& getSampleTime() const { return mSampleTime; }
 
            void setInputChannelCount(int inputChannelCount);
 
            void setOutputChannelCount(int outputChannelCount);
 
            void setSampleRate(float sampleRate);
 
            void setInternalBufferSize(int size);
 
            void registerRootProcess(Process& rootProcess);
 
 
            void unregisterRootProcess(Process& rootProcess);
 
            template<typename T, typename... Args>
            SafeOwner<T> makeSafe(Args&& ... args)
            {
                auto owner = SafeOwner<T>(mDeletionQueue, new T(std::forward<Args>(args)...));
                return owner;
            }
 
            template<typename T>
            SafeOwner<T> makeSafe(T* ptr)
            {
                auto owner = SafeOwner<T>(mDeletionQueue, ptr);
                return owner;
            }
 
            DeletionQueue& getDeletionQueue() { return mDeletionQueue; }
 
            Signal<NodeManager&> mChannelCountChangedSignal;
 
 
        private:
            // Used by the nodes and audio processes to register themselves on construction
            void registerProcess(Process& process);
 
            // Used by the nodes and audio processes to unregister themselves on destruction
            void unregisterProcess(Process& process);
 
        private:
            /*
             * Used by @OutputNode to provide new output for the node system
             * Note: multiple output buffers can be provided for the same channel by different output nodes.
             * @param buffer: a buffer of output
             * @param channel: the channel that the output will be played on
             */
            void provideOutputBufferForChannel(SampleBuffer* buffer, int channel);
 
            /*
             * Used by @InputNode to request audio input for the current buffer
             * @param channel: the input channel that is being monitored
             * @param index: the index of the requested sample within the buffer currently being calculated.
             * TODO: optimize by returning a float array for the whole buffer
             */
            const SampleValue& getInputSample(int channel, int index) const
            {
                return mInputBuffer[channel][mInternalBufferOffset + index];
            }
 
            int mInputChannelCount = 0; // Number of input channels this node manager processes
            int mOutputChannelCount = 0; // Number of channel this node manager outputs
            float mSampleRate = 0; // Current sample rate the node manager runs on.
            float mSamplesPerMillisecond = 0; // cached here for optimization purpose
            int mInternalBufferSize = 64; // The internal buffersize that the node manager runs on.
 
            DiscreteTimeValue mSampleTime = 0; // the actual sample time clock of the audio system
            unsigned int mInternalBufferOffset = 0; // helper variable for the process method
 
            // for each output channel a vector of buffers that need to be played back on the corresponding channel
            OutputMapping mOutputMapping;
 
            std::vector<float*> mInputBuffer; //  Pointing to the audio input that this node manager has to process. The format is a non-interleaved array containing a float array for each channel.
 
            std::set<Process*> mProcesses; // all the audio processes managed by this node manager
            std::set<Process*> mRootProcesses; // the nodes that will be processed directly by the manager on every audio callback
 
            nap::TaskQueue mTaskQueue = { 256 }; // Queue with lambda functions to be executed before processing the next internal buffer.
            DeletionQueue& mDeletionQueue; // Deletion queue used to safely create and destruct nodes in a threadsafe manner.
        };
 
    }
}