cRIFF.h

Go to the documentation of this file.

//
//
#ifndef _INC_cRIFF_H
#define _INC_cRIFF_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cRIFFFormat.h"
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/cArraySortRef.h"
#include "GrayCore/include/cArrayRef.h"
#include "GrayCore/include/FileName.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cRIFFBlock : public cRefBase, public cRIFFHead
        {
 
        protected:
                virtual HRESULT ReadStreamBody(cStreamInput& strIn) = 0;
                virtual HRESULT WriteStreamBody(cStreamOutput* pFile) const = 0;
 
        public:
                cRIFFBlock(FOURCC nTypeChunk, RIFF_SIZE_t nSize)
                : cRIFFHead(nTypeChunk, nSize)
                {
                }
                virtual ~cRIFFBlock()
                {
                }
 
                virtual bool isListType() const = 0;
 
                static HRESULT GRAYCALL ReadStreamUnk(cStreamInput& strIn, cRefPtr<cRIFFBlock>* ppRet);
                HRESULT WriteStream(cStreamOutput* pFile) const;
        };
        typedef cRefPtr<cRIFFBlock> cRIFFBasePtr;
 
        class GRAYLIB_LINK cRIFFChunk : public cRIFFBlock
        {
 
        public:
                cHeapBlock m_Data;      
 
        protected:
                virtual HRESULT ReadStreamBody(cStreamInput& strIn);
                virtual HRESULT WriteStreamBody(cStreamOutput* pFile) const;
 
        public:
                cRIFFChunk(FOURCC nTypeChunk, RIFF_SIZE_t nDataSize)
                : cRIFFBlock(nTypeChunk, nDataSize)
                {
                }
                virtual ~cRIFFChunk()
                {
                }
 
                virtual bool isListType() const
                {
                        return false;
                }
                void* get_Data() const
                {
                        // If this is loaded.
                        return m_Data.get_Data();
                }
        };
 
        class GRAYLIB_LINK cRIFFList : public cRIFFBlock
        {
 
        public:
                cFourCC m_nTypeList;            
                cArrayRef<cRIFFBlock> m_aList;  
 
        protected:
                virtual HRESULT ReadStreamBody(cStreamInput& strIn);
                virtual HRESULT WriteStreamBody(cStreamOutput* pFile) const;
 
        public:
                cRIFFList(FOURCC nTypeList, FOURCC nTypeChunk, RIFF_SIZE_t nDataSize)
                : cRIFFBlock(nTypeChunk, nDataSize)
                , m_nTypeList(nTypeList)
                {
                }
                virtual ~cRIFFList()
                {
                }
 
                virtual bool isListType() const
                {
                        return true;
                }
                cRIFFChunk* EnumChunk(int i) const
                {
                        if (!m_aList.IsValidIndex(i))
                                return nullptr;
                        return SMARTS_CAST(cRIFFChunk,m_aList[i]);
                }
                cRIFFChunk* FindChunkId(FOURCC nTypeChunk) const
                {
                        for (int i = 0; i < m_aList.GetSize(); i++)
                        {
                                cRIFFBlock* pChunk = m_aList[i];
                                if (pChunk->m_nTypeChunk == nTypeChunk)
                                        return static_cast<cRIFFChunk*>(pChunk);
                        }
                        return nullptr;
                }
        };
 
        class GRAYLIB_LINK cRIFF
        {
 
        public:
                cRefPtr<cRIFFList> m_pRIFF;     
 
        public:
                cRIFF()
                {
                }
 
                size_t get_Size() const
                {
                        if (m_pRIFF == nullptr)
                                return 0;
                        return m_pRIFF->m_nDataSize;
                }
 
                HRESULT ReadStream(cStreamInput& strIn);
                HRESULT WriteStream(cStreamOutput* pFile) const;
 
                HRESULT LoadFile(const FILECHAR_t* pszFile);
                HRESULT SaveFile(const FILECHAR_t* pszFile) const;
 
                UNITTEST_FRIEND(cRIFF);
        };
};
 
#endif