sequenceplayeraudioclock.h

#pragma once
 
#include "sequenceserviceaudio.h"
 
#include <audio/utility/audiotypes.h>
#include <sequenceplayerclock.h>
#include <audio/core/process.h>
#include <concurrentqueue.h>
 
namespace nap
{
 
    // forward declares
    class SequenceServiceAudio;
    class SequencePlayerAudioClockProcess;
 
    class NAPAPI SequencePlayerAudioClock final : public SequencePlayerClock
    {
        RTTI_ENABLE(SequencePlayerClock);
    public:
        SequencePlayerAudioClock(SequenceServiceAudio& service);
 
        // make this class explicitly non-copyable
        SequencePlayerAudioClock(const SequencePlayerAudioClock&) = delete;
        SequencePlayerAudioClock& operator =(const SequencePlayerAudioClock&) = delete;
 
        void onDestroy() override;
 
        void start(Slot<double>& updateSlot) override;
 
        void stop() override;
 
    private:
        // reference to SequenceAudioService
        SequenceServiceAudio& mService;
 
        // update slot, updates sequence player
        Slot<double> mUpdateSlot;
 
        // the audio clock process
        audio::SafeOwner<SequencePlayerAudioClockProcess> mAudioClockProcess;
    };
 
    // shortcut to factory function
    using SequencePlayerAudioClockObjectCreator = rtti::ObjectCreator<SequencePlayerAudioClock, SequenceServiceAudio>;
 
    class NAPAPI SequencePlayerAudioClockProcess final : public audio::Process
    {
        RTTI_ENABLE(audio::Process)
    public:
        SequencePlayerAudioClockProcess(audio::NodeManager& nodeManager);
 
        /*
         * We need to delete these so that the compiler doesn't try to use them. Otherwise we get compile errors on vector<unique_ptr>.
         */
        SequencePlayerAudioClockProcess(const SequencePlayerAudioClockProcess&) = delete;
        SequencePlayerAudioClockProcess& operator=(const SequencePlayerAudioClockProcess&) = delete;
 
        virtual ~SequencePlayerAudioClockProcess();
 
        void connectSlot(Slot<double>& slot);
 
        void disconnectUpdateSlot(Slot<double>& slot);
 
        // Signals
        Signal<double> mUpdateSignal;
    protected:
        void process() override;
 
    private:
        // last known timestamp in samples
        audio::DiscreteTimeValue mTime;
 
        // queue of tasks to perform on process()
        moodycamel::ConcurrentQueue<std::function<void()>> mTasks;
    };
 
}