videoplayer.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
 
// Local Includes
#include "videofile.h"
#include "video.h"
 
// External Includes
#include <nap/device.h>
#include <nap/resourceptr.h>
#include <nap/numeric.h>
#include <texture.h>
 
namespace nap
{
    // Forward Declares
    class VideoService;
 
    class NAPAPI VideoPlayer : public Device
    {
        RTTI_ENABLE(Device)
        friend class VideoService;
    public:
 
        // Constructor
        VideoPlayer(VideoService& service);
 
        const VideoFile& getFile() const;
 
        const Video& getVideo() const;                              
 
        Video& getVideo();
 
        int getIndex() const                                        { return mCurrentVideoIndex; }
 
        int getCount() const                                        { return static_cast<int>(mVideos.size()); }
 
        bool selectVideo(int index, utility::ErrorState& error);
 
        void play(double startTime = 0.0, bool clearTextures = true);
 
        void stopPlayback()                                         { getVideo().stop(true); }
 
        bool isPlaying() const                                      { return getVideo().isPlaying(); }
 
        void loop(bool value);
 
        bool isLooping() const                                      { return mLoop; }
 
        void setSpeed(float speed);
 
        float getSpeed() const                                      { return mSpeed; }
 
        void seek(double seconds)                                   { getVideo().seek(seconds); }
 
        double getCurrentTime() const                               { return getVideo().getCurrentTime(); }
 
        double getDuration() const                                  { return getVideo().getDuration(); }
 
        int getWidth() const                                        { return getVideo().getWidth(); }
 
        int getHeight() const                                       { return getVideo().getHeight(); }
 
        bool hasAudio() const                                       { return getVideo().hasAudio(); }
 
        virtual bool start(utility::ErrorState& errorState) override;
 
        virtual void stop() override;
 
        bool hasSelection() const                               { return mCurrentVideo != nullptr; }
 
        Texture2D& getYTexture();
 
        Texture2D& getUTexture();
 
        Texture2D& getVTexture();
 
        std::vector<nap::ResourcePtr<VideoFile>> mVideoFiles;   
        nap::uint mVideoIndex = 0;                              
        bool mLoop = false;                                     
        float mSpeed = 1.0f;                                    
        
        nap::Signal<nap::VideoPlayer&> VideoChanged;
 
    private:
        void update(double deltaTime);
 
        void clearTextures();
 
        int mCurrentVideoIndex = 0;                             
        nap::Video* mCurrentVideo = nullptr;                    
        bool mTexturesCreated = false;                          
        std::vector<std::unique_ptr<nap::Video>> mVideos;       
        std::unique_ptr<Texture2D> mYTexture;                   
        std::unique_ptr<Texture2D> mUTexture;                   
        std::unique_ptr<Texture2D> mVTexture;                   
        VideoService&   mService;                               
    };
 
    // Object creator used for constructing the the OSC receiver
    using VideoPlayerObjectCreator = rtti::ObjectCreator<VideoPlayer, VideoService>;
}