cVideoBZ.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVideoBZ_H
#define _INC_cVideoBZ_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVideoCodec.h"
 
#ifdef USE_BZIP2
#include "cAVSink.h"
#include "../Math/cBitArray.h"
#include "../Image/cSurface.h"
#include "../Geometry/cRectI.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cStreamQueue.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cVideoBZ
        {
 
        public:
                static const int k_BLOCK_SIZE = 32;             // size of a block in pixels.
                static const FOURCC k_Form = MAKEFOURCC('G', 'V', 'B', 'Z');
 
                cWinSize m_Blocks;                              
                UINT m_nFrameNum;
                cSurfaceInfo m_Info;            
 
        protected:
                cVideoBZ();
                virtual ~cVideoBZ();
 
#pragma pack(push,2)
                struct CATTR_PACKED BLOCK_COORD
                {
                        BYTE col;       // x
                        BYTE row;       // y
                };
#pragma pack(pop)
 
                void UpdateBlockParams();
                static HRESULT GRAYCALL CoordWrite(cStreamOutput& out, const BLOCK_COORD& coord);
                static HRESULT GRAYCALL CoordRead(cStreamInput& stmIn, BLOCK_COORD& coord);
 
                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(const BLOCK_COORD& coord, cRectI& rect) const noexcept
                {
                        rect.left = coord.col * k_BLOCK_SIZE;
                        rect.top = coord.row * k_BLOCK_SIZE;
                        rect.right = (coord.col >= m_Blocks.cx - 1) ? m_Info.get_Width() : (rect.left + k_BLOCK_SIZE);
                        rect.bottom = (coord.row >= m_Blocks.cy - 1) ? m_Info.get_Height() : (rect.top + k_BLOCK_SIZE);
                }
 
                UNITTEST_FRIEND(cVideoBZ);
        };
 
        class GRAYLIB_LINK cVideoBZComp : public IVideoCompress, public cVideoBZ
        {
 
        public:
                cSurface m_FrameLast;   
 
                // Temporary buffers while compressing.
                cBitArrayStatic m_BlocksDirty;  
                cStreamQueue m_CompFrame;               
 
        protected:
                bool SetBlockDirty(int x, int y);
                int UpdateBlockDirtyBits(const cSurfaceBase& frame);
                // void GetBlockTmp(int row, int col);
 
        public:
                cVideoBZComp(void);
                virtual ~cVideoBZComp(void);
 
                // IVideoCompress
                virtual HRESULT CompStart(const cSurfaceInfo& rInfo, OUT cSurfaceBitmapInfo* pbiOut) override;
                virtual HRESULT CompFrame(const cSurfaceBase& frame, OUT const void*& rpCompRet, OUT size_t& rnSizeRet, OUT bool& rbIsKey) override;
        };
 
        class GRAYLIB_LINK cVideoBZDecomp : public IVideoDecompress, public cVideoBZ
        {
        public:
                cVideoBZDecomp(void);
                virtual ~cVideoBZDecomp(void);
 
                // IVideoDecompress
                virtual HRESULT DecompStart(const cSurfaceBitmapInfo* pbiInp, cSurfaceInfo* pFrameInfo) override;
                virtual HRESULT DecompFrame(const void* pCompData, size_t nSizeComp, cSurfaceBase& frame) override;
        };
 
        class GRAYLIB_LINK cVideoBZRateController : public cAVRateController, public cVideoBZ
        {
 
        protected:
                struct cBlock
                {
                        cTimeSys m_tUpdated;                    
                };
 
                cArrayStruct<cBlock> m_aBlocks; 
                cSurface                m_FrameLast;            
                cStreamQueue    m_CompFrame;            
                cTimeSys                m_tUpdateOldest;        
 
        public:
                cVideoBZRateController();
 
                // 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;
 
        protected:
                void UpdateBlockParams();
        };
} 
 
#endif
#endif