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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
qtatoms.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：48k
源码类别：

Symbian

开发平台：

Visual 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.     QT_alac = QT_ENCODE_TYPE('a', 'l', 'a', 'c')
  131.     // /-->> 3GPP Timed Text box types:
  132.     , QT_text = QT_ENCODE_TYPE('t', 'e', 'x', 't')
  133.     , QT_tx3g = QT_ENCODE_TYPE('t', 'x', '3', 'g')
  134.     , QT_ftab = QT_ENCODE_TYPE('f', 't', 'a', 'b')
  135.     , QT_styl = QT_ENCODE_TYPE('s', 't', 'y', 'l')
  136.     , QT_hlit = QT_ENCODE_TYPE('h', 'l', 'i', 't')
  137.     , QT_hclr = QT_ENCODE_TYPE('h', 'c', 'l', 'r')
  138.     , QT_krok = QT_ENCODE_TYPE('k', 'r', 'o', 'k')
  139.     , QT_href = QT_ENCODE_TYPE('h', 'r', 'e', 'f')
  140.     , QT_tbox = QT_ENCODE_TYPE('t', 'b', 'o', 'x')
  141.     , QT_blnk = QT_ENCODE_TYPE('b', 'l', 'n', 'k')
  142.     // /<<-- end 3GPP Timed Text box types.
  143. } QTKnownAtomType;
  146. /****************************************************************************
  147.  *  Atom factory
  148.  */
  149. extern CQTAtom* CreateQTAtom (QTAtomType AtomType,
  150.  ULONG32 ulOffset,
  151.  ULONG32 ulSize,
  152.  CQTAtom *pParent,
  153.  ULONG32 ulAtomID    = 0,
  154.  UINT16 uChildCount  = 0);
  156. /****************************************************************************
  157.  *  Atom Classes
  158.  */
  159. /****************************************************************************
  160.  *  Root Atom Class - RN Data Type
  161.  */
  162. class CQTRootAtom : public CQTAtom
  163. {
  164. public:
  165.     /*
  166.      * Required Virtual Methods
  167.      */
  168.     virtual BOOL IsLeafType(void)    { return FALSE; }
  169.     virtual QTAtomType GetType(void)     { return QT_HXROOT; }
  170. };
  172. /****************************************************************************
  173.  *  moov Atom Class
  174.  */
  175. class CQT_moov_Atom : public CQTAtom
  176. {
  177. public:
  178.     /*
  179.      * Constructor/Destructor
  180.      */
  181.     CQT_moov_Atom(ULONG32 ulOffset,
  182.   ULONG32 ulSize, 
  183.   CQTAtom *pParent) : CQTAtom(ulOffset,
  184.       ulSize,
  185.       pParent) {;}
  187.     /*
  188.      * Required Virtual Methods
  189.      */
  190.     virtual BOOL IsLeafType(void)    { return FALSE; }
  191.     virtual QTAtomType GetType(void)     { return QT_moov; }
  192. };
  194. /****************************************************************************
  195.  *  mvhd Atom Class
  196.  */
  197. class CQT_mvhd_Atom : public CQTAtom
  198. {
  199. public:
  200.     /*
  201.      * Leaf Data Format
  202.      */
  203.     struct Data
  204.     {
  205. UINT8 pVersion[1]; 
  206. UINT8 pFlags[3];
  207. UINT8 pCreatTime[4]; 
  208. UINT8 pModifTime[4]; 
  209. UINT8 pTimeScale[4];
  210. UINT8 pDuration[4];
  211. UINT8 pPrefRate[4];
  212. UINT8 pPrefVolume[2];
  213. UINT8 pReserved[10];
  214. UINT8 pMatrix[36];
  215. UINT8 pPrevTime[4];
  216. UINT8 pPrevDuration[4];
  217. UINT8 pPosterTime[4];
  218. UINT8 pSelectionTime[4];
  219. UINT8 pSelectionDuration[4];
  220. UINT8 pCurrentTime[4];
  221. UINT8 pNextTrackID[4];
  222.     } PACKING;
  224.     /*
  225.      * Constructor/Destructor
  226.      */
  227.     CQT_mvhd_Atom(ULONG32 ulOffset,
  228.   ULONG32 ulSize, 
  229.   CQTAtom *pParent) : CQTAtom(ulOffset,
  230.       ulSize,
  231.       pParent) {;}
  233.     /*
  234.      * Required Virtual Methods
  235.      */
  236.     virtual BOOL IsLeafType(void)    { return TRUE; }
  237.     virtual QTAtomType GetType(void)     { return QT_mvhd; }
  239.     /*
  240.      * Data Access Methods
  241.      */
  242.     ULONG32 Get_TimeScale(void)
  243.     {
  244. HX_ASSERT(m_pData);
  245. return GetUL32(((Data*) m_pData)->pTimeScale);
  246.     }
  248.     ULONG32 Get_Duration(void)
  249.     {
  250. HX_ASSERT(m_pData);
  251. return GetUL32(((Data*) m_pData)->pDuration);
  252.     }
  253. };
  255. /****************************************************************************
  256.  *  udta Atom Class
  257.  */
  258. #define QT_UDTA_TERMINATOR_LENGTH   4
  260. class CQT_udta_Atom : public CQTAtom
  261. {
  262. public:
  263.     /*
  264.      * Constructor/Destructor
  265.      */
  266.     CQT_udta_Atom(ULONG32 ulOffset,
  267.   ULONG32 ulSize, 
  268.   CQTAtom *pParent) : CQTAtom(ulOffset,
  269.       ulSize,
  270.       pParent) {;}
  272.     /*
  273.      * Required Virtual Methods
  274.      */
  275.     virtual BOOL IsLeafType(void)    { return FALSE; }
  276.     virtual QTAtomType GetType(void)     { return QT_udta; }
  277. };
  279. /****************************************************************************
  280.  *  name Atom Class
  281.  */
  282. class CQT_name_Atom : public CQTAtom
  283. {
  284. public:
  285.     /*
  286.      * Leaf Data Format
  287.      */
  288.     struct Data
  289.     {
  290. UINT8 pName[1];
  291.     } PACKING;
  293.     /*
  294.      * Constructor/Destructor
  295.      */
  296.     CQT_name_Atom(ULONG32 ulOffset,
  297.   ULONG32 ulSize, 
  298.   CQTAtom *pParent) : CQTAtom(ulOffset,
  299.       ulSize,
  300.       pParent) {;}
  302.     /*
  303.      * Required Virtual Methods
  304.      */
  305.     virtual BOOL IsLeafType(void)    { return TRUE; }
  306.     virtual QTAtomType GetType(void)     { return QT_name; }
  307. };
  309. /****************************************************************************
  310.  *  hinf Atom Class
  311.  */
  312. class CQT_hinf_Atom : public CQTAtom
  313. {
  314. public:
  315.     /*
  316.      * Constructor/Destructor
  317.      */
  318.     CQT_hinf_Atom(ULONG32 ulOffset,
  319.   ULONG32 ulSize, 
  320.   CQTAtom *pParent) : CQTAtom(ulOffset,
  321.       ulSize,
  322.       pParent) {;}
  324.     /*
  325.      * Required Virtual Methods
  326.      */
  327.     virtual BOOL IsLeafType(void)    { return FALSE; }
  328.     virtual QTAtomType GetType(void)     { return QT_hinf; }
  329. };
  331. /****************************************************************************
  332.  *  trpy Atom Class
  333.  */
  334. class CQT_trpy_Atom : public CQTAtom
  335. {
  336. public:
  337.     /*
  338.      * Leaf Data Format
  339.      */
  340.     struct Data
  341.     {
  342. UINT8 pBytesToSendHi[4];    // not including Net. headers
  343. UINT8 pBytesToSendLo[4];    // not including Net. headers
  344.     } PACKING;
  346.     /*
  347.      * Constructor/Destructor
  348.      */
  349.     CQT_trpy_Atom(ULONG32 ulOffset,
  350.   ULONG32 ulSize, 
  351.   CQTAtom *pParent) : CQTAtom(ulOffset,
  352.       ulSize,
  353.       pParent) {;}
  355.     /*
  356.      * Required Virtual Methods
  357.      */
  358.     virtual BOOL IsLeafType(void)    { return TRUE; }
  359.     virtual QTAtomType GetType(void)     { return QT_trpy; }
  361.     /*
  362.      * Data Access Methods
  363.      */
  364.     ULONG32 Get_BytesToSend(void)
  365.     {
  366. HX_ASSERT(m_pData);
  367. return GetUL32(((Data*) m_pData)->pBytesToSendLo);
  368.     }
  369. };
  371. /****************************************************************************
  372.  *  nump Atom Class
  373.  */
  374. class CQT_nump_Atom : public CQTAtom
  375. {
  376. public:
  377.     /*
  378.      * Leaf Data Format
  379.      */
  380.     struct Data
  381.     {
  382. UINT8 pPacketsToSendHi[4];
  383. UINT8 pPacketsToSendLo[4];
  384.     } PACKING;
  386.     /*
  387.      * Constructor/Destructor
  388.      */
  389.     CQT_nump_Atom(ULONG32 ulOffset,
  390.   ULONG32 ulSize, 
  391.   CQTAtom *pParent) : CQTAtom(ulOffset,
  392.       ulSize,
  393.       pParent) {;}
  395.     /*
  396.      * Required Virtual Methods
  397.      */
  398.     virtual BOOL IsLeafType(void)    { return TRUE; }
  399.     virtual QTAtomType GetType(void)     { return QT_nump; }
  401.     /*
  402.      * Data Access Methods
  403.      */
  404.     ULONG32 Get_PacketsToSend(void)
  405.     {
  406. HX_ASSERT(m_pData);
  407. return GetUL32(((Data*) m_pData)->pPacketsToSendLo);
  408.     }
  409. };
  411. /****************************************************************************
  412.  *  tpyl Atom Class
  413.  */
  414. class CQT_tpyl_Atom : public CQTAtom
  415. {
  416. public:
  417.     /*
  418.      * Leaf Data Format
  419.      */
  420.     struct Data
  421.     {
  422. UINT8 pBytesToSendHi[4];    // not including RTP or Net. headers
  423. UINT8 pBytesToSendLo[4];    // not including RTP or Net. headers
  424.     } PACKING;
  426.     /*
  427.      * Constructor/Destructor
  428.      */
  429.     CQT_tpyl_Atom(ULONG32 ulOffset,
  430.   ULONG32 ulSize, 
  431.   CQTAtom *pParent) : CQTAtom(ulOffset,
  432.       ulSize,
  433.       pParent) {;}
  435.     /*
  436.      * Required Virtual Methods
  437.      */
  438.     virtual BOOL IsLeafType(void)    { return TRUE; }
  439.     virtual QTAtomType GetType(void)     { return QT_tpyl; }
  441.     /*
  442.      * Data Access Methods
  443.      */
  444.     ULONG32 Get_BytesToSend(void)
  445.     {
  446. HX_ASSERT(m_pData);
  447. return GetUL32(((Data*) m_pData)->pBytesToSendLo);
  448.     }
  449. };
  451. /****************************************************************************
  452.  *  payt Atom Class
  453.  */
  454. class CQT_payt_Atom : public CQTAtom
  455. {
  456. public:
  457.     /*
  458.      * Leaf Data Format
  459.      */
  460.     struct Data
  461.     {
  462. UINT8 pPayloadType[4];    
  463. UINT8 pPayloadString[1];    // Pascal String
  464.     } PACKING;
  466.     /*
  467.      * Constructor/Destructor
  468.      */
  469.     CQT_payt_Atom(ULONG32 ulOffset,
  470.   ULONG32 ulSize, 
  471.   CQTAtom *pParent) : CQTAtom(ulOffset,
  472.       ulSize,
  473.       pParent) {;}
  475.     /*
  476.      * Required Virtual Methods
  477.      */
  478.     virtual BOOL IsLeafType(void)    { return TRUE; }
  479.     virtual QTAtomType GetType(void)     { return QT_payt; }
  481.     /*
  482.      * Data Access Methods
  483.      */
  484.     ULONG32 Get_PayloadType(void)
  485.     {
  486. HX_ASSERT(m_pData);
  487. return GetUL32(((Data*) m_pData)->pPayloadType);
  488.     }
  490.     UINT8* Get_PayloadString(void)
  491.     {
  492. HX_ASSERT(m_pData);
  493. return (((Data*) m_pData)->pPayloadString);
  494.     }
  495. };
  497. /****************************************************************************
  498.  *  hnti Atom Class
  499.  */
  500. class CQT_hnti_Atom : public CQTAtom
  501. {
  502. public:
  503.     /*
  504.      * Constructor/Destructor
  505.      */
  506.     CQT_hnti_Atom(ULONG32 ulOffset,
  507.   ULONG32 ulSize, 
  508.   CQTAtom *pParent) : CQTAtom(ulOffset,
  509.       ulSize,
  510.       pParent) {;}
  512.     /*
  513.      * Required Virtual Methods
  514.      */
  515.     virtual BOOL IsLeafType(void)    { return FALSE; }
  516.     virtual QTAtomType GetType(void)     { return QT_hnti; }
  517. };
  519. /****************************************************************************
  520.  *  sdp Atom Class
  521.  */
  522. class CQT_sdp_Atom : public CQTAtom
  523. {
  524. public:
  525.     /*
  526.      * Leaf Data Format
  527.      */
  528.     struct Data
  529.     {
  530. UINT8 pDesc[1];
  531.     } PACKING;
  533.     /*
  534.      * Constructor/Destructor
  535.      */
  536.     CQT_sdp_Atom(ULONG32 ulOffset,
  537.   ULONG32 ulSize, 
  538.   CQTAtom *pParent) : CQTAtom(ulOffset,
  539.       ulSize,
  540.       pParent) {;}
  542.     /*
  543.      * Required Virtual Methods
  544.      */
  545.     virtual BOOL IsLeafType(void)    { return TRUE; }
  546.     virtual QTAtomType GetType(void)     { return QT_sdp; }
  547. };
  549. /****************************************************************************
  550.  *  rtp Atom Class
  551.  */
  552. class CQT_rtp_Atom : public CQTAtom
  553. {
  554. public:
  555.     /*
  556.      * Leaf Data Format
  557.      */
  558.     struct Data
  559.     {
  560. UINT8 pSubType[4];
  561. UINT8 pData[1];
  562.     } PACKING;
  564.     /*
  565.      * Constructor/Destructor
  566.      */
  567.     CQT_rtp_Atom(ULONG32 ulOffset,
  568.  ULONG32 ulSize, 
  569.  CQTAtom *pParent) : CQTAtom(ulOffset,
  570.      ulSize,
  571.      pParent) {;}
  572.     /*
  573.      * Data Access Methods
  574.      */
  575.     ULONG32 Get_SubType(void)
  576.     {
  577. HX_ASSERT(m_pData);
  578. return GetUL32(((Data*) m_pData)->pSubType);
  579.     }
  581.     UINT8* Get_Data(void)
  582.     {
  583. HX_ASSERT(m_pData);
  584. return ((Data*) m_pData)->pData;
  585.     }
  587.     /*
  588.      * Required Virtual Methods
  589.      */
  590.     virtual BOOL IsLeafType(void)    { return TRUE; }
  591.     virtual QTAtomType GetType(void)     { return QT_rtp; }
  592. };
  594. /****************************************************************************
  595.  *  trak Atom Class
  596.  */
  597. class CQT_trak_Atom : public CQTAtom
  598. {
  599. public:
  600.     /*
  601.      * Constructor/Destructor
  602.      */
  603.     CQT_trak_Atom(ULONG32 ulOffset,
  604.   ULONG32 ulSize, 
  605.   CQTAtom *pParent) : CQTAtom(ulOffset,
  606.       ulSize,
  607.       pParent) {;}
  609.     /*
  610.      * Required Virtual Methods
  611.      */
  612.     virtual BOOL IsLeafType(void)    { return FALSE; }
  613.     virtual QTAtomType GetType(void)     { return QT_trak; }
  614. };
  616. /****************************************************************************
  617.  *  tkhd Atom Class
  618.  */
  619. class CQT_tkhd_Atom : public CQTAtom
  620. {
  621. public:
  622.     /*
  623.      * Leaf Data Format
  624.      */
  625.     struct Data
  626.     {
  627. UINT8 pVersion[1]; 
  628. UINT8 pFlags[3];
  629. UINT8 pCreatTime[4]; 
  630. UINT8 pModifTime[4]; 
  631. UINT8 pTrackID[4];
  632. UINT8 pReserved1[4];
  633. UINT8 pDuration[4];
  634. UINT8 pReserved2[8];
  635. UINT8 pLayer[2];
  636. UINT8 pAltGroup[2];
  637. UINT8 pVolume[2];
  638. UINT8 pReserved3[2];
  639. UINT8 Matrix[36];
  640. UINT8 pTrackWidth[4];
  641. UINT8 pTrackHeight[4];
  642.     } PACKING;
  644.     /*
  645.      * Constructor/Destructor
  646.      */
  647.     CQT_tkhd_Atom(ULONG32 ulOffset,
  648.   ULONG32 ulSize, 
  649.   CQTAtom *pParent) : CQTAtom(ulOffset,
  650.       ulSize,
  651.       pParent) {;}
  653.     /*
  654.      * Required Virtual Methods
  655.      */
  656.     virtual BOOL IsLeafType(void)    { return TRUE; }
  657.     virtual QTAtomType GetType(void)     { return QT_tkhd; }
  659.     /*
  660.      * Data Access Methods
  661.      */
  662.     ULONG32 Get_TrackID(void)
  663.     {
  664. HX_ASSERT(m_pData);
  665. return GetUL32(((Data*) m_pData)->pTrackID);
  666.     }
  668.     ULONG32 Get_Duration(void)
  669.     {
  670. HX_ASSERT(m_pData);
  671. return GetUL32(((Data*) m_pData)->pDuration);
  672.     }
  674.     double Get_TrackWidth(void)
  675.     {
  676. HX_ASSERT(m_pData);
  677. return GetFixed32(((Data*) m_pData)->pTrackWidth);
  678.     }
  680.     double Get_TrackHeight(void)
  681.     {
  682. HX_ASSERT(m_pData);
  683. return GetFixed32(((Data*) m_pData)->pTrackHeight);
  684.     }
  686.     double Get_TrackMatrixTx(void)
  687.     {
  688. HX_ASSERT(m_pData);
  689. return GetFixed32((UINT8*)(((Data*) m_pData)->Matrix) +
  690. TKHD_MATRIX_TX_LOCATION);
  691.     }
  693.     double Get_TrackMatrixTy(void)
  694.     {
  695. HX_ASSERT(m_pData);
  696. return GetFixed32((UINT8*)(((Data*) m_pData)->Matrix) +
  697. TKHD_MATRIX_TY_LOCATION);
  698.     }
  699. };
  701. /****************************************************************************
  702.  *  mdia Atom Class
  703.  */
  704. class CQT_mdia_Atom : public CQTAtom
  705. {
  706. public:
  707.     /*
  708.      * Constructor/Destructor
  709.      */
  710.     CQT_mdia_Atom(ULONG32 ulOffset,
  711.   ULONG32 ulSize, 
  712.   CQTAtom *pParent) : CQTAtom(ulOffset,
  713.       ulSize,
  714.       pParent) {;}
  716.     /*
  717.      * Required Virtual Methods
  718.      */
  719.     virtual BOOL IsLeafType(void)    { return FALSE; }
  720.     virtual QTAtomType GetType(void)     { return QT_mdia; }
  721. };
  723. /****************************************************************************
  724.  *  mdhd Atom Class
  725.  */
  726. class CQT_mdhd_Atom : public CQTAtom
  727. {
  728. public:
  729.     /*
  730.      * Leaf Data Format
  731.      */
  732.     struct Data
  733.     {
  734. UINT8 pVersion[1]; 
  735. UINT8 pFlags[3];
  736. UINT8 pCreatTime[4]; 
  737. UINT8 pModifTime[4]; 
  738. UINT8 pTimeScale[4];
  739. UINT8 pDuration[4];
  740. UINT8 pLangCode[2];
  741. UINT8 pQuality[2];
  742.     } PACKING;
  744.     /*
  745.      * Constructor/Destructor
  746.      */
  747.     CQT_mdhd_Atom(ULONG32 ulOffset,
  748.   ULONG32 ulSize, 
  749.   CQTAtom *pParent) : CQTAtom(ulOffset,
  750.       ulSize,
  751.       pParent) {;}
  753.     /*
  754.      * Required Virtual Methods
  755.      */
  756.     virtual BOOL IsLeafType(void)    { return TRUE; }
  757.     virtual QTAtomType GetType(void)     { return QT_mdhd; }
  759.     /*
  760.      * Data Access Methods
  761.      */
  762.     ULONG32 Get_TimeScale(void)
  763.     {
  764. HX_ASSERT(m_pData);
  765. return GetUL32(((Data*) m_pData)->pTimeScale);
  766.     }
  767. };
  769. /****************************************************************************
  770.  *  hdlr Atom Class
  771.  */
  772. class CQT_hdlr_Atom : public CQTAtom
  773. {
  774. public:
  775.     /*
  776.      * Leaf Data Format
  777.      */
  778.     struct Data
  779.     {
  780. UINT8 pVersion[1]; 
  781. UINT8 pFlags[3];
  782. UINT8 pCompType[4]; 
  783. UINT8 pCompSubtype[4]; 
  784. UINT8 pCompManufacturer[4];
  785. UINT8 pCompFlags[4];
  786. UINT8 pCompFlagsMask[4];
  787. UINT8 pName[1];     // Pascal String
  788.     } PACKING;
  790.     /*
  791.      * Constructor/Destructor
  792.      */
  793.     CQT_hdlr_Atom(ULONG32 ulOffset,
  794.   ULONG32 ulSize, 
  795.   CQTAtom *pParent) : CQTAtom(ulOffset,
  796.       ulSize,
  797.       pParent) {;}
  799.     /*
  800.      * Required Virtual Methods
  801.      */
  802.     virtual BOOL IsLeafType(void)    { return TRUE; }
  803.     virtual QTAtomType GetType(void)     { return QT_hdlr; }
  805.     /*
  806.      * Data Access Methods
  807.      */
  808.     ULONG32 Get_CompType(void)
  809.     {
  810. HX_ASSERT(m_pData);
  811. return GetUL32(((Data*) m_pData)->pCompType);
  812.     }
  814.     ULONG32 Get_CompSubtype(void)
  815.     {
  816. HX_ASSERT(m_pData);
  817. return GetUL32(((Data*) m_pData)->pCompSubtype);
  818.     }
  819. };
  821. /****************************************************************************
  822.  *  minf Atom Class
  823.  */
  824. class CQT_minf_Atom : public CQTAtom
  825. {
  826. public:
  827.     /*
  828.      * Constructor/Destructor
  829.      */
  830.     CQT_minf_Atom(ULONG32 ulOffset,
  831.   ULONG32 ulSize, 
  832.   CQTAtom *pParent) : CQTAtom(ulOffset,
  833.       ulSize,
  834.       pParent) {;}
  836.     /*
  837.      * Required Virtual Methods
  838.      */
  839.     virtual BOOL IsLeafType(void)    { return FALSE; }
  840.     virtual QTAtomType GetType(void)     { return QT_minf; }
  842. };
  844. /****************************************************************************
  845.  *  dinf Atom Class
  846.  */
  847. class CQT_dinf_Atom : public CQTAtom
  848. {
  849. public:
  850.     /*
  851.      * Constructor/Destructor
  852.      */
  853.     CQT_dinf_Atom(ULONG32 ulOffset,
  854.   ULONG32 ulSize, 
  855.   CQTAtom *pParent) : CQTAtom(ulOffset,
  856.       ulSize,
  857.       pParent) {;}
  859.     /*
  860.      * Required Virtual Methods
  861.      */
  862.     virtual BOOL IsLeafType(void)    { return FALSE; }
  863.     virtual QTAtomType GetType(void)     { return QT_dinf; }
  864. };
  866. /****************************************************************************
  867.  *  dref Atom Class
  868.  */
  869. #define QT_SELFREF_FLAG 0x00000001
  870. #define QT_ALIS_END     -1 /* Last Marker */
  871. #define QT_ALIS_ABSPATH     2 /* Absolute path name marker */
  872. #define QT_ALIS_MAXCOUNT    10 /* Maximum number of Markers */
  874. class CQT_dref_Atom : public CQTAtom
  875. {
  876. public:
  877.     /*
  878.      * Leaf Data Format
  879.      */
  880.     struct ItemEntry
  881.     {
  882. UINT8 pType[2];   // type of information
  883. UINT8 pSize[2];   // size of variable data
  884. UINT8 pData[1];   // actual data
  885.     } varInfo;
  886.     
  887.     struct DataRef
  888.     {
  889. UINT8 pReserved1[130];
  890. UINT8 pNLvlFrom[2]; // # of levels from fromFile/toFile until
  891. UINT8 pNLvlTo[2]; // a common ancestor directory is found
  892. UINT8 pReserved2[16];
  893. UINT8 pArray[1]; // variable length info
  894.     } PACKING;
  896.     struct ArrayEntry
  897.     {
  898. UINT8 pSize[4];
  899. UINT8 pType[4];
  900. UINT8 pVersion[1];
  901. UINT8 pFlags[3];
  902. UINT8 pDataRef[1];
  903.     } PACKING;
  905.     struct Data
  906.     {
  907. UINT8 pVersion[1]; 
  908. UINT8 pFlags[3]; 
  909. UINT8 pNumEntries[4]; 
  910. UINT8 pArray[1];
  911.     } PACKING;
  913.     /*
  914.      * Constructor/Destructor
  915.      */
  916.     CQT_dref_Atom(ULONG32 ulOffset,
  917.   ULONG32 ulSize, 
  918.   CQTAtom *pParent) : CQTAtom(ulOffset,
  919.       ulSize,
  920.       pParent) {;}
  922.     /*
  923.      * Required Virtual Methods
  924.      */
  925.     virtual BOOL IsLeafType(void)    { return TRUE; }
  926.     virtual QTAtomType GetType(void)     { return QT_dref; }
  928.     /*
  929.      * Data Access Methods
  930.      */
  931.     ULONG32 Get_NumEntries(void)
  932.     {
  933. HX_ASSERT(m_pData);
  934. return GetUL32(((Data*) m_pData)->pNumEntries);
  935.     }
  937.     CQT_dref_Atom::ArrayEntry* GetRefEntry(ULONG32 ulArrayIdx)
  938.     {
  939. HX_ASSERT(m_pData);
  940. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  941. return (ArrayEntry*) FindArrayEntry(((Data*) m_pData)->pArray,
  942.     ulArrayIdx);
  943.     }
  945.     ULONG32 Get_RefType(ULONG32 ulArrayIdx)
  946.     {
  947. HX_ASSERT(m_pData);
  948. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  949. return GetUL32(((ArrayEntry*) FindArrayEntry(
  950. ((Data*) m_pData)->pArray,
  951. ulArrayIdx))->pType);
  952.     }
  954.     ULONG32 Get_RefFlags(ULONG32 ulArrayIdx)
  955.     {
  956. HX_ASSERT(m_pData);
  957. HX_ASSERT(ulArrayIdx < Get_NumEntries());
  958. return GetFlags(((ArrayEntry*) FindArrayEntry(
  959. ((Data*) m_pData)->pArray,
  960. ulArrayIdx))->pFlags);
  961.     }
  963.     ULONG32 Get_RefType(CQT_dref_Atom::ArrayEntry* pRefEntry)
  964.     {
  965. HX_ASSERT(pRefEntry);
  966. return GetUL32(pRefEntry->pType);
  967.     }
  969.     ULONG32 Get_RefFlags(CQT_dref_Atom::ArrayEntry* pRefEntry)
  970.     {
  971. HX_ASSERT(pRefEntry);
  972. return GetFlags(pRefEntry->pFlags);
  973.     }
  975.     CQT_dref_Atom::DataRef* Get_RefData
  976.     (
  977. CQT_dref_Atom::ArrayEntry* pRefEntry
  978.     )
  979.     {
  980. HX_ASSERT(pRefEntry);
  981. return (CQT_dref_Atom::DataRef*) pRefEntry->pDataRef;
  982.     }
  984.     ULONG32 Get_RefDataLen(CQT_dref_Atom::ArrayEntry* pRefEntry)
  985.     {
  986. HX_ASSERT(pRefEntry);
  987. return (GetUL32(pRefEntry->pSize) - sizeof(ArrayEntry) + 1);
  988.     }
  989. };
  991. /****************************************************************************
  992.  *  stbl Atom Class
  993.  */
  994. class CQT_stbl_Atom : public CQTAtom
  995. {
  996. public:
  997.     /*
  998.      * Constructor/Destructor
  999.      */
  1000.     CQT_stbl_Atom(ULONG32 ulOffset,
  1001.   ULONG32 ulSize, 
  1002.   CQTAtom *pParent) : CQTAtom(ulOffset,
  1003.       ulSize,
  1004.       pParent) {;}
  1006.     /*
  1007.      * Required Virtual Methods
  1008.      */
  1009.     virtual BOOL IsLeafType(void)    { return FALSE; }
  1010.     virtual QTAtomType GetType(void)     { return QT_stbl; }
  1011. };
  1013. /****************************************************************************
  1014.  *  stsd Atom Class
  1015.  */
  1016. class CQT_stsd_Atom : public CQTAtom
  1017. {
  1018. public:
  1019.     /*
  1020.      * Leaf Data Format
  1021.      */
  1022.     struct TaggedEntry
  1023.     {
  1024. UINT8 pSize[4];
  1025. UINT8 pTag[4];
  1026. UINT8 pData[1];
  1027.     } PACKING;
  1029.     class ArrayEntry
  1030.     {
  1031.     public:
  1032. UINT8 pSize[4];
  1033. UINT8 pDataFormat[4];
  1034. UINT8 pReserved[6];
  1035. UINT8 pDataRefIdx[2];
  1036.     } PACKING;
  1038.     class HintArrayEntry : public ArrayEntry
  1039.     {
  1040.     public:
  1041. UINT8 pHintTrakVersion[2];
  1042. UINT8 pLastCompHintTrakVersion[2];
  1043. UINT8 pMaxPacketSize[4];
  1044. UINT8 pTaggedArray[1];
  1045.     } PACKING;
  1047.     class AudioArrayEntry : public ArrayEntry // just a space holder in MP4
  1048.     {
  1049.     public:
  1050. UINT8 pVersion[2];
  1051. UINT8 pRevLevel[2];
  1052. UINT8 pVendor[4];
  1053. UINT8 pNumChannels[2];
  1054. UINT8 pSampleSize[2];
  1055. UINT8 pCompressionID[2];
  1056. UINT8 pPacketSize[2];
  1057. UINT8 pSampleRate[4];
  1058.     } PACKING;
  1060.     class VideoArrayEntry : public ArrayEntry
  1061.     {
  1062.     public:
  1063. UINT8 pVersion[2];
  1064. UINT8 pRevision[2];
  1065. UINT8 pVendor[4];
  1066. UINT8 pTemporalQuality[4];
  1067. UINT8 pSpatialQuality[4];
  1068. UINT8 pWidth[2];
  1069. UINT8 pHeight[2];
  1070. UINT8 pHRes[4];
  1071. UINT8 pVRes[4];
  1072. UINT8 pDataSize[4];
  1073. UINT8 pFrameCount[2];
  1074. UINT8 pName[32];
  1075. UINT8 pDepth[2];
  1076. UINT8 pClutID[2];
  1077.     } PACKING;
  1079.     class AudioMP4ArrayEntry : public AudioArrayEntry
  1080.     {
  1081.     public:
  1082. UINT8 pSize[4];
  1083. UINT8 pType[4];
  1084. UINT8 pVersion[1];
  1085. UINT8 pFlags[3];
  1086. UINT8 pESDescriptor[1];
  1087.     } PACKING;
  1089.     class VideoMP4ArrayEntry : public VideoArrayEntry
  1090.     {
  1091.     public:
  1092. UINT8 pSize[4];
  1093. UINT8 pType[4];
  1094. UINT8 pVersion[1];
  1095. UINT8 pFlags[3];
  1096. UINT8 pESDescriptor[1];
  1097.     } PACKING;
  1099.     class AudioSAMRArrayEntry : public AudioArrayEntry
  1100.     {
  1101.     public:
  1102. UINT8 pDecoderSpecificInfo[1];
  1103.     } PACKING;
  1105.     class AudioSAWBArrayEntry : public AudioArrayEntry
  1106.     {
  1107.     public:
  1108. UINT8 pDecoderSpecificInfo[1];
  1109.     } PACKING;
  1111.     class VideoS263ArrayEntry : public VideoArrayEntry
  1112.     {
  1113.     public:
  1114. UINT8 pDecoderSpecificInfo[1];
  1115.     } PACKING;
  1117.     class AudioALACArrayEntry : public AudioArrayEntry
  1118.     {
  1119.     public:
  1120. UINT8 pDecoderSpecificInfo[1];
  1121.     } PACKING;
  1123.     ////////////////////////////////
  1124.     // /  3GPP Timed Text structs: 
  1125.     ///
  1126.     class BoxRecord
  1127.     {
  1128.     public:
  1129. INT16 top;
  1130. INT16 left;
  1131. INT16 bottom;
  1132. INT16 right;
  1133.     } PACKING;
  1135.     class StyleRecord
  1136.     {
  1137.     public:
  1138. UINT16 startChar;
  1139. UINT16 endChar;
  1140. UINT16 fontID;
  1141. UINT8  faceStyleFlags;
  1142. UINT8  fontSize;
  1143. UINT8  textColorRGBA[4];
  1144.     } PACKING;
  1146.     class FontRecord
  1147.     {
  1148.     public:
  1149. UINT16 fontID;
  1150. UINT8  fontNameLength;
  1151. UINT8* pFont; // /There are [fontNameLength] bytes in the string;
  1152.     } PACKING;
  1154.     class FontTableBox // / 慺tab