cVideoCodec.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVideoCodec_H
#define _INC_cVideoCodec_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "../Image/cSurfaceInfo.h"
#include "../Image/cSurfaceBase.h"
#include "../UID/cFourCC.h"
 
namespace GrayLib
{
        typedef short AV_QUALITY_t;                                                             
        static const AV_QUALITY_t k_AV_QUALITY_DEF = -1;                
        static const AV_QUALITY_t k_AV_QUALITY_0 = 0;                   
        static const AV_QUALITY_t k_AV_QUALITY_MAX = 10000;             
 
        struct GRAYLIB_LINK IVideoCompress
        {
                // IGNORE_WARN_ABSTRACT(IVideoCompress);
 
                virtual ~IVideoCompress()
                {
                }
                virtual HRESULT CompStart(const cSurfaceInfo& rInfo, cSurfaceBitmapInfo* pbiOut) = 0;
                virtual HRESULT CompFrame(const cSurfaceBase& frame, OUT const void*& rpCompRet, OUT size_t& rnSizeRet, OUT bool& rbIsKey) = 0; // cMemBlock ??
                virtual void CompEnd()
                {
                }
                virtual AV_QUALITY_t get_CompQuality() const
                {
                        return k_AV_QUALITY_MAX;        // assume uncompressed.
                }
        };
 
        struct GRAYLIB_LINK IVideoDecompress
        {
                // IGNORE_WARN_ABSTRACT(IVideoDecompress);
                virtual ~IVideoDecompress()
                {
                }
                virtual HRESULT DecompStart(const cSurfaceBitmapInfo* pbiInp, cSurfaceInfo* pFrameInfo) = 0;
                virtual HRESULT DecompFrame(const void* pCompData, size_t nSizeComp, cSurfaceBase& frame) = 0;
                virtual void DecompEnd()
                {
                }
        };
 
        class GRAYLIB_LINK cVideoCodecNull : public IVideoCompress, public IVideoDecompress
        {
 
        public:
                static const FOURCC k_Form = MAKEFOURCC('D', 'I', 'B', ' ');    // BI_RGB
 
                cVideoCodecNull() noexcept
                {
                }
                virtual ~cVideoCodecNull() noexcept
                {
                }
 
                virtual HRESULT CompStart(const cSurfaceInfo& rInfo, cSurfaceBitmapInfo* pbiOut) override
                {
                        pbiOut->SetSurfaceInfo(rInfo);
                        return S_OK;
                }
 
                virtual HRESULT CompFrame(const cSurfaceBase& frame, OUT const void*& rpCompRet, OUT size_t& rnSizeRet, OUT bool& rbIsKey) override
                {
                        rbIsKey = true;
                        rnSizeRet = frame.get_Info().get_SurfaceSize();
                        rpCompRet = frame.get_PixelData();
                        return S_OK;
                }
 
                virtual HRESULT DecompStart(const cSurfaceBitmapInfo* pbiInp, cSurfaceInfo* pFrameInfo) override
                {
                        if (pbiInp == nullptr)
                                return E_POINTER;
                        if (pFrameInfo != nullptr)
                        {
                                pFrameInfo->SetBitmapInfo(pbiInp);
                        }
                        return S_OK;
                }
 
                virtual HRESULT DecompFrame(const void* pCompData, size_t nSizeComp, cSurfaceBase& frame) override
                {
                        if (nSizeComp != frame.get_Info().get_SurfaceSize())
                                return E_FAIL;
                        frame.put_PixelData(const_cast<void*>(pCompData));
                        return S_OK;
                }
        };
} 
 
#endif