cFourCC.h

Go to the documentation of this file.

//
//
#ifndef _INC_cFourCC_H
#define _INC_cFourCC_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/StrArg.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cTypes.h"
 
#ifdef _WIN32
typedef DWORD FOURCC;   
#else
typedef UINT32 FOURCC;  
#endif
 
#ifndef MAKEFOURCC      // code from _WIN32 mmsystem.h
// Keep string order as a 32 bit int. Use DWORD Same as MMSYSTEM mmioFOURCC()
#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
        ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
        ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cFourCC);
 
        enum FOURCC_TYPE
        {
                FOURCC_0 = 0,   
 
#ifndef FOURCC_RIFF // from mmsystem.h
                FOURCC_RIFF = MAKEFOURCC('R','I','F','F'),
                FOURCC_LIST = MAKEFOURCC('L','I','S','T'),
#endif
                FOURCC_FORM = MAKEFOURCC('F', 'O', 'R', 'M'),   
 
                FOURCC_WAVE = MAKEFOURCC('W', 'A', 'V', 'E'), 
                FOURCC_fmt = MAKEFOURCC('f', 'm', 't', ' '), 
                FOURCC_fact = MAKEFOURCC('f', 'a', 'c', 't'), 
                FOURCC_data = MAKEFOURCC('d', 'a', 't', 'a'), 
 
                FOURCC_INFO = MAKEFOURCC('I', 'N', 'F', 'O'), 
                FOURCC_odsp = MAKEFOURCC('o', 'd', 's', 'p'), 
 
                FOURCC_PROP = MAKEFOURCC('P', 'R', 'O', 'P'), 
                FOURCC_MDPR = MAKEFOURCC('M', 'D', 'P', 'R'), 
                FOURCC_CONT = MAKEFOURCC('C', 'O', 'N', 'T'), 
                FOURCC_DISP = MAKEFOURCC('D', 'I', 'S', 'P'), 
                FOURCC_TEXT = MAKEFOURCC('T', 'E', 'X', 'T'), 
 
                FOURCC_IART = MAKEFOURCC('I', 'A', 'R', 'T'), 
                FOURCC_ICMT = MAKEFOURCC('I', 'C', 'M', 'T'), 
                FOURCC_ICOP = MAKEFOURCC('I', 'C', 'O', 'P'), //
                FOURCC_ICRD = MAKEFOURCC('I', 'C', 'R', 'D'), 
                FOURCC_IENG = MAKEFOURCC('I', 'E', 'N', 'G'), //
                FOURCC_INAM = MAKEFOURCC('I', 'N', 'A', 'M'), //
                FOURCC_ISBJ = MAKEFOURCC('I', 'S', 'B', 'J'), 
                FOURCC_ISFT = MAKEFOURCC('I', 'S', 'F', 'T'), //
                FOURCC_DATE = MAKEFOURCC('D', 'A', 'T', 'E'), //
                FOURCC_MARC = MAKEFOURCC('M', 'A', 'R', 'C'), // ??
 
                FOURCC_UART = MAKEFOURCC('U', 'A', 'R', 'T'), 
                FOURCC_UCMT = MAKEFOURCC('U', 'C', 'M', 'T'), //
                FOURCC_UCOP = MAKEFOURCC('U', 'C', 'O', 'P'), //
                FOURCC_UNAM = MAKEFOURCC('U', 'N', 'A', 'M'), //
                FOURCC_USBJ = MAKEFOURCC('U', 'S', 'B', 'J'), //
 
                FOURCC_JUNK = MAKEFOURCC('J', 'U', 'N', 'K'),   
 
                FOURCC_AVI = MAKEFOURCC('A', 'V', 'I', ' '),    
                FOURCC_idx1 = MAKEFOURCC('i', 'd', 'x', '1'),   
                FOURCC_movi = MAKEFOURCC('m', 'o', 'v', 'i'),   
 
                FOURCC_hdrl = MAKEFOURCC('h', 'd', 'r', 'l'),   
                FOURCC_avih = MAKEFOURCC('a', 'v', 'i', 'h'),   
                FOURCC_strl = MAKEFOURCC('s', 't', 'r', 'l'),   
                FOURCC_strh = MAKEFOURCC('s', 't', 'r', 'h'),   
                FOURCC_strf = MAKEFOURCC('s', 't', 'r', 'f'),   
                FOURCC_strd = MAKEFOURCC('s', 't', 'r', 'd'),   
                FOURCC_strn = MAKEFOURCC('s', 't', 'r', 'n'),   
                FOURCC_rec = MAKEFOURCC('r', 'e', 'c', ' '),    
        };
 
#pragma pack(push,1)
 
        class CATTR_PACKED GRAYLIB_LINK cFourCC
        {
 
        public:
                cUnion32 m_u;   
 
        public:
                cFourCC() noexcept
                {
                        m_u.u_dw = FOURCC_0;
                }
                cFourCC(FOURCC dwVal) noexcept
                {
                        m_u.u_dw = dwVal;
                }
                cFourCC(BYTE ch0, BYTE ch1, BYTE ch2, BYTE ch3) noexcept
                {
                        SetChars(ch0, ch1, ch2, ch3);
                }
                cFourCC(const char* s)
                {
                        SetChars(s[0], s[1], s[2], s[3]);
                }
 
                static bool GRAYCALL IsValidChar(wchar_t ch);
 
                bool isValid() const noexcept
                {
                        return m_u.u_dw != FOURCC_0;
                }
                FOURCC get_FOURCC() const noexcept
                {
                        return m_u.u_dw;
                }
                operator FOURCC() const noexcept
                {
                        return m_u.u_dw;
                }
                bool isListType() const noexcept
                {
                        switch (m_u.u_dw)
                        {
                        case FOURCC_RIFF:
                        case FOURCC_LIST:
                                return true;
                        case FOURCC_FORM:       // For AIFF
                                return true;
                        }
                        return false;
                }
 
                void SetChars(BYTE ch0, BYTE ch1, BYTE ch2, BYTE ch3) noexcept
                {
                        m_u.u_c[0] = ch0; m_u.u_c[1] = ch1; m_u.u_c[2] = ch2; m_u.u_c[3] = ch3;
                }
                void SetChar(int i, BYTE ch) 
                {
                        m_u.u_c[i] = ch;
                }
                StrLen_t GetStrA(char* pszOut, StrLen_t iSizeMax = 5) const;
                const char* get_StrA() const;
 
                UNITTEST2_PREDEF(cFourCC);
        };
 
#pragma pack(pop)
};
 
#endif