MoviePlatform.h

#pragma once
#include <vector>
#include "IAttributeFields.h"
#include "IMovieCodec.h"
#include <mutex>
namespace ParaEngine
{
    using namespace std;

    enum MOVIE_RECORDING_STATE
    {
        RECORDER_STATE_BEGIN=0,
        RECORDER_STATE_PAUSED,
        RECORDER_STATE_END
    };

    class CMoviePlatform : public IAttributeFields
    {
    public:
        CMoviePlatform(void);
        virtual ~CMoviePlatform(void);
        static CMoviePlatform& GetSingleton();

        void Cleanup();

        IMovieCodec* GetMovieCodec(bool bCreateIfNotExist = true);

    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){ return ATTRIBUTE_CLASSID_MoviePlatform; }
        virtual const char* GetAttributeClassName(){ static const char name[] = "MoviePlatform"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CMoviePlatform, video_encode_example_s, const char*)  { cls->video_encode_example(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CMoviePlatform, GetCodec_s, int*) { *p1 = cls->GetCodec(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetCodec_s, int)  { cls->SetCodec(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, GetMarginLeft_s, int*)    { *p1 = cls->MarginLeft(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetMarginLeft_s, int) { cls->MarginLeft(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CMoviePlatform, GetMarginTop_s, int*) { *p1 = cls->MarginTop(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetMarginTop_s, int)  { cls->MarginTop(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CMoviePlatform, GetMarginRight_s, int*)   { *p1 = cls->MarginRight(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetMarginRight_s, int)    { cls->MarginRight(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CMoviePlatform, GetMarginBottom_s, int*)  { *p1 = cls->MarginBottom(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetMarginBottom_s, int)   { cls->MarginBottom(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, HasMoviePlugin_s, bool*)  { *p1 = cls->HasMoviePlugin(); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, GetRecordingFPS_s, int*)  { *p1 = cls->GetRecordingFPS(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetRecordingFPS_s, int)   { cls->SetRecordingFPS(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, GetVideoBitRate_s, int*)  { *p1 = cls->GetVideoBitRate(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetVideoBitRate_s, int)   { cls->SetVideoBitRate(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, IsCaptureMic_s, bool*)    { *p1 = cls->IsCaptureMic(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetCaptureMic_s, bool)    { cls->SetCaptureMic(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, IsCaptureAudio_s, bool*)  { *p1 = cls->IsCaptureAudio(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetCaptureAudio_s, bool)  { cls->SetCaptureAudio(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, GetStereoCaptureMode_s, int*) { *p1 = cls->GetStereoCaptureMode(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetStereoCaptureMode_s, int)  { cls->SetStereoCaptureMode((MOVIE_CAPTURE_MODE)p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMoviePlatform, GetStereoEyeSeparation_s, float*) { *p1 = cls->GetStereoEyeSeparation(); return S_OK; }
        ATTRIBUTE_METHOD1(CMoviePlatform, SetStereoEyeSeparation_s, float)  { cls->SetStereoEyeSeparation(p1); return S_OK; }
    public:
        void video_encode_example(const char *filename, int codec_id = 0);

        virtual void SetCodec(int nCodec);

        virtual int GetCodec();
    public:
        typedef std::function<void(bool, std::vector<BYTE>& base64)>            screenshot_callback;

    public:
        void CleanUp();

        void SetCaptureGUI(bool bGUI){m_bCaptureGUI = bGUI;}
        bool CaptureGUI(){return m_bCaptureGUI;};

        void SetMovieName(string name){m_sMovieName = name;}
        string GetMovieName(){return m_sMovieName;}

        int GetScreenWidth(){return m_nScreenWidth;}
        int GetScreenHeight(){return m_nScreenHeight;}

        void SetVideoBitRate(int nRate);
        int GetVideoBitRate();

        void SetMovieScreenSize(int nWidth, int nHeight);
        void GetMovieScreenSize(int* nWidth, int* nHeight);

        string GetMovieFileName();

        void BeginCaptureFrame();
        void EndCaptureFrame();
        //
        // screen capture and movie setting
        //

        bool BeginCapture(const string& sFileName);
        bool EndCapture();
        void PauseCapture();
        void ResumeCapture();
        bool IsInCaptureSession();
        bool IsRecording();

        bool SetCaptureTarget();
        bool UnsetCaptureTarget();
        void RenderCaptured();

        void SaveCapturedFrame(int nMode=0);

        bool TakeScreenShot(const string& filename);

        void TakeScreenShot_Async(const string& filename, bool bEncode = false, int width = -1, int height = -1, screenshot_callback callback = nullptr);
        bool TakeScreenShot_FromGDI(const string& filename, std::vector<BYTE>& outBase64Buffers, bool bEncode = false, int width = -1, int height = -1);
        int CaptureBitmapBuffer(HWND nHwnd, int& outFileHeaderSize, int& outInfoHeaderSize, std::vector<BYTE>& outBuffers, bool bCaptureMouse = false, int nLeft = 0, int nTop = 0, int width = 0, int height = 0);

        bool TakeScreenShot(const string& filename, int width, int height);
        
        bool ResizeImage(const string& filename, int width, int height, const string& destFilename);

        bool GetImageInfo(const string& filename, int* width, int* height, int* nFileSize);

        HRESULT InvalidateDeviceObjects(); // called just before device is Reset
        HRESULT RestoreDeviceObjects();    // called when device is restored

        void EnableCodecSelection(bool bEnable);
        bool IsCodecSelectionEnabled();


        void SetRecordingFPS(int nFPS);

        int GetRecordingFPS();

        void SetStereoCaptureMode(MOVIE_CAPTURE_MODE nMode = MOVIE_CAPTURE_MODE_NORMAL);

        MOVIE_CAPTURE_MODE GetStereoCaptureMode();

        void SetStereoEyeSeparation(float fDist);

        float  GetStereoEyeSeparation();

        int GetCurrentFrameNumber();

        void FrameCaptureFFMPEG();

        void FrameCaptureDX(IMovieCodec* pMovieCodec);

        bool HasMoviePlugin();

        void SetCaptureAudio(bool bEnable);
        bool IsCaptureAudio();

        void SetCaptureMic(bool bEnable);
        bool IsCaptureMic();

        bool IsUseGDI() const;
        void SetUseGDI(bool val);

    private:
        IMovieCodec* m_pMovieCodec;
        string m_sMovieName;
        string m_beginningStr;
        string m_endingStr;
        float m_fLastRefreshInterval;

        std::vector<std::function<void()>> m_functionsToPerform;
        std::mutex m_performMutex;
        
#ifdef USE_DIRECTX_RENDERER
        LPDIRECT3DTEXTURE9 m_pCaptureTexture;
        LPDIRECT3DSURFACE9 m_pCaptureSurface;
        LPDIRECT3DSURFACE9 m_pBackBufferSurface;
        LPDIRECT3DSURFACE9 m_pOldDepthStencilSurface, m_pDepthStencilSurface; 
        LPDIRECT3DSURFACE9 m_pOffScreenSurface;
        HDC m_CompatibleHDC;
        HBITMAP m_BitmapHandle;
#endif

        bool m_bUseGDI;
        MOVIE_RECORDING_STATE m_recorderState;
        bool m_bCaptureGUI;
        bool m_bRenderBorder;
        bool m_bUseWaterMark;
        int m_nScreenWidth;
        int m_nScreenHeight;

        int m_nMarginLeft;
        int MarginLeft() const { return m_nMarginLeft; }
        void MarginLeft(int val) { m_nMarginLeft = val; }
        int m_nMarginRight;
        int MarginRight() const { return m_nMarginRight; }
        void MarginRight(int val) { m_nMarginRight = val; }
        int m_nMarginTop;
        int MarginTop() const { return m_nMarginTop; }
        void MarginTop(int val) { m_nMarginTop = val; }
        int m_nMarginBottom;
        int MarginBottom() const { return m_nMarginBottom; }
        void MarginBottom(int val) { m_nMarginBottom = val; }

        int m_nRecordingFPS;
        bool m_bAllowCodecSelection;

        MOVIE_CAPTURE_MODE m_nStereoCaptureMode;

        float m_nStereoEyeSeparation;
        

        bool m_isLeftEye;
    };

}