sequenceplayeraudiooutput.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
 
// nap includes
#include <nap/resourceptr.h>
#include <nap/signalslot.h>
#include <sequenceplayeroutput.h>
#include <audio/node/outputnode.h>
#include <audio/resource/audiobufferresource.h>
#include <audio/service/audioservice.h>
#include <nap/signalslot.h>
#include <rtti/objectptr.h>
#include <audio/node/mixnode.h>
 
// local includes
#include "sequenceplayeraudioadapter.h"
#include "multisamplebufferplayernode.h"
 
namespace nap
{
 
    // forward declares
    class SequenceService;
 
    // shortcut to map of created multi sample buffer player nodes
    using BufferPlayerMap = std::unordered_map<std::string, audio::SafeOwner<audio::MultiSampleBufferPlayerNode>>;
 
    class NAPAPI SequencePlayerAudioOutput final : public SequencePlayerOutput
    {
        friend class SequencePlayerAudioAdapter;
 
        RTTI_ENABLE(SequencePlayerOutput);
    public:
        SequencePlayerAudioOutput(SequenceService& service);
 
        bool init(utility::ErrorState& errorState) override;
 
        void onDestroy() override;
 
        virtual const std::vector<rtti::ObjectPtr<audio::AudioBufferResource>>& getBuffers() const;
 
        void connectInputPin(audio::InputPin& inputPin, int channel);
 
        void disconnectInputPin(audio::InputPin& inputPin, int channel);
 
        audio::OutputPin* getOutputForChannel(int channel);
 
        int getChannelCount() const;
 
        // properties
 
        //Resource pointers to AudioBuffers
        std::vector<ResourcePtr<audio::AudioBufferResource>> mAudioBuffers; 
 
        bool mManualRouting = false; 
 
        int mMaxChannels = 8; 
    protected:
        void update(double deltaTime) override;
 
    private:
        void handleAudioSegmentPlay(const SequencePlayerAudioAdapter* adapter, const std::string& id, double time,
                                    float playbackSpeed);
 
        void handleAudioSegmentStop(const SequencePlayerAudioAdapter* adapter, const std::string& id);
 
        void registerAdapter(const SequencePlayerAudioAdapter* adapter);
 
        void unregisterAdapter(const SequencePlayerAudioAdapter* adapter);
 
        // pointer to audio service
        audio::AudioService* mAudioService;
 
        // map of BufferPlayerMaps
        std::unordered_map<const SequencePlayerAudioAdapter*, BufferPlayerMap> mBufferPlayers;
 
        // map of output nodes created and owned by SequencePlayerAudioOutput
        std::vector<audio::SafeOwner<audio::OutputNode>> mOutputNodes;
 
        // mix nodes created and owned by SequencePlayerAudioOutput
        std::vector<audio::SafeOwner<audio::MixNode>> mMixNodes;
 
        // Buffer players are delete on audio thread. When an adapter is disconnected, the buffer players are moved
        // to this vector and deleted on the next update of the audio thread.
        std::mutex mBufferPlayersToDeleteMutex;
        std::vector<audio::SafeOwner<audio::MultiSampleBufferPlayerNode>> mBufferPlayersToDelete;
    };
 
    // shortcut to factory function
    using SequencePlayerAudioOutputObjectCreator = rtti::ObjectCreator<SequencePlayerAudioOutput, SequenceService>;
}