cRIFFFormat.h

Go to the documentation of this file.

//
//
#ifndef _INC_cRIFFFormat_H
#define _INC_cRIFFFormat_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../UID/cFourCC.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cBits.h"
 
namespace GrayLib
{
        typedef UINT32 RIFF_SIZE_t;     
 
        enum RIFFIO_TYPE
        {
                RIFFIO_NULL = 0,
                RIFFIO_CREATERIFF,
                RIFFIO_CREATELIST,
                RIFFIO_CREATECHUNK,
                RIFFIO_FINDRIFF,
                RIFFIO_FINDLIST,        
                RIFFIO_FINDCHUNK,
        };
 
#pragma pack(1)
        class CATTR_PACKED GRAYLIB_LINK cRIFFHead
        {
 
        public:
                FOURCC  m_nTypeChunk;           
                RIFF_SIZE_t     m_nDataSize;    
 
        public:
                cRIFFHead(FOURCC nTypeChunk = FOURCC_0, RIFF_SIZE_t nDataSize = 0)
                        : m_nTypeChunk(nTypeChunk)
                        , m_nDataSize(nDataSize)
                {
                }
                bool isListType() const
                {
                        return(cFourCC(m_nTypeChunk).isListType());
                }
                bool isPadded() const
                {
                        return (m_nDataSize % 2 == 1);
                }
                RIFF_SIZE_t get_RawSize() const
                {
                        RIFF_SIZE_t nSize = m_nDataSize;
                        if (isPadded())
                                nSize++;
                        return nSize + sizeof(m_nTypeChunk) + sizeof(m_nDataSize);
                }
                RIFF_SIZE_t get_DataSize() const
                {
                        return m_nDataSize;
                }
                HRESULT WriteChunk(cStreamOutput* pOut) const;
                HRESULT ReadChunk(cStreamInput& stmIn);
        };
 
        class GRAYLIB_LINK cRIFFHeadList : public cRIFFHead
        {
 
                typedef cRIFFHead SUPER_t;
 
        public:
                FOURCC m_nTypeList;     
 
        public:
                cRIFFHeadList(FOURCC nTypeChunk = FOURCC_0, RIFF_SIZE_t nDataSize = 0, FOURCC nTypeList = FOURCC_0)
                        : cRIFFHead(nTypeChunk, nDataSize)
                        , m_nTypeList(nTypeList)
                {
                }
                RIFF_SIZE_t get_RawSize() const
                {
                        return SUPER_t::get_RawSize() + sizeof(m_nTypeList);
                }
        };
#pragma pack()
 
        class GRAYLIB_LINK cRIFFHeadX : public cRIFFHeadList
        {
 
        public:
                STREAM_POS_t m_nFileOffsetData; 
                RIFFIO_TYPE     m_dwFlags;      
 
        public:
                cRIFFHeadX(FOURCC nTypeChunk = FOURCC_0, RIFF_SIZE_t nDataSize = 0, FOURCC nTypeList = FOURCC_0)
                        : cRIFFHeadList(nTypeChunk, nDataSize, nTypeList)
                        , m_nFileOffsetData(0)
                        , m_dwFlags(RIFFIO_NULL)
                {
                }
 
                HRESULT ReadChunk(cStreamInput& stmIn, BITOP_TYPE nList = BITOP_TOGGLE);
                HRESULT WriteChunk(cStreamOutput* pOut, BITOP_TYPE nList = BITOP_TOGGLE) const;
        };
 
        class GRAYLIB_LINK cRIFFReader
        {
 
        public:
                cStreamInput& m_rInp;   
 
        private:
                HRESULT Descend(cRIFFHeadX* pChunk, const cRIFFHeadX* pInfoRIFF, RIFFIO_TYPE dwFlags);
 
        public:
                cRIFFReader(cStreamInput& s)
                        : m_rInp(s)
                {
                }
 
                HRESULT Ascend(cRIFFHeadX* pChunk);
                HRESULT DescendRIFF(cRIFFHeadX* pChunkList, FOURCC nTypeList);
                HRESULT DescendLIST(cRIFFHeadX* pChunk, const cRIFFHeadX* pChunkList, FOURCC nTypeList);
                HRESULT DescendChunk(cRIFFHeadX* pChunk, const cRIFFHeadX* pChunkList, FOURCC nTypeChunk = FOURCC_0);
        };
 
        class GRAYLIB_LINK cRIFFWriter
        {
 
        public:
                cStreamOutput* m_pOut;  
 
        public:
                cRIFFWriter(cStreamOutput* pOut)
                        : m_pOut(pOut)
                {
                }
 
                HRESULT Ascend(cRIFFHeadX* pChunk);
                HRESULT CreateChunk(cRIFFHeadX* pChunk, RIFFIO_TYPE dwFlags = RIFFIO_NULL);
        };
}
 
#endif