sequenceplayer.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
 
// internal includes
#include "sequence.h"
#include "sequenceplayeradapter.h"
#include "sequenceplayeroutput.h"
#include "sequenceservice.h"
#include "sequenceplayerclock.h"
 
// external includes
#include <rtti/factory.h>
#include <nap/device.h>
#include <nap/signalslot.h>
#include <future>
#include <mutex>
#include <nap/timer.h>
#include <concurrentqueue.h>
#include <nap/numeric.h>
 
namespace nap
{
 
    // forward declares
    class SequenceService;
 
    class NAPAPI SequencePlayer : public Device
    {
        friend class SequenceEditor;
        friend class SequenceController;
 
    RTTI_ENABLE(Device)
    public:
        SequencePlayer(SequenceService& service);
 
        bool init(utility::ErrorState& errorState) override;
 
        bool save(const std::string& name, utility::ErrorState& errorState);
 
        bool load(const std::string& name, utility::ErrorState& errorState);
 
        bool loadBinary(const std::vector<nap::uint8>& buffer, utility::ErrorState& errorState);
 
        void setIsPlaying(bool isPlaying);
 
        void setIsPaused(bool isPaused);
 
        void setIsLooping(bool isLooping);
 
        void setPlayerTime(double time);
 
        void setPlaybackSpeed(float speed);
 
        double getPlayerTime() const;
 
        double getDuration() const;
 
        bool getIsPlaying() const;
 
        bool getIsLooping() const;
 
        bool getIsPaused() const;
 
        float getPlaybackSpeed() const;
 
        void stop() override;
 
        bool start(utility::ErrorState& errorState) override;
 
        const Sequence& getSequenceConst() const;
 
        const std::string& getSequenceFilename() const;
 
        // signals
        /***
         * playbackSpeedChanged signal is dispatched when setPlaybackSpeed(float) method is called on SequencePlayer
         * This is useful when you want to sync or invoke other methods with the SequencePlayer
         * Note: Signal is dispatched from whichever thread is calling the setPlaybackSpeed(float) method on SequencePlayer
         */
        Signal<SequencePlayer&, float> playbackSpeedChanged;
 
        /***
         * playerTimeChanged signal is dispatched when setPlayerTime(double) method is called on SequencePlayer
         * This is useful when you want to sync or invoke other methods with the SequencePlayer
         * Note: Signal is dispatched from whichever thread is calling the setPlayerTime(double) method on SequencePlayer
         */
        Signal<SequencePlayer&, double> playerTimeChanged;
 
        /***
         * playStateChanged signal is dispatched when setIsPlaying(bool) method is called on SequencePlayer
         * This is useful when you want to sync or invoke other methods with the SequencePlayer
         * Note: Signal is dispatched from whichever thread is calling the setIsPlaying(bool) method on SequencePlayer
         * Note: Play state doesn't mean Paused or not. The SequencePlayer can be Paused but still be Playing, in which case time doesn't get updated but adapter will still be called
         */
        Signal<SequencePlayer&, bool> playStateChanged;
 
        /***
         * pauseStateChanged signal is dispatched when setIsPaused(bool) method is called on SequencePlayer
         * This is useful when you want to sync or invoke other methods with the SequencePlayer
         * Note: Signal is dispatched from whichever thread is calling the setIsPaused(bool) method on SequencePlayer
         * Note: Play state doesn't mean Paused or not. The SequencePlayer can be Paused but still be Playing, in which case time doesn't get updated but adapter will still be called
         */
        Signal<SequencePlayer&, bool> pauseStateChanged;
 
        /***
         *  preTick Signal is triggered on player thread, before updating the adapters
         */
        Signal<SequencePlayer&> preTick;
 
        Signal<SequencePlayer&> postTick;
 
        /***
         * sequenceLoaded signal is dispatched when the load(name) method succeeds on SequencePlayer
         */
        Signal<SequencePlayer&, std::string> sequenceLoaded;
 
        Signal<SequencePlayer&> edited;
 
        // properties
        std::string mSequenceFileName; 
        bool mCreateEmptySequenceOnLoadFail = true; 
        std::vector<ResourcePtr<SequencePlayerOutput>> mOutputs;  
        ResourcePtr<SequencePlayerClock> mClock;    
    protected:
        Signal<std::function<void(const std::string&, std::unique_ptr<SequencePlayerAdapter>)>&> adaptersCreated;
 
        // Reference to sequence service
        SequenceService& mService;
    private:
        Sequence& getSequence();
 
        bool createAdapter(const std::string& objectID, const std::string& trackID);
 
        void tick(double deltaTime);
 
        // read objects from sequence
        std::vector<std::unique_ptr<rtti::Object>> mReadObjects;
 
        // read object ids from sequence
        std::unordered_set<std::string> mReadObjectIDs;
 
        void createAdapters();
 
        void destroyAdapters();
 
        void performEditAction(std::function<void()> &action);
 
        // mutex
        std::mutex mMutex;
 
        // raw pointer to loaded sequence
        Sequence *mSequence = nullptr;
 
        // is playing
        bool mIsPlaying = false;
 
        // is paused
        bool mIsPaused = false;
 
        // is looping
        bool mIsLooping = false;
 
        // speed
        float mSpeed = 1.0f;
 
        // current time
        double mTime = 0.0;
 
        // list of instantiated adapters
        std::unordered_map<std::string, std::unique_ptr<SequencePlayerAdapter>> mAdapters;
    };
 
    using SequencePlayerObjectCreator = rtti::ObjectCreator<SequencePlayer, SequenceService>;
}