cFLVFile.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFLVFile_H
#define _INC_cFLVFile_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../AV/cAVSink.h"
#include "GrayCore/include/cFilePath.h"
#include "GrayCore/include/cArrayRef.h"
 
namespace GrayLib
{
        class cFLVForm
        {
        public:
                static const BYTE k_INVALID = 0xFF;
        protected:
                BYTE m_bVal;
 
        public:
                cFLVForm() noexcept
                : m_bVal(k_INVALID)
                {
                }
                bool isValid() const noexcept
                {
                        return m_bVal != k_INVALID;
                }
                void put_Byte(BYTE bVal) noexcept
                {
                        m_bVal = bVal;
                }
                BYTE get_Byte() const noexcept
                {
                        return m_bVal;
                }
        };
 
        class cFLVVideo : public cFLVForm
        {
        public:
                enum CODEC_TYPE
                {
                        CODEC_UNCOMPRESSED = 0,
                        CODEC_H263 = 0x02,              
                        CODEC_SCREEN = 0x03,            
                        CODEC_ON2_VP6E = 0x04,          
                        CODEC_ON2_VP6S = 0x05,          
                        CODEC_SCREEN2 = 0x06,           
                        CODEC_H264 = 0x07,              
                        CODEC_MASK = 0x07,
                };
                enum FRAME_TYPE
                {
                        FRAME_0 = 0,
                        FRAME_KEY = 0x10,
                        FRAME_INTER = 0x20,
                        FRAME_DISP_INTER = 0x30,        // NOT USED
                        FRAME_MASK = 0x30,
                };
 
                CODEC_TYPE get_Codec() const
                {
                        return (CODEC_TYPE)(m_bVal & CODEC_MASK);
                }
                void put_Codec(CODEC_TYPE eCodecType)
                {
                        m_bVal &= ~CODEC_MASK;
                        m_bVal |= eCodecType;
                }
                FRAME_TYPE get_FrameType() const
                {
                        return (FRAME_TYPE)(m_bVal & FRAME_MASK);
                }
                void put_FrameType(FRAME_TYPE eFrameType)
                {
                        m_bVal &= ~FRAME_MASK;
                        m_bVal |= eFrameType;
                }
        };
 
        class cFLVAudio : public cFLVForm
        {
        public:
                enum CHAN_TYPE
                {
                        CHAN_STEREO = 0,
                        CHAN_MONO = 1,
                        CHAN_MASK = CHAN_MONO,
                };
                enum SIZE_TYPE
                {
                        SIZE_8 = 0,
                        SIZE_16 = (1 << 1),
                        SIZE_MASK = SIZE_16,
                };
                enum RATE_TYPE
                {
                        RATE_5KHZ = 0,          // signifies 5512Hz or 8000Hz in the case of FORMAT_NELLYMOSER
                        RATE_11KHZ = (1 << 2),  // 11025
                        RATE_22KHZ = (2 << 2),  // 22050
                        RATE_44KHZ = (3 << 2),  // 44100
                        RATE_MASK = (RATE_11KHZ | RATE_22KHZ | RATE_44KHZ)
                };
                enum FORMAT_TYPE
                {
                        FORMAT_UNCOMPRESSED = 0,        // PCM
                        FORMAT_ADPCM = (1 << 4),
                        FORMAT_MP3 = (2 << 4),
                        FORMAT_PCM_LE = (3 << 4),       // Little Endian PCM data.
                        FORMAT_NELLY_16KHZ_MONO = (4 << 4),
                        FORMAT_NELLY_8KHZ_MONO = (5 << 4),      // NELLYMOSER_8KHZ_MONO
                        FORMAT_NELLYMOSER = (6 << 4),   // http://en.wikipedia.org/wiki/Nellymoser_Asao_Codec
                        FORMAT_AAC = (10 << 4), // AAC (HE-AAC/AAC SBR, AAC Main Profile, and AAC-LC) M4A, MP4
                        FORMAT_SPEEX = (11 << 4),
                        FORMAT_MASK = (FORMAT_ADPCM | FORMAT_MP3 | FORMAT_PCM_LE | FORMAT_NELLY_16KHZ_MONO | FORMAT_NELLY_8KHZ_MONO | FORMAT_NELLYMOSER | FORMAT_AAC | FORMAT_SPEEX)
                };
 
                FORMAT_TYPE get_Format() const
                {
                        return (FORMAT_TYPE)(m_bVal & FORMAT_MASK);
                }
                void put_Format(FORMAT_TYPE eFormat)
                {
                        m_bVal &= ~FORMAT_MASK;
                        m_bVal |= eFormat;
                }
                RATE_TYPE get_SamplingRate() const
                {
                        return (RATE_TYPE)(m_bVal & RATE_MASK);
                }
                void put_SamplingRate(RATE_TYPE eSamplingRate)
                {
                        m_bVal &= ~RATE_MASK;
                        m_bVal |= eSamplingRate;
                }
                SIZE_TYPE get_SampleSize() const
                {
                        return (SIZE_TYPE)(m_bVal & SIZE_MASK);
                }
                void put_SampleSize(SIZE_TYPE eSampleSize)
                {
                        m_bVal &= ~SIZE_MASK;
                        m_bVal |= eSampleSize;
                }
                CHAN_TYPE get_Channels() const
                {
                        return (CHAN_TYPE)(m_bVal & CHAN_MASK);
                }
                void put_Channels(CHAN_TYPE eChan)
                {
                        m_bVal &= ~CHAN_MASK;
                        m_bVal |= eChan;
                }
        };
 
        class cFLVTag
        {
        public:
                static const size_t k_SIZE = 11;        
 
                enum TAG_TYPE
                {
                        TAG_UNK = 0,
                        TAG_AUDIO = 0x08,       
                        TAG_VIDEO = 0x09,       
                        TAG_META = 0x12,        
                        TAG_META2 = 0x18,       
                };
 
                TAG_TYPE m_eTagType;    
                size_t m_dataSize;              
                TIMESYSD_t m_timeStamp; 
                UINT32 m_nStreamID;             
 
                // followed by m_dataSize data. first byte of which might be cFLVAudio or cFLVVideo depending on m_eType
                // followed by UI32 tail = ( m_dataSize + k_SIZE )
        public:
                cFLVTag()
                : m_eTagType(TAG_UNK)
                , m_dataSize(0)
                , m_timeStamp(0)
                , m_nStreamID(0)
                {
                }
        };
 
        class GRAYLIB_LINK cFLVFile
        {
 
        public:
                static const BYTE k_VERSION_1 = 1;
 
                enum FLV_FORMFLAG_TYPE
                {
                        FLV_FORMFLAG_VIDEO = 0x1,
                        FLV_FORMFLAG_AUDIO = 0x4,
                };
                enum FLV_META_TYPE
                {
                        FLV_META_Number = 0,    
                        FLV_META_Boolean,               
                        FLV_META_String,                
                        FLV_META_Object,                
                        FLV_META_MovieClip,             
                        FLV_META_Null,                  
                        FLV_META_Undef,                 
                        FLV_META_Ref,                   
                        FLV_META_ECMA,                  
                        FLV_META_END,                   
                        FLV_META_StrictArray,   
                        FLV_META_Date,                  
                        FLV_META_LongString,    
                };
 
                static const char k_bFLV[4];    
                BYTE m_bFormFlags;              
                cFLVVideo m_FormVideo;  
                cFLVAudio m_FormAudio;  
 
        public:
                cFLVFile()
                : m_bFormFlags(0)
                {
                }
 
                bool hasAudio() const
                {
                        return m_bFormFlags & FLV_FORMFLAG_AUDIO;
                }
                bool hasVideo() const
                {
                        return m_bFormFlags & FLV_FORMFLAG_VIDEO;
                }
        };
 
        class GRAYLIB_LINK cFLVFileWriter : public cFLVFile, public cAVSink
        {
        public:
                cStreamOutput* m_pStreamOut;
                float m_fFramesPerSec;          
                TIMESYSD_t m_timeStampA;        
                TIMESYSD_t m_timeStampV;        
        protected:
                HRESULT WriteUI24(UINT32 uVal) const;
                HRESULT WriteUI32(UINT32 uVal) const;
                HRESULT WriteTagHeader(const cFLVTag& tag) const;
                HRESULT WriteHeader() const;
        public:
                cFLVFileWriter(cStreamOutput* pStreamOut);
                virtual ~cFLVFileWriter();
 
                HRESULT OnHeaderVideo(const cSurfaceBitmapInfo* pForm, size_t nSizeForm);
                HRESULT OnHeaderAudio(const cWaveFormatEx* pForm, size_t nSizeForm);
 
                // 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;
 
                UNITTEST_FRIEND(cFLVFileWriter);
        };
 
        class GRAYLIB_LINK cFLVFileReader : public cAVReader, public cFLVFile
        {
 
        public:
                static const BYTE k_FLAG_Header = 0x80; 
                BYTE m_bFormFlagsFound;         
                cArrayRef<cAVFrame> m_FramesQ;
 
        protected:
                HRESULT ReadUI16(WORD& uVal);
                HRESULT ReadUI24(UINT32& uVal);
                HRESULT ReadUI32(UINT32& uVal);
                HRESULT ReadTag(cFLVTag& tag);
                HRESULT ReadMetaString(cString& sVal);
                HRESULT ReadMeta(UINT32 uLenBlockMax, FLV_META_TYPE eTypeEnd, UINT32 uQtyMax);
 
                HRESULT UpdateHeaderAudio(BYTE bFormFlag);
                HRESULT UpdateHeaderVideo(BYTE bFormFlag);
                HRESULT ReadFrame(const cFLVTag& tag);
 
        public:
                cFLVFileReader(cStreamInput& s, cAVSink* pAVSink)
                : cAVReader(s, pAVSink)
                , m_bFormFlagsFound(0)
                {
                }
                virtual ~cFLVFileReader(void)
                {
                }
                virtual HRESULT ReadStream() override;
 
                UNITTEST_FRIEND(cFLVFileReader);
        };
}
#endif