cAVSink.h

Go to the documentation of this file.

//
 
#ifndef _INC_cAVSink_H
#define _INC_cAVSink_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cRefPtr.h"
 
namespace GrayLib
{
        class cSurfaceBitmapInfo;
        class cWaveFormatEx;
        typedef short AV_QUALITY_t;             
 
        enum AV_STREAM_TYPE
        {
                AV_STREAM_UNK = 0,              
                AV_STREAM_Video,                
                AV_STREAM_Audio,                
                AV_STREAM_Text,                 
                AV_STREAM_Location,             
                AV_STREAM_Meta,                 
                AV_STREAM_QTY,
                AV_STREAM_MASK = 0x0f,
                // Any extra bits are used to id a stream. can be multiple streams of the same type ?
                // AV_STREAM_KEYFRAME = 0x80,   //!< bitmask indicates a frame is a key frame.
        };
        typedef BYTE AV_STREAM_t;       
        typedef BYTE AV_STREAMS_t;      
 
#pragma pack(1)
        class CATTR_PACKED cAVHeader
        {
        public:
                WORD m_wVersion;                                
                float m_fFramesPerSec;                  
                UINT32 m_dwTotalTimeSec;                
        public:
                cAVHeader(float fFramesPerSec = 0.0f, UINT32 dwTotalTimeSec = 0)
                        : m_wVersion(1)
                        , m_fFramesPerSec(fFramesPerSec)
                        , m_dwTotalTimeSec(dwTotalTimeSec)
                {
                }
        };
        class CATTR_PACKED cAVHeaderStream
        {
        public:
                AV_STREAM_t m_bTypeId;                  
                AV_QUALITY_t m_nQuality;                
        public:
                cAVHeaderStream(AV_STREAM_TYPE bTypeId, AV_QUALITY_t nQuality = 10000) noexcept
                        : m_bTypeId((AV_STREAM_t)bTypeId)
                        , m_nQuality(nQuality)
                {
                }
                AV_STREAM_TYPE get_Type() const noexcept
                {
                        return (AV_STREAM_TYPE)(m_bTypeId & AV_STREAM_MASK);
                }
        };
 
        class CATTR_PACKED cAVHeaderFrame
        {
 
        public:
                static const BYTE k_FLAG_KeyFrame = 0x80;       
                AV_STREAM_t m_bTypeId;                          
 
        public:
                cAVHeaderFrame(AV_STREAM_TYPE bTypeId) noexcept
                        : m_bTypeId((AV_STREAM_t)bTypeId)
                {
                        // e.g. ( m_bType & AV_STREAM_MASK ) = AV_STREAM_Audio
                }
                AV_STREAM_TYPE get_Type() const noexcept
                {
                        return (AV_STREAM_TYPE)(m_bTypeId & AV_STREAM_MASK);
                }
                bool isAudio() const noexcept
                {
                        return get_Type() == AV_STREAM_Audio;
                }
                bool isVideo() const noexcept
                {
                        return get_Type() == AV_STREAM_Video;
                }
                bool isKeyFrame() const noexcept
                {
                        return (m_bTypeId & k_FLAG_KeyFrame) ? true : false;
                }
        };
#pragma pack()
 
        class cAVFrame : public cRefBase
        {
        public:
                cAVHeaderFrame m_head;
                cHeapBlock m_data;
        public:
                cAVFrame(const cAVHeaderFrame& head, const cHeapBlock& data)
                        : m_head(head), m_data(data)
                {
                }
        };
 
        //*************************************************************
 
        class GRAYLIB_LINK cAVSink
        {
                // IGNORE_WARN_ABSTRACT(cAVSink);
 
        public:
                virtual ~cAVSink()
                {
                }
 
                virtual HRESULT OnHeaderOpen(const cAVHeader& head)
                {
                        UNREFERENCED_REFERENCE(head);
                        return S_OK;
                }
                virtual HRESULT OnHeaderStream(const cAVHeaderStream& head, const void* pForm, size_t nSizeForm)
                {
                        UNREFERENCED_REFERENCE(head);
                        UNREFERENCED_PARAMETER(pForm);
                        UNREFERENCED_PARAMETER(nSizeForm);
                        return S_OK;
                }
                virtual HRESULT OnHeaderClose()
                {
                        return S_OK;
                }
                virtual HRESULT OnFrame(const cAVHeaderFrame& head, const void* pData, size_t nSizeData)
                {
                        UNREFERENCED_REFERENCE(head);
                        UNREFERENCED_PARAMETER(pData);
                        UNREFERENCED_PARAMETER(nSizeData);
                        return S_OK;
                }
                virtual HRESULT OnClose()
                {
                        return S_OK;
                }
        };
 
        class GRAYLIB_LINK cAVSinkNull : public cAVSink
        {
        };
 
        class GRAYLIB_LINK cAVReader
        {
 
        protected:
                cStreamInput* m_pStreamInput;   
                cAVSink* m_pAVSink;                             
 
        public:
                cAVReader(cStreamInput& stmIn, cAVSink* pSink)
                        : m_pStreamInput(&stmIn)
                        , m_pAVSink(pSink)
                {
                }
                virtual ~cAVReader()
                {
                }
 
                virtual HRESULT ReadStream() = 0;       
        };
 
        //*************************************************************
 
        class GRAYLIB_LINK cAVControl
        {
        public:
                enum CTL_TYPE
                {
                        CTL_UNK = 0,
                        CTL_Source,             
                        CTL_Channel,    
                        CTL_Quality,    
                        CTL_Stop,               
                        CTL_Seek,               
                        CTL_Position,   
                        CTL_Mouse,              
                        CTL_Keys,               
                        CTL_QTY
                };
                virtual ~cAVControl()
                {
                }
                virtual HRESULT OnControl(CTL_TYPE eType, const void* pData = nullptr, size_t nSizeData = 0) = 0;
        };
 
        class GRAYLIB_LINK cAVRateController : public cAVSink
        {
 
        public:
                virtual HRESULT BuildCompFrame(TIMESYS_t tWhenLast, const void*& rpCompRet, size_t& rnSizeRet) = 0;
        };
};
 
#endif