cAVStream.h

Go to the documentation of this file.

//
//
#ifndef _INC_cAVStream_H
#define _INC_cAVStream_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cAVSink.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cQueue.h"
 
namespace GrayLib
{
        enum CAVPkt_TYPE
        {
                CAVPkt_Undefined = 0,
 
                // Outgoing messages.
                CAVPkt_Open,                            
                CAVPkt_Close,                           
 
                CAVPkt_HeaderOpen,                      
                CAVPkt_HeaderStream,            
                CAVPkt_HeaderClose,                     
 
                CAVPkt_Frame,                           
                CAVPkt_Error,                           
                CAVPkt_QTY
        };
 
        typedef BYTE CAVPkt_t;  
 
#pragma pack(1)
        class CATTR_PACKED cAVStreamPacket
        {
        public:
                BYTE m_eType;           
                UINT32 m_nLength;       
        public:
                cAVStreamPacket(BYTE eType = CAVPkt_Undefined, size_t nLength = 0) noexcept
                : m_eType(eType)
                , m_nLength((UINT32)nLength)
                {
                }
                bool isValidPacket() const noexcept
                {
                        if (m_eType == 0 || m_eType >= 32)      // CAVPkt_TYPE or CTL_TYPE
                                return false;
                        if (m_nLength > cHeap::k_ALLOC_MAX)
                                return false;
                        return true;
                }
        };
#pragma pack()
 
        class GRAYLIB_LINK cAVStreamOut : public cAVSink
        {
 
        protected:
                cStreamOutput* m_pOut;  
        public:
                cAVStreamOut(cStreamOutput* pOut) noexcept
                : m_pOut(pOut)
                {
                }
                virtual ~cAVStreamOut()
                {
                }
                void put_StreamOutput(cStreamOutput* pOut)
                {
                        m_pOut = pOut;
                }
 
                // cAVSink
                virtual HRESULT OnHeaderOpen(const cAVHeader& head) override;
                virtual HRESULT OnHeaderStream(const cAVHeaderStream& head, const void* pForm, size_t nSizeForm) override;
                virtual HRESULT OnHeaderClose() override;
 
                virtual HRESULT OnFrame(const cAVHeaderFrame& head, const void* pData, size_t nSizeData) override;
                virtual HRESULT OnClose() override;
 
                HRESULT WritePacket(CAVPkt_TYPE eState, const void* pHead = nullptr, size_t nSizeHead = 0, const void* pData = nullptr, size_t nSizeData = 0);
        };
 
        class GRAYLIB_LINK cAVStreamInp : public cAVReader
        {
                typedef cStreamOutput SUPER_t;
 
        private:
                size_t m_nReadSize;
                cAVStreamPacket m_Packet;
                cHeapBlock m_data;      
 
        protected:
                virtual HRESULT ProcessPacket(CAVPkt_TYPE eState, const void* pData, size_t nSizeData);
        public:
                cAVStreamInp(cStreamInput& stmIn, cAVSink* pSink);
                virtual ~cAVStreamInp();
 
                HRESULT ProcessStreamPacket();
                virtual HRESULT ReadStream() override;
        };
 
        //*************************************************************
 
        class GRAYLIB_LINK cAVControlOut : public cAVControl
        {
 
        protected:
                cStreamOutput* m_pOut;  
        public:
                cAVControlOut(cStreamOutput* pOut) noexcept
                : m_pOut(pOut)
                {
                }
                virtual ~cAVControlOut()
                {
                }
                void put_StreamOutput(cStreamOutput* pOut)
                {
                        m_pOut = pOut;
                }
 
                // cAVControl
                virtual HRESULT OnControl(CTL_TYPE eType, const void* pData = nullptr, size_t nSizeData = 0);
        };
 
        class GRAYLIB_LINK cAVControlInp : public cStreamOutput
        {
                typedef cStreamOutput SUPER_t;
        protected:
                cAVControl* m_pAVControl;       
        public:
                cAVControlInp(cAVControl* pControl)
                : m_pAVControl(pControl)
                {
                }
                virtual ~cAVControlInp()
                {
                }
                virtual HRESULT WriteX(const void* pData, size_t nDataSize);
        };
};
 
#endif