cVideoFS.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVideoFS_H
#define _INC_cVideoFS_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVideoCodec.h"
#include "cAVSink.h"
#include "../Math/cBitArray.h"
#include "../Image/cSurfaceBase.h"
#include "../Geometry/cRectI.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cArray.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cVideoFS
        {
 
        public:
                static const int k_BLOCK_DEF = 32;
                static const FOURCC k_Form = MAKEFOURCC('F', 'S', 'V', '1');    // FSV1
 
                cWinSize m_BlockSize;                   
                cWinSize m_FrameSize;                   
 
                cWinSize m_Blocks;                              
                UINT m_nFrameNum;                               
                cArrayVal<cColor888> m_BlockTmp;        
 
        protected:
                cVideoFS(int nBlockX = k_BLOCK_DEF, int nBlockY = k_BLOCK_DEF);
                ~cVideoFS();
 
                void UpdateBlockParams();
                BYTE* BuildCompFrameHeader(BYTE* pComp) const;
 
                bool isReady() const noexcept
                {
                        return m_Blocks.cx && m_Blocks.cy;
                }
                int get_BlocksTotal() const noexcept
                {
                        return m_Blocks.cx*m_Blocks.cy;
                }
 
                void GetBlockRect(int col, int row, cRectI& rect) const noexcept
                {
                        rect.left = col * m_BlockSize.cx;
                        rect.top = row * m_BlockSize.cy;
                        rect.right = (col >= m_Blocks.cx - 1) ? m_FrameSize.cx : (rect.left + m_BlockSize.cx);
                        rect.bottom = (row >= m_Blocks.cy - 1) ? m_FrameSize.cy : (rect.top + m_BlockSize.cy);
                }
 
                UNITTEST_FRIEND(cVideoFS);
        };
 
        class GRAYLIB_LINK cVideoFSComp : public IVideoCompress, public cVideoFS
        {
 
        protected:
                cNewPtr<cColor888> m_FrameLast; 
 
                // Temporary buffers while compressing.
                cBitArrayStatic m_BlocksDirty;  
                cHeapBlock m_CompFrame;         
 
        protected:
                void SetBlockDirty(int x, int y);
                void UpdateBlockDirtyBits(const cSurfaceBase& frame);
                size_t AddImageBlock(BYTE* pComp, INT_PTR nCompSizeMax, int row, int col);
 
        public:
                cVideoFSComp(int nBlockX = k_BLOCK_DEF, int nBlockY = k_BLOCK_DEF);
                cVideoFSComp(const cVideoFSComp& copythis);
                virtual ~cVideoFSComp();
 
                // IVideoCompress
                virtual HRESULT CompStart(const cSurfaceInfo& rInfo, cSurfaceBitmapInfo* pbiOut) override;
                virtual HRESULT CompFrame(const cSurfaceBase& frame, OUT const void*& rpCompRet, OUT size_t& rnSizeRet, OUT bool& rbIsKey) override;
        };
 
        class GRAYLIB_LINK cVideoFSDecomp : public IVideoDecompress, public cVideoFS
        {
        public:
                virtual HRESULT DecompStart(const cSurfaceBitmapInfo* pbiInp, cSurfaceInfo* pFrameInfo) override;
                virtual HRESULT DecompFrame(const void* pCompData, size_t nSizeComp, cSurfaceBase& frame) override;
        };
 
        class GRAYLIB_LINK cVideoFSRateController : public cAVRateController, public cVideoFS
        {
 
        protected:
                struct CBlock
                {
                        cTimeSys m_tUpdated;                    
                        cHeapBlock m_Compressed;                
                };
 
                cArrayStruct<CBlock> m_aBlocks; 
                cHeapBlock m_CompFrame;                 
 
        protected:
                void UpdateBlockParams();
 
        public:
                cVideoFSRateController()
                {
                }
                virtual ~cVideoFSRateController()
                {
                }
 
                // cAVSink in cAVRateController
                virtual HRESULT OnHeaderStream(const cAVHeaderStream& head, const void* pForm, size_t nSizeForm) override;
                virtual HRESULT OnFrame(const cAVHeaderFrame& head, const void* pData, size_t nSizeData) override;
 
                // cAVRateController
                virtual HRESULT BuildCompFrame(TIMESYS_t tWhenLast, const void*& rpCompRet, size_t& rnSizeRet) override;
        };
};
#endif