cVideoVFW.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVideoVFW_H
#define _INC_cVideoVFW_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVideoCodec.h"
 
#if defined(_WIN32) && ! defined(UNDER_CE)
#include "../WinAPI/WinTypes.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/cHandlePtr.h"
 
#include <vfw.h>        // COMPVARS ICINFO
 
namespace Gray
{
        template <> inline void cHandlePtr<HIC>::CloseHandle(HIC h) // static
        {
                ::ICClose(h);
        }
}
 
namespace GrayLib
{
        class GRAYLIB_LINK cVideoVFW
        {
 
        public:
                static const FOURCC k_FormNull = MAKEFOURCC('D', 'I', 'B', ' ');
                static HRESULT GRAYCALL GetHResultFrom(LRESULT lRes);
 
                UNITTEST_FRIEND(cVideoVFW);
        };
 
        class GRAYLIB_LINK cVideoVFWComp : public IVideoCompress, public cVideoVFW
        {
        public:
 
                class cParams
                {
 
                public:
                        cFourCC m_fccHandler;   
                        LONG m_lKeyRate;                
                        LONG m_lDataRate;               
                        AV_QUALITY_t m_nQuality;                
 
                public:
                        cParams(FOURCC fccHandler = cVideoVFW::k_FormNull, LONG lKeyRate = 1, LONG lDataRate = 300, AV_QUALITY_t nQuality = k_AV_QUALITY_DEF) noexcept
                                : m_fccHandler(fccHandler)
                                , m_lKeyRate(lKeyRate)
                                , m_lDataRate(lDataRate)
                                , m_nQuality(nQuality)
                        {
                        }
 
                        bool isCodecNull() const noexcept
                        {
                                return(m_fccHandler == cVideoVFW::k_FormNull);
                        }
                        bool isValidFormat() const noexcept
                        {
                                return true;
                        }
 
                        bool SetCodecParams(FOURCC fccHandler = k_FormNull, LONG lKeyRate = 1, LONG lDataRate = 300, AV_QUALITY_t nQuality = k_AV_QUALITY_DEF) noexcept
                        {
                                // Params for video codec.
                                m_fccHandler = fccHandler;
                                m_lKeyRate = lKeyRate;
                                m_lDataRate = lDataRate;
                                m_nQuality = nQuality;  // ICQUALITY_DEFAULT
                                return true;
                        }
 
                        // serializers
                        StrLen_t GetCodecStr(char* pszValue, StrLen_t iSizeMax) const;
                        bool put_CodecStr(const char* pszValue);
                };
 
        private:
                COMPVARS m_v;                           
                cSurfaceBitmapInfo m_biIn;      
                bool m_bCompStart;                      
 
        public:
                cVideoVFWComp();
                cVideoVFWComp(const cParams& params);
                cVideoVFWComp(const cVideoVFWComp& copythis);
                virtual ~cVideoVFWComp();
 
                bool isCodecAlloc() const noexcept
                {
                        return(m_v.cbSize != 0);
                }
                bool isCodecNull() const noexcept
                {
                        return(m_v.fccHandler == k_FormNull);
                }
                bool isCodecOpen() const
                {
                        if (isCodecNull())
                                return true;
                        return m_v.hic != HANDLE_NULL;
                }
                bool isCompStarted() const
                {
                        if (!m_bCompStart)
                                return false;
                        ASSERT(isCodecOpen());
                        ASSERT(m_v.lpbiOut != nullptr);
                        return true;
                }
 
                void DestroyCodec();
 
                HRESULT OpenCodec(WORD wMode = ICMODE_FASTCOMPRESS);
                void CloseCodec();
                HRESULT ResetCodec();
 
                bool GetCodecInfo(ICINFO& icInfo) const;
                HRESULT GetCompFormat(const tagBITMAPINFO* lpbiIn, tagBITMAPINFO* lpbiOut = nullptr) const;
                bool GetCodecParams(cParams& params) const;
                bool SetCodecParams(const cParams& params);
 
                bool CompSupportsConfigureDlg() const;
                HRESULT CompConfigureDlg(HWND hWndApp);
                bool CompChooseDlg(HWND hWndApp, const char* lpszTitle);
 
#ifdef _DEBUG
                void DumpSettings();
#endif
 
                // 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;
                virtual void CompEnd();
                virtual AV_QUALITY_t get_CompQuality() const
                {
                        return (AV_QUALITY_t)m_v.lQ;
                }
        };
 
        class GRAYLIB_LINK cVideoVFWDecomp : public IVideoDecompress, public cVideoVFW
        {
        private:
                cHandlePtr<HIC> m_hic;
                ICDECOMPRESS m_Decomp;
        public:
                cVideoVFWDecomp() noexcept
                        : m_hic(HANDLE_NULL)
                {
                }
                virtual ~cVideoVFWDecomp()
                {
                }
                virtual HRESULT DecompStart(const cSurfaceBitmapInfo* pbiInp, cSurfaceInfo* pFrameInfo) override
                {
                        UNREFERENCED_PARAMETER(pbiInp);
                        UNREFERENCED_PARAMETER(pFrameInfo);
                        return E_NOTIMPL;
                }
                virtual HRESULT DecompFrame(const void* pCompData, size_t nSizeComp, cSurfaceBase& frame) override
                {
                        UNREFERENCED_PARAMETER(pCompData);
                        UNREFERENCED_PARAMETER(nSizeComp);
                        UNREFERENCED_REFERENCE(frame);
                        return E_NOTIMPL;
                }
        };
} 
#endif
#endif