开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
qtatoms.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：48k
源码类别：

Symbian

开发平台：

C/C++

qtatoms.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _QTATOMS_H_
  37. #define _QTATOMS_H_
  39. /****************************************************************************
  40.  *  Defines
  41.  */
  42. #ifdef QTCONFIG_SPEED_OVER_SIZE
  43. #define QTATOMS_INLINE inline
  44. #else // QTCONFIG_SPEED_OVER_SIZE
  45. #define QTATOMS_INLINE /**/
  46. #endif // QTCONFIG_SPEED_OVER_SIZE
  48. /****************************************************************************
  49.  *  Includes
  50.  */
  51. #include "qtbatom.h"
  52. #include "mempager.h"
  54. #define QT_BAD_SAMPLE_SIZE 0xFFFFFFFF
  56. // /26245-013R6.doc says the unity matrix in the track header is:
  57. // { 0x00010000,0,0,0,0x00010000,0,tx,ty,0x40000000 }, so (tx,ty) is here:
  58. #define TKHD_MATRIX_TX_LOCATION (sizeof(UINT32) * 6)
  59. #define TKHD_MATRIX_TY_LOCATION (sizeof(UINT32) * 7)
  61. #if defined(_SYMBIAN) && !defined(__WINS__)
  62. #  define PACKING __attribute__ ((packed))
  63. #else
  64. #  define PACKING
  65. #endif
  66. /****************************************************************************
  67.  *  Atom Type definitions
  68.  */
  69. typedef enum
  70. {
  71.     QT_HXROOT = 0,     // RN data type
  72.     QT_mdat = QT_ENCODE_TYPE('m', 'd', 'a', 't'),
  73.     QT_moov = QT_ENCODE_TYPE('m', 'o', 'o', 'v'),
  74.     QT_mvhd = QT_ENCODE_TYPE('m', 'v', 'h', 'd'),
  75.     QT_trak = QT_ENCODE_TYPE('t', 'r', 'a', 'k'),
  76.     QT_tkhd = QT_ENCODE_TYPE('t', 'k', 'h', 'd'),
  77.     QT_mdia = QT_ENCODE_TYPE('m', 'd', 'i', 'a'),
  78.     QT_mdhd = QT_ENCODE_TYPE('m', 'd', 'h', 'd'),
  79.     QT_hdlr = QT_ENCODE_TYPE('h', 'd', 'l', 'r'),
  80.     QT_minf = QT_ENCODE_TYPE('m', 'i', 'n', 'f'),
  81.     QT_vmhd = QT_ENCODE_TYPE('v', 'm', 'h', 'd'),
  82.     QT_dinf = QT_ENCODE_TYPE('d', 'i', 'n', 'f'),
  83.     QT_dref = QT_ENCODE_TYPE('d', 'r', 'e', 'f'),
  84.     QT_stbl = QT_ENCODE_TYPE('s', 't', 'b', 'l'),
  85.     QT_stts = QT_ENCODE_TYPE('s', 't', 't', 's'),
  86.     QT_ctts = QT_ENCODE_TYPE('c', 't', 't', 's'),
  87.     QT_stss = QT_ENCODE_TYPE('s', 't', 's', 's'),
  88.     QT_stsd = QT_ENCODE_TYPE('s', 't', 's', 'd'),
  89.     QT_stsz = QT_ENCODE_TYPE('s', 't', 's', 'z'),
  90.     QT_stsc = QT_ENCODE_TYPE('s', 't', 's', 'c'),
  91.     QT_stco = QT_ENCODE_TYPE('s', 't', 'c', 'o'),
  92.     QT_smhd = QT_ENCODE_TYPE('s', 'm', 'h', 'd'),
  93.     QT_hint = QT_ENCODE_TYPE('h', 'i', 'n', 't'),
  94.     QT_mhlr = QT_ENCODE_TYPE('m', 'h', 'l', 'r'),
  95.     QT_alis = QT_ENCODE_TYPE('a', 'l', 'i', 's'),
  96.     QT_rsrc = QT_ENCODE_TYPE('r', 's', 'r', 'c'),
  97.     QT_name = QT_ENCODE_TYPE('n', 'a', 'm', 'e'),
  98.     QT_hinf = QT_ENCODE_TYPE('h', 'i', 'n', 'f'),
  99.     QT_hnti = QT_ENCODE_TYPE('h', 'n', 't', 'i'),
  100.     QT_sdp  = QT_ENCODE_TYPE('s', 'd', 'p', ' '),
  101.     QT_trpy = QT_ENCODE_TYPE('t', 'r', 'p', 'y'),
  102.     QT_nump = QT_ENCODE_TYPE('n', 'u', 'm', 'p'),
  103.     QT_tpyl = QT_ENCODE_TYPE('t', 'p', 'y', 'l'),
  104.     QT_payt = QT_ENCODE_TYPE('p', 'a', 'y', 't'),
  105.     QT_udta = QT_ENCODE_TYPE('u', 'd', 't', 'a'),
  106.     QT_edts = QT_ENCODE_TYPE('e', 'd', 't', 's'),
  107.     QT_elst = QT_ENCODE_TYPE('e', 'l', 's', 't'),
  108.     QT_tref = QT_ENCODE_TYPE('t', 'r', 'e', 'f'),
  109.     QT_tims = QT_ENCODE_TYPE('t', 'i', 'm', 's'),
  110.     QT_tsro = QT_ENCODE_TYPE('t', 's', 'r', 'o'),
  111.     QT_snro = QT_ENCODE_TYPE('s', 'n', 'r', 'o'),
  112.     QT_rtp  = QT_ENCODE_TYPE('r', 't', 'p', ' '),
  113.     QT_rtpo = QT_ENCODE_TYPE('r', 't', 'p', 'o'),
  114.     QT_iods = QT_ENCODE_TYPE('i', 'o', 'd', 's'),
  115.     QT_vide = QT_ENCODE_TYPE('v', 'i', 'd', 'e'),
  116.     QT_soun = QT_ENCODE_TYPE('s', 'o', 'u', 'n'),
  117.     QT_mp4v = QT_ENCODE_TYPE('m', 'p', '4', 'v'),
  118.     QT_mp4a = QT_ENCODE_TYPE('m', 'p', '4', 'a'),
  119.     QT_ftyp = QT_ENCODE_TYPE('f', 't', 'y', 'p'),
  120.     QT_isom = QT_ENCODE_TYPE('i', 's', 'o', 'm'),
  121.     QT_3gp4 = QT_ENCODE_TYPE('3', 'g', 'p', '4'),
  122.     QT_3gp5 = QT_ENCODE_TYPE('3', 'g', 'p', '5'),
  123.     QT_mp41 = QT_ENCODE_TYPE('m', 'p', '4', '1'),
  124.     QT_mp42 = QT_ENCODE_TYPE('m', 'p', '4', '2'),
  125.     QT_mmp4 = QT_ENCODE_TYPE('m', 'm', 'p', '4'),
  126.     QT_m4a  = QT_ENCODE_TYPE('M', '4', 'A', ' '),
  127.     QT_samr = QT_ENCODE_TYPE('s', 'a', 'm', 'r'),
  128.     QT_s263 = QT_ENCODE_TYPE('s', '2', '6', '3'),
  129.     QT_sawb = QT_ENCODE_TYPE('s', 'a', 'w', 'b')
  130.     // /-->> 3GPP Timed Text box types:
  131.     , QT_text = QT_ENCODE_TYPE('t', 'e', 'x', 't')
  132.     , QT_tx3g = QT_ENCODE_TYPE('t', 'x', '3', 'g')
  133.     , QT_ftab = QT_ENCODE_TYPE('f', 't', 'a', 'b')
  134.     , QT_styl = QT_ENCODE_TYPE('s', 't', 'y', 'l')
  135.     , QT_hlit = QT_ENCODE_TYPE('h', 'l', 'i', 't')
  136.     , QT_hclr = QT_ENCODE_TYPE('h', 'c', 'l', 'r')
  137.     , QT_krok = QT_ENCODE_TYPE('k', 'r', 'o', 'k')
  138.     , QT_href = QT_ENCODE_TYPE('h', 'r', 'e', 'f')
  139.     , QT_tbox = QT_ENCODE_TYPE('t', 'b', 'o', 'x')
  140.     , QT_blnk = QT_ENCODE_TYPE('b', 'l', 'n', 'k')
  141.     // /<<-- end 3GPP Timed Text box types.
  142. } QTKnownAtomType;
  145. /****************************************************************************
  146.  *  Atom factory
  147.  */
  148. extern CQTAtom* CreateQTAtom (QTAtomType AtomType,
  149.  ULONG32 ulOffset,
  150.  ULONG32 ulSize,
  151.  CQTAtom *pParent,
  152.  ULONG32 ulAtomID    = 0,
  153.  UINT16 uChildCount  = 0);
  155. /****************************************************************************
  156.  *  Atom Classes
  157.  */
  158. /****************************************************************************
  159.  *  Root Atom Class - RN Data Type
  160.  */
  161. class CQTRootAtom : public CQTAtom
  162. {
  163. public:
  164.     /*
  165.      * Required Virtual Methods
  166.      */
  167.     virtual BOOL IsLeafType(void)    { return FALSE; }
  168.     virtual QTAtomType GetType(void)     { return QT_HXROOT; }
  169. };
  171. /****************************************************************************
  172.  *  moov Atom Class
  173.  */
  174. class CQT_moov_Atom : public CQTAtom
  175. {
  176. public:
  177.     /*
  178.      * Constructor/Destructor
  179.      */
  180.     CQT_moov_Atom(ULONG32 ulOffset,
  181.   ULONG32 ulSize, 
  182.   CQTAtom *pParent) : CQTAtom(ulOffset,
  183.       ulSize,
  184.       pParent) {;}
  186.     /*
  187.      * Required Virtual Methods
  188.      */
  189.     virtual BOOL IsLeafType(void)    { return FALSE; }
  190.     virtual QTAtomType GetType(void)     { return QT_moov; }
  191. };
  193. /****************************************************************************
  194.  *  mvhd Atom Class
  195.  */
  196. class CQT_mvhd_Atom : public CQTAtom
  197. {
  198. public:
  199.     /*
  200.      * Leaf Data Format
  201.      */
  202.     struct Data
  203.     {
  204. UINT8 pVersion[1]; 
  205. UINT8 pFlags[3];
  206. UINT8 pCreatTime[4]; 
  207. UINT8 pModifTime[4]; 
  208. UINT8 pTimeScale[4];
  209. UINT8 pDuration[4];
  210. UINT8 pPrefRate[4];
  211. UINT8 pPrefVolume[2];
  212. UINT8 pReserved[10];
  213. UINT8 pMatrix[36];
  214. UINT8 pPrevTime[4];
  215. UINT8 pPrevDuration[4];
  216. UINT8 pPosterTime[4];
  217. UINT8 pSelectionTime[4];
  218. UINT8 pSelectionDuration[4];
  219. UINT8 pCurrentTime[4];
  220. UINT8 pNextTrackID[4];
  221.     } PACKING;
  223.     /*
  224.      * Constructor/Destructor
  225.      */
  226.     CQT_mvhd_Atom(ULONG32 ulOffset,
  227.   ULONG32 ulSize, 
  228.   CQTAtom *pParent) : CQTAtom(ulOffset,
  229.       ulSize,
  230.       pParent) {;}
  232.     /*
  233.      * Required Virtual Methods
  234.      */
  235.     virtual BOOL IsLeafType(void)    { return TRUE; }
  236.     virtual QTAtomType GetType(void)     { return QT_mvhd; }
  238.     /*
  239.      * Data Access Methods
  240.      */
  241.     ULONG32 Get_TimeScale(void)
  242.     {
  243. HX_ASSERT(m_pData);
  244. return GetUL32(((Data*) m_pData)->pTimeScale);
  245.     }
  247.     ULONG32 Get_Duration(void)
  248.     {
  249. HX_ASSERT(m_pData);
  250. return GetUL32(((Data*) m_pData)->pDuration);
  251.     }
  252. };
  254. /****************************************************************************
  255.  *  udta Atom Class
  256.  */
  257. #define QT_UDTA_TERMINATOR_LENGTH   4
  259. class CQT_udta_Atom : public CQTAtom
  260. {
  261. public:
  262.     /*
  263.      * Constructor/Destructor
  264.      */
  265.     CQT_udta_Atom(ULONG32 ulOffset,
  266.   ULONG32 ulSize, 
  267.   CQTAtom *pParent) : CQTAtom(ulOffset,
  268.       ulSize,
  269.       pParent) {;}
  271.     /*
  272.      * Required Virtual Methods
  273.      */
  274.     virtual BOOL IsLeafType(void)    { return FALSE; }
  275.     virtual QTAtomType GetType(void)     { return QT_udta; }
  276. };
  278. /****************************************************************************
  279.  *  name Atom Class
  280.  */
  281. class CQT_name_Atom : public CQTAtom
  282. {
  283. public:
  284.     /*
  285.      * Leaf Data Format
  286.      */
  287.     struct Data
  288.     {
  289. UINT8 pName[1];
  290.     } PACKING;
  292.     /*
  293.      * Constructor/Destructor
  294.      */
  295.     CQT_name_Atom(ULONG32 ulOffset,
  296.   ULONG32 ulSize, 
  297.   CQTAtom *pParent) : CQTAtom(ulOffset,
  298.       ulSize,
  299.       pParent) {;}
  301.     /*
  302.      * Required Virtual Methods
  303.      */
  304.     virtual BOOL IsLeafType(void)    { return TRUE; }
  305.     virtual QTAtomType GetType(void)     { return QT_name; }
  306. };
  308. /****************************************************************************
  309.  *  hinf Atom Class
  310.  */
  311. class CQT_hinf_Atom : public CQTAtom
  312. {
  313. public:
  314.     /*
  315.      * Constructor/Destructor
  316.      */
  317.     CQT_hinf_Atom(ULONG32 ulOffset,
  318.   ULONG32 ulSize, 
  319.   CQTAtom *pParent) : CQTAtom(ulOffset,
  320.       ulSize,
  321.       pParent) {;}
  323.     /*
  324.      * Required Virtual Methods
  325.      */
  326.     virtual BOOL IsLeafType(void)    { return FALSE; }
  327.     virtual QTAtomType GetType(void)     { return QT_hinf; }
  328. };
  330. /****************************************************************************
  331.  *  trpy Atom Class
  332.  */
  333. class CQT_trpy_Atom : public CQTAtom
  334. {
  335. public:
  336.     /*
  337.      * Leaf Data Format
  338.      */
  339.     struct Data
  340.     {
  341. UINT8 pBytesToSendHi[4];    // not including Net. headers
  342. UINT8 pBytesToSendLo[4];    // not including Net. headers
  343.     } PACKING;
  345.     /*
  346.      * Constructor/Destructor
  347.      */
  348.     CQT_trpy_Atom(ULONG32 ulOffset,
  349.   ULONG32 ulSize, 
  350.   CQTAtom *pParent) : CQTAtom(ulOffset,
  351.       ulSize,
  352.       pParent) {;}
  354.     /*
  355.      * Required Virtual Methods
  356.      */
  357.     virtual BOOL IsLeafType(void)    { return TRUE; }
  358.     virtual QTAtomType GetType(void)     { return QT_trpy; }
  360.     /*
  361.      * Data Access Methods
  362.      */
  363.     ULONG32 Get_BytesToSend(void)
  364.     {
  365. HX_ASSERT(m_pData);
  366. return GetUL32(((Data*) m_pData)->pBytesToSendLo);
  367.     }
  368. };
  370. /****************************************************************************
  371.  *  nump Atom Class
  372.  */
  373. class CQT_nump_Atom : public CQTAtom
  374. {
  375. public:
  376.     /*
  377.      * Leaf Data Format
  378.      */
  379.     struct Data
  380.     {
  381. UINT8 pPacketsToSendHi[4];
  382. UINT8 pPacketsToSendLo[4];
  383.     } PACKING;
  385.     /*
  386.      * Constructor/Destructor
  387.      */
  388.     CQT_nump_Atom(ULONG32 ulOffset,
  389.   ULONG32 ulSize, 
  390.   CQTAtom *pParent) : CQTAtom(ulOffset,
  391.       ulSize,
  392.       pParent) {;}
  394.     /*
  395.      * Required Virtual Methods
  396.      */
  397.     virtual BOOL IsLeafType(void)    { return TRUE; }
  398.     virtual QTAtomType GetType(void)     { return QT_nump; }
  400.     /*
  401.      * Data Access Methods
  402.      */
  403.     ULONG32 Get_PacketsToSend(void)
  404.     {
  405. HX_ASSERT(m_pData);
  406. return GetUL32(((Data*) m_pData)->pPacketsToSendLo);
  407.     }
  408. };
  410. /****************************************************************************
  411.  *  tpyl Atom Class
  412.  */
  413. class CQT_tpyl_Atom : public CQTAtom
  414. {
  415. public:
  416.     /*
  417.      * Leaf Data Format
  418.      */
  419.     struct Data
  420.     {
  421. UINT8 pBytesToSendHi[4];    // not including RTP or Net. headers
  422. UINT8 pBytesToSendLo[4];    // not including RTP or Net. headers
  423.     } PACKING;
  425.     /*
  426.      * Constructor/Destructor
  427.      */
  428.     CQT_tpyl_Atom(ULONG32 ulOffset,
  429.   ULONG32 ulSize, 
  430.   CQTAtom *pParent) : CQTAtom(ulOffset,
  431.       ulSize,
  432.       pParent) {;}
  434.     /*
  435.      * Required Virtual Methods
  436.      */
  437.     virtual BOOL IsLeafType(void)    { return TRUE; }
  438.     virtual QTAtomType GetType(void)     { return QT_tpyl; }
  440.     /*
  441.      * Data Access Methods
  442.      */
  443.     ULONG32 Get_BytesToSend(void)
  444.     {
  445. HX_ASSERT(m_pData);
  446. return GetUL32(((Data*) m_pData)->pBytesToSendLo);
  447.     }
  448. };
  450. /****************************************************************************
  451.  *  payt Atom Class
  452.  */
  453. class CQT_payt_Atom : public CQTAtom
  454. {
  455. public:
  456.     /*
  457.      * Leaf Data Format
  458.      */
  459.     struct Data
  460.     {
  461. UINT8 pPayloadType[4];    
  462. UINT8 pPayloadString[1];    // Pascal String
  463.     } PACKING;
  465.     /*
  466.      * Constructor/Destructor
  467.      */
  468.     CQT_payt_Atom(ULONG32 ulOffset,
  469.   ULONG32 ulSize, 
  470.   CQTAtom *pParent) : CQTAtom(ulOffset,
  471.       ulSize,
  472.       pParent) {;}
  474.     /*
  475.      * Required Virtual Methods
  476.      */
  477.     virtual BOOL IsLeafType(void)    { return TRUE; }
  478.     virtual QTAtomType GetType(void)     { return QT_payt; }
  480.     /*
  481.      * Data Access Methods
  482.      */
  483.     ULONG32 Get_PayloadType(void)
  484.     {
  485. HX_ASSERT(m_pData);
  486. return GetUL32(((Data*) m_pData)->pPayloadType);
  487.     }
  489.     UINT8* Get_PayloadString(void)
  490.     {
  491. HX_ASSERT(m_pData);
  492. return (((Data*) m_pData)->pPayloadString);
  493.     }
  494. };
  496. /****************************************************************************
  497.  *  hnti Atom Class
  498.  */
  499. class CQT_hnti_Atom : public CQTAtom
  500. {
  501. public:
  502.     /*
  503.      * Constructor/Destructor
  504.      */
  505.     CQT_hnti_Atom(ULONG32 ulOffset,
  506.   ULONG32 ulSize, 
  507.   CQTAtom *pParent) : CQTAtom(ulOffset,
  508.       ulSize,
  509.       pParent) {;}
  511.     /*
  512.      * Required Virtual Methods
  513.      */
  514.     virtual BOOL IsLeafType(void)    { return FALSE; }
  515.     virtual QTAtomType GetType(void)     { return QT_hnti; }
  516. };
  518. /****************************************************************************
  519.  *  sdp Atom Class
  520.  */
  521. class CQT_sdp_Atom : public CQTAtom
  522. {
  523. public:
  524.     /*
  525.      * Leaf Data Format
  526.      */
  527.     struct Data
  528.     {
  529. UINT8 pDesc[1];
  530.     } PACKING;
  532.     /*
  533.      * Constructor/Destructor
  534.      */
  535.     CQT_sdp_Atom(ULONG32 ulOffset,
  536.   ULONG32 ulSize, 
  537.   CQTAtom *pParent) : CQTAtom(ulOffset,
  538.       ulSize,
  539.       pParent) {;}
  541.     /*
  542.      * Required Virtual Methods
  543.      */
  544.     virtual BOOL IsLeafType(void)    { return TRUE; }
  545.     virtual QTAtomType GetType(void)     { return QT_sdp; }
  546. };
  548. /****************************************************************************
  549.  *  rtp Atom Class
  550.  */
  551. class CQT_rtp_Atom : public CQTAtom
  552. {
  553. public:
  554.     /*
  555.      * Leaf Data Format
  556.      */
  557.     struct Data
  558.     {
  559. UINT8 pSubType[4];
  560. UINT8 pData[1];
  561.     } PACKING;
  563.     /*
  564.      * Constructor/Destructor
  565.      */
  566.     CQT_rtp_Atom(ULONG32 ulOffset,
  567.  ULONG32 ulSize, 
  568.  CQTAtom *pParent) : CQTAtom(ulOffset,
  569.      ulSize,
  570.      pParent) {;}
  571.     /*
  572.      * Data Access Methods
  573.      */
  574.     ULONG32 Get_SubType(void)
  575.     {
  576. HX_ASSERT(m_pData);
  577. return GetUL32(((Data*) m_pData)->pSubType);
  578.     }
  580.     UINT8* Get_Data(void)
  581.     {
  582. HX_ASSERT(m_pData);
  583. return ((Data*) m_pData)->pData;
  584.     }
  586.     /*
  587.      * Required Virtual Methods
  588.      */
  589.     virtual BOOL IsLeafType(void)    { return TRUE; }
  590.     virtual QTAtomType GetType(void)     { return QT_rtp; }
  591. };
  593. /****************************************************************************
  594.  *  trak Atom Class
  595.  */
  596. class CQT_trak_Atom : public CQTAtom
  597. {
  598. public:
  599.     /*
  600.      * Constructor/Destructor
  601.      */
  602.     CQT_trak_Atom(ULONG32 ulOffset,
  603.   ULONG32 ulSize, 
  604.   CQTAtom *pParent) : CQTAtom(ulOffset,
  605.       ulSize,
  606.       pParent) {;}
  608.     /*
  609.      * Required Virtual Methods
  610.      */
  611.     virtual BOOL IsLeafType(void)    { return FALSE; }
  612.     virtual QTAtomType GetType(void)     { return QT_trak; }
  613. };
  615. /****************************************************************************
  616.  *  tkhd Atom Class
  617.  */
  618. class CQT_tkhd_Atom : public CQTAtom
  619. {
  620. public:
  621.     /*
  622.      * Leaf Data Format
  623.      */
  624.     struct Data
  625.     {
  626. UINT8 pVersion[1]; 
  627. UINT8 pFlags[3];
  628. UINT8 pCreatTime[4]; 
  629. UINT8 pModifTime[4]; 
  630. UINT8 pTrackID[4];
  631. UINT8 pReserved1[4];
  632. UINT8 pDuration[4];
  633. UINT8 pReserved2[8];
  634. UINT8 pLayer[2];
  635. UINT8 pAltGroup[2];
  636. UINT8 pVolume[2];
  637. UINT8 pReserved3[2];
  638. UINT8 Matrix[36];
  639. UINT8 pTrackWidth[4];
  640. UINT8 pTrackHeight[4];
  641.     } PACKING;
  643.     /*
  644.      * Constructor/Destructor
  645.      */
  646.     CQT_tkhd_Atom(ULONG32 ulOffset,
  647.   ULONG32 ulSize, 
  648.   CQTAtom *pParent) : CQTAtom(ulOffset,
  649.       ulSize,
  650.       pParent) {;}
  652.     /*
  653.      * Required Virtual Methods
  654.      */
  655.     virtual BOOL IsLeafType(void)    { return TRUE; }
  656.     virtual QTAtomType GetType(void)     { return QT_tkhd; }
  658.     /*
  659.      * Data Access Methods
  660.      */
  661.     ULONG32 Get_TrackID(void)
  662.     {
  663. HX_ASSERT(m_pData);
  664. return GetUL32(((Data*) m_pData)->pTrackID);
  665.     }
  667.     ULONG32 Get_Duration(void)
  668.     {
  669. HX_ASSERT(m_pData);
  670. return GetUL32(((Data*) m_pData)->pDuration);
  671.     }
  673.     double Get_TrackWidth(void)
  674.     {
  675. HX_ASSERT(m_pData);
  676. return GetFixed32(((Data*) m_pData)->pTrackWidth);
  677.     }
  679.     double Get_TrackHeight(void)
  680.     {
  681. HX_ASSERT(m_pData);
  682. return GetFixed32(((Data*) m_pData)->pTrackHeight);
  683.     }
  685.     double Get_TrackMatrixTx(void)
  686.     {
  687. HX_ASSERT(m_pData);
  688. return GetFixed32((UINT8*)(((Data*) m_pData)->Matrix) +
  689. TKHD_MATRIX_TX_LOCATION);
  690.     }
  692.     double Get_TrackMatrixTy(void)
  693.     {
  694. HX_ASSERT(m_pData);
  695. return GetFixed32((UINT8*)(((Data*) m_pData)->Matrix) +
  696. TKHD_MATRIX_TY_LOCATION);
  697.     }
  698. };
  700. /****************************************************************************
  701.  *  mdia Atom Class
  702.  */
  703. class CQT_mdia_Atom : public CQTAtom
  704. {
  705. public:
  706.     /*
  707.      * Constructor/Destructor
  708.      */
  709.     CQT_mdia_Atom(ULONG32 ulOffset,
  710.   ULONG32 ulSize, 
  711.   CQTAtom *pParent) : CQTAtom(ulOffset,
  712.       ulSize,
  713.       pParent) {;}
  715.     /*
  716.      * Required Virtual Methods
  717.      */
  718.     virtual BOOL IsLeafType(void)    { return FALSE; }
  719.     virtual QTAtomType GetType(void)     { return QT_mdia; }
  720. };
  722. /****************************************************************************
  723.  *  mdhd Atom Class
  724.  */
  725. class CQT_mdhd_Atom : public CQTAtom
  726. {
  727. public:
  728.     /*
  729.      * Leaf Data Format
  730.      */
  731.     struct Data
  732.     {
  733. UINT8 pVersion[1]; 
  734. UINT8 pFlags[3];
  735. UINT8 pCreatTime[4]; 
  736. UINT8 pModifTime[4]; 
  737. UINT8 pTimeScale[4];
  738. UINT8 pDuration[4];
  739. UINT8 pLangCode[2];
  740. UINT8 pQuality[2];
  741.     } PACKING;
  743.     /*
  744.      * Constructor/Destructor
  745.      */
  746.     CQT_mdhd_Atom(ULONG32 ulOffset,
  747.   ULONG32 ulSize, 
  748.   CQTAtom *pParent) : CQTAtom(ulOffset,
  749.       ulSize,
  750.       pParent) {;}
  752.     /*
  753.      * Required Virtual Methods
  754.      */
  755.     virtual BOOL IsLeafType(void)    { return TRUE; }
  756.     virtual QTAtomType GetType(void)     { return QT_mdhd; }
  758.     /*
  759.      * Data Access Methods
  760.      */
  761.     ULONG32 Get_TimeScale(void)
  762.     {
  763. HX_ASSERT(m_pData);
  764. return GetUL32(((Data*) m_pData)->pTimeScale);
  765.     }
  766. };
  768. /****************************************************************************
  769.  *  hdlr Atom Class
  770.  */
  771. class CQT_hdlr_Atom : public CQTAtom
  772. {
  773. public:
  774.     /*
  775.      * Leaf Data Format
  776.      */
  777.     struct Data
  778.     {
  779. UINT8 pVersion[1]; 
  780. UINT8 pFlags[3];
  781. UINT8 pCompType[4]; 
  782. UINT8 pCompSubtype[4]; 
  783. UINT8 pCompManufacturer[4];
  784. UINT8 pCompFlags[4];
  785. UINT8 pCompFlagsMask[4];
  786. UINT8 pName[1];     // Pascal String
  787.     } PACKING;
  789.     /*
  790.      * Constructor/Destructor
  791.      */
  792.     CQT_hdlr_Atom(ULONG32 ulOffset,
  793.   ULONG32 ulSize, 
  794.   CQTAtom *pParent) : CQTAtom(ulOffset,
  795.       ulSize,
  796.       pParent) {;}
  798.     /*
  799.      * Required Virtual Methods
  800.      */
  801.     virtual BOOL IsLeafType(void)    { return TRUE; }
  802.     virtual QTAtomType GetType(void)     { return QT_hdlr; }
  804.     /*
  805.      * Data Access Methods
  806.      */
  807.     ULONG32 Get_CompType(void)
  808.     {
  809. HX_ASSERT(m_pData);
  810. return GetUL32(((Data*) m_pData)->pCompType);
  811.     }
  813.     ULONG32 Get_CompSubtype(void)
  814.     {
  815. HX_ASSERT(m_pData);
  816. return GetUL32(((Data*) m_pData)->pCompSubtype);
  817.     }
  818. };
  820. /****************************************************************************
  821.  *  minf Atom Class
  822.  */
  823. class CQT_minf_Atom : public CQTAtom
  824. {
  825. public:
  826.     /*
  827.      * Constructor/Destructor
  828.      */
  829.     CQT_minf_Atom(ULONG32 ulOffset,
  830.   ULONG32 ulSize, 
  831.   CQTAtom *pParent) : CQTAtom(ulOffset,
  832.       ulSize,
  833.       pParent) {;}
  835.     /*
  836.      * Required Virtual Methods
  837.      */
  838.     virtual BOOL IsLeafType(void)    { return FALSE; }
  839.     virtual QTAtomType GetType(void)     { return QT_minf; }
  841. };
  843. /****************************************************************************
  844.  *  dinf Atom Class
  845.  */
  846. class CQT_dinf_Atom : public CQTAtom
  847. {
  848. public:
  849.     /*
  850.      * Constructor/Destructor
  851.      */
  852.     CQT_dinf_Atom(ULONG32 ulOffset,
  853.   ULONG32 ulSize, 
  854.   CQTAtom *pParent) : CQTAtom(ulOffset,
  855.       ulSize,
  856.       pParent) {;}
  858.     /*
  859.      * Required Virtual Methods
  860.      */
  861.     virtual BOOL IsLeafType(void)    { return FALSE; }
  862.     virtual QTAtomType GetType(void)     { return QT_dinf; }
  863. };
  865. /****************************************************************************
  866.  *  dref Atom Class
  867.  */
  868. #define QT_SELFREF_FLAG 0x00000001
  869. #define QT_ALIS_END     -1 /* Last Marker */
  870. #define QT_ALIS_ABSPATH     2 /* Absolute path name marker */
  871. #define QT_ALIS_MAXCOUNT    10 /* Maximum number of Markers */
  873. class CQT_dref_Atom : public CQTAtom
  874. {
  875. public:
  876.     /*
  877.      * Leaf Data Format
  878.      */
  879.     struct ItemEntry
  880.     {
  881. UINT8 pType[2];   // type of information
  882. UINT8 pSize[2];   // size of variable data
  883. UINT8 pData[1];   // actual data
  884.     } varInfo;
  885.     
  886.     struct DataRef
  887.     {
  888. UINT8 pReserved1[130];
  889. UINT8 pNLvlFrom[2]; // # of levels from fromFile/toFile until
  890. UINT8 pNLvlTo[2]; // a common ancestor directory is found
  891. UINT8 pReserved2[16];
  892. UINT8 pArray[1]; // variable length info
  893.     } PACKING;
  895.     struct ArrayEntry
  896.     {
  897. UINT8 pSize[4];
  898. UINT8 pType[4];
  899. UINT8 pVersion[1];
  900. UINT8 pFlags[3];
  901. UINT8 pDataRef[1];
  902.     } PACKING;
  904.     struct Data
  905.     {
  906. UINT8 pVersion[1]; 
  907. UINT8 pFlags[3]; 
  908. UINT8 pNumEntries[4]; 
  909. UINT8 pArray[1];
  910.     } PACKING;
  912.     /*
  913.      * Constructor/Destructor
  914.      */
  915.     CQT_dref_Atom(ULONG32 ulOffset,
  916.   ULONG32 ulSize, 
  917.   CQTAtom *pParent) : CQTAtom(ulOffset,
  918.       ulSize,
  919.       pParent) {;}
  921.     /*
  922.      * Required Virtual Methods
  923.      */
  924.     virtual BOOL IsLeafType(void)    { return TRUE; }
  925.     virtual QTAtomType GetType(void)     { return QT_dref; }
  927.     /*
  928.      * Data Access Methods
  929.      */
  930.     ULONG32 Get_NumEntries(void)
  931.     {
  932. HX_ASSERT(m_pData);
  933. return GetUL32(((Data*) m_pData)->pNumEntries);
  934.     }
  936.     CQT_dref_Atom::ArrayEntry* GetRefEntry(ULONG32 ulArrayIdx)
  937.     {
  938. HX_ASSERT(m_pData);
  939. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  940. return (ArrayEntry*) FindArrayEntry(((Data*) m_pData)->pArray,
  941.     ulArrayIdx);
  942.     }
  944.     ULONG32 Get_RefType(ULONG32 ulArrayIdx)
  945.     {
  946. HX_ASSERT(m_pData);
  947. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  948. return GetUL32(((ArrayEntry*) FindArrayEntry(
  949. ((Data*) m_pData)->pArray,
  950. ulArrayIdx))->pType);
  951.     }
  953.     ULONG32 Get_RefFlags(ULONG32 ulArrayIdx)
  954.     {
  955. HX_ASSERT(m_pData);
  956. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  957. return GetFlags(((ArrayEntry*) FindArrayEntry(
  958. ((Data*) m_pData)->pArray,
  959. ulArrayIdx))->pFlags);
  960.     }
  962.     ULONG32 Get_RefType(CQT_dref_Atom::ArrayEntry* pRefEntry)
  963.     {
  964. HX_ASSERT(pRefEntry);
  965. return GetUL32(pRefEntry->pType);
  966.     }
  968.     ULONG32 Get_RefFlags(CQT_dref_Atom::ArrayEntry* pRefEntry)
  969.     {
  970. HX_ASSERT(pRefEntry);
  971. return GetFlags(pRefEntry->pFlags);
  972.     }
  974.     CQT_dref_Atom::DataRef* Get_RefData
  975.     (
  976. CQT_dref_Atom::ArrayEntry* pRefEntry
  977.     )
  978.     {
  979. HX_ASSERT(pRefEntry);
  980. return (CQT_dref_Atom::DataRef*) pRefEntry->pDataRef;
  981.     }
  983.     ULONG32 Get_RefDataLen(CQT_dref_Atom::ArrayEntry* pRefEntry)
  984.     {
  985. HX_ASSERT(pRefEntry);
  986. return (GetUL32(pRefEntry->pSize) - sizeof(ArrayEntry) + 1);
  987.     }
  988. };
  990. /****************************************************************************
  991.  *  stbl Atom Class
  992.  */
  993. class CQT_stbl_Atom : public CQTAtom
  994. {
  995. public:
  996.     /*
  997.      * Constructor/Destructor
  998.      */
  999.     CQT_stbl_Atom(ULONG32 ulOffset,
  1000.   ULONG32 ulSize, 
  1001.   CQTAtom *pParent) : CQTAtom(ulOffset,
  1002.       ulSize,
  1003.       pParent) {;}
  1005.     /*
  1006.      * Required Virtual Methods
  1007.      */
  1008.     virtual BOOL IsLeafType(void)    { return FALSE; }
  1009.     virtual QTAtomType GetType(void)     { return QT_stbl; }
  1010. };
  1012. /****************************************************************************
  1013.  *  stsd Atom Class
  1014.  */
  1015. class CQT_stsd_Atom : public CQTAtom
  1016. {
  1017. public:
  1018.     /*
  1019.      * Leaf Data Format
  1020.      */
  1021.     struct TaggedEntry
  1022.     {
  1023. UINT8 pSize[4];
  1024. UINT8 pTag[4];
  1025. UINT8 pData[1];
  1026.     } PACKING;
  1028.     class ArrayEntry
  1029.     {
  1030.     public:
  1031. UINT8 pSize[4];
  1032. UINT8 pDataFormat[4];
  1033. UINT8 pReserved[6];
  1034. UINT8 pDataRefIdx[2];
  1035.     } PACKING;
  1037.     class HintArrayEntry : public ArrayEntry
  1038.     {
  1039.     public:
  1040. UINT8 pHintTrakVersion[2];
  1041. UINT8 pLastCompHintTrakVersion[2];
  1042. UINT8 pMaxPacketSize[4];
  1043. UINT8 pTaggedArray[1];
  1044.     } PACKING;
  1046.     class AudioArrayEntry : public ArrayEntry // just a space holder in MP4
  1047.     {
  1048.     public:
  1049. UINT8 pVersion[2];
  1050. UINT8 pRevLevel[2];
  1051. UINT8 pVendor[4];
  1052. UINT8 pNumChannels[2];
  1053. UINT8 pSampleSize[2];
  1054. UINT8 pCompressionID[2];
  1055. UINT8 pPacketSize[2];
  1056. UINT8 pSampleRate[4];
  1057.     } PACKING;
  1059.     class VideoArrayEntry : public ArrayEntry
  1060.     {
  1061.     public:
  1062. UINT8 pVersion[2];
  1063. UINT8 pRevision[2];
  1064. UINT8 pVendor[4];
  1065. UINT8 pTemporalQuality[4];
  1066. UINT8 pSpatialQuality[4];
  1067. UINT8 pWidth[2];
  1068. UINT8 pHeight[2];
  1069. UINT8 pHRes[4];
  1070. UINT8 pVRes[4];
  1071. UINT8 pDataSize[4];
  1072. UINT8 pFrameCount[2];
  1073. UINT8 pName[32];
  1074. UINT8 pDepth[2];
  1075. UINT8 pClutID[2];
  1076.     } PACKING;
  1078.     class AudioMP4ArrayEntry : public AudioArrayEntry
  1079.     {
  1080.     public:
  1081. UINT8 pSize[4];
  1082. UINT8 pType[4];
  1083. UINT8 pVersion[1];
  1084. UINT8 pFlags[3];
  1085. UINT8 pESDescriptor[1];
  1086.     } PACKING;
  1088.     class VideoMP4ArrayEntry : public VideoArrayEntry
  1089.     {
  1090.     public:
  1091. UINT8 pSize[4];
  1092. UINT8 pType[4];
  1093. UINT8 pVersion[1];
  1094. UINT8 pFlags[3];
  1095. UINT8 pESDescriptor[1];
  1096.     } PACKING;
  1098.     class AudioSAMRArrayEntry : public AudioArrayEntry
  1099.     {
  1100.     public:
  1101. UINT8 pDecoderSpecificInfo[1];
  1102.     } PACKING;
  1104.     class AudioSAWBArrayEntry : public AudioArrayEntry
  1105.     {
  1106.     public:
  1107. UINT8 pDecoderSpecificInfo[1];
  1108.     } PACKING;
  1110.     class VideoS263ArrayEntry : public VideoArrayEntry
  1111.     {
  1112.     public:
  1113. UINT8 pDecoderSpecificInfo[1];
  1114.     } PACKING;
  1116.     ////////////////////////////////
  1117.     // /  3GPP Timed Text structs: 
  1118.     ///
  1119.     class BoxRecord
  1120.     {
  1121.     public:
  1122. INT16 top;
  1123. INT16 left;
  1124. INT16 bottom;
  1125. INT16 right;
  1126.     } PACKING;
  1128.     class StyleRecord
  1129.     {
  1130.     public:
  1131. UINT16 startChar;
  1132. UINT16 endChar;
  1133. UINT16 fontID;
  1134. UINT8  faceStyleFlags;
  1135. UINT8  fontSize;
  1136. UINT8  textColorRGBA[4];
  1137.     } PACKING;
  1139.     class FontRecord
  1140.     {
  1141.     public:
  1142. UINT16 fontID;
  1143. UINT8  fontNameLength;
  1144. UINT8* pFont; // /There are [fontNameLength] bytes in the string;
  1145.     } PACKING;
  1147.     class FontTableBox // / 慺tab