qtbatom.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:8k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #ifndef _QTBATOM_H
  36. #define _QTBATOM_H
  37. /****************************************************************************
  38.  *  Defines
  39.  */
  40. #define QT_HEADER_SIZE     8
  41. #define QT_NEW_HEADER_SIZE  20
  42. #define QT_EXTENDED_SIZE 8
  43. #define QT_NEW_HEADER_GAP   4
  44. #define QT_ENCODE_TYPE(b1, b2, b3, b4) ((b1 << 24) |
  45.  (b2 << 16) |
  46.  (b3 << 8)  |
  47.  b4)
  48. /****************************************************************************
  49.  *  Includes
  50.  */
  51. #include "hxcom.h"
  52. #include "hxtypes.h"
  53. #include "hxslist.h"
  54. #include "ihxpckts.h"
  55. class CMemPager;
  56. /****************************************************************************
  57.  *  Atom Type definition
  58.  */
  59. typedef LONG32 QTAtomType;
  60. /****************************************************************************
  61.  *  Abstract Atom Class
  62.  */
  63. class CQTAtom : public IUnknown
  64. {
  65. public:
  66.     /*
  67.      * IUnknown methods
  68.      */
  69.     STDMETHOD (QueryInterface )     (THIS_ 
  70.     REFIID ID, 
  71.     void** ppInterfaceObj);
  72.     STDMETHOD_(UINT32, AddRef )     (THIS);
  73.     STDMETHOD_(UINT32, Release)     (THIS);
  74.     
  75.     /*
  76.      * Utilities
  77.      */
  78.     static UINT64   GetUL64 (UINT8 *pData)
  79.     {
  80. return (((UINT64) *pData)     << 56) |
  81. (((UINT64) *(pData + 1))    << 48) |
  82. (((UINT64) *(pData + 2))    << 40) |
  83. (((UINT64) *(pData + 3))    << 32) |
  84. (*(pData + 4)     << 24) |
  85. (*(pData + 5)     << 16) |
  86. (*(pData + 6)     << 8 ) |
  87. *(pData + 7);
  88.     }
  89.     static ULONG32  GetUL32 (UINT8 *pData)
  90.     {
  91. return (*pData << 24) |
  92. (*(pData + 1) << 16) |
  93. (*(pData + 2) << 8 ) |
  94. *(pData + 3);
  95.     }
  96.     static LONG32   GetL32 (UINT8 *pData)
  97.     {
  98. return (LONG32) GetUL32(pData);
  99.     }
  100.     static UINT16   GetUI16 (UINT8 *pData)
  101.     {
  102. return (*pData     << 8) |
  103. *(pData + 1);
  104.     }
  105.     static INT16    GetI16 (UINT8 *pData)
  106.     {
  107. return (INT16) GetUI16(pData);
  108.     }
  109.     static double    GetFixed32 (UINT8 *pData)
  110.     {
  111. return ((*pData << 8) |
  112.  *(pData + 1)) +
  113. (((*(pData + 2) << 8) |
  114.   *(pData + 3)) / 65536.0);
  115.     }
  116.     static double    GetFixed16 (UINT8 *pData)
  117.     {
  118. return *pData +
  119. (*(pData + 1) / 256.0);
  120.     }
  121.     static ULONG32  GetFlags (UINT8 *pData)
  122.     {
  123. return (*pData << 16) |
  124. (*(pData + 1) << 8 ) |
  125. *(pData + 2);
  126.     }
  127.     
  128.     /*
  129.      * Main Interface
  130.      */
  131.     virtual BOOL IsLeafType(void) = 0;
  132.     virtual QTAtomType GetType(void) = 0;
  133.     virtual BOOL IsNewQTAtom(void) { return FALSE; }
  134.     virtual BOOL IsPagingAtom(void) { return FALSE; }
  135.     virtual BOOL IsPagingEnabled(void) { return FALSE; }
  136.     virtual void SetMemPager(CMemPager* pMemPager)   { ; }
  137.     virtual BOOL IsFaulted(void) { return FALSE; }
  138.     UINT16  GetPresentChildCount(void)
  139.     {
  140. return m_pChildList ? m_pChildList->GetCount() : 0;
  141.     }
  142.     HX_RESULT AddPresentChild(CQTAtom *pChild);
  143.     CQTAtom* GetPresentChild(UINT16 uChildIndex);
  144.     CQTAtom* FindPresentChild(QTAtomType AtomType);
  145.     CQTAtom* GetParent(void) { return m_pParent; }
  146.     ULONG32 GetOffset(void) { return m_ulOffset; }
  147.     ULONG32 GetSize(void) { return m_ulSize; }
  148.     IHXBuffer* GetBuffer(void) { return m_pBuffer; }
  149.     UINT8* GetData(void) { return m_pData; }
  150.     ULONG32 GetDataSize(void) { return m_pBuffer ? m_pBuffer->GetSize() : 0; }
  151.     void SetOffset(ULONG32 ulOffset) { m_ulOffset = ulOffset; }   
  152.     void SetSize(ULONG32 ulSize) { m_ulSize = ulSize; }
  153.     virtual void SetBuffer(IHXBuffer *pBuffer);
  154.     /*
  155.      * Child Iterator
  156.      */
  157.     class ChildIterator
  158.     {
  159.     public:
  160. friend class CQTAtom;
  161. ChildIterator(void)
  162.     : m_NextChildPos(NULL)
  163.     , m_pChildList(NULL)
  164.     , m_pChild(NULL) {;}
  165. ChildIterator& operator ++(void)
  166. {
  167.     HX_ASSERT(m_NextChildPos);
  168.     m_pChild = (CQTAtom*) m_pChildList->GetNext(m_NextChildPos);
  169.     return *this;
  170. }
  171. CQTAtom* operator *(void) { return m_pChild; }
  172.     private:
  173. ChildIterator(CHXSimpleList* pSimpleList, LISTPOSITION ChildPos)
  174.     : m_pChildList(pSimpleList)
  175.     , m_NextChildPos(ChildPos)
  176. {
  177.     m_pChild = (CQTAtom*) m_pChildList->GetNext(m_NextChildPos);
  178. }
  179. CHXSimpleList *m_pChildList;
  180. LISTPOSITION m_NextChildPos;
  181. CQTAtom* m_pChild;
  182.     };
  183.     ChildIterator BeginChildren(void)
  184.     {
  185. HX_ASSERT(m_pChildList);
  186. HX_ASSERT(m_pChildList->GetHeadPosition());
  187. return ChildIterator(m_pChildList, m_pChildList->GetHeadPosition());
  188.     }
  189. protected:
  190.     UINT8* FindArrayEntry(UINT8* pStartEntry, ULONG32 ulArrayIdx)
  191.     {
  192. while (ulArrayIdx != 0)
  193. {
  194.     HX_ASSERT(((ULONG32) (pStartEntry - m_pData))
  195.       < m_pBuffer->GetSize());
  196.     pStartEntry += GetUL32(pStartEntry);
  197.     ulArrayIdx--;
  198. }
  199. return pStartEntry;
  200.     }
  201.     CQTAtom(void);
  202.     CQTAtom(ULONG32 ulOffset,
  203.     ULONG32 ulSize, 
  204.     CQTAtom *pParent);
  205.     virtual ~CQTAtom();
  206.     CQTAtom*     m_pParent;
  207.     CHXSimpleList*  m_pChildList;
  208.     ULONG32     m_ulOffset;
  209.     ULONG32     m_ulSize;
  210.     IHXBuffer*     m_pBuffer;
  211.     UINT8*     m_pData;
  212. private:
  213.     LONG32     m_lRefCount;
  214. };
  215. /****************************************************************************
  216.  *  Abstract Atom Class for new QT Atoms
  217.  */
  218. class CQTNewAtom : public CQTAtom
  219. {
  220. public:
  221.     virtual BOOL IsLeafType(void)    { return (m_uChildCount == 0); }
  222.     virtual QTAtomType GetType(void) = 0;
  223.     virtual BOOL IsNewQTAtom(void)   { return TRUE; }
  224.     UINT16  GetChildCount(void) { return m_uChildCount; }
  225. protected:
  226.     CQTNewAtom( ULONG32 ulOffset,
  227. ULONG32 ulSize, 
  228. CQTAtom *pParent, 
  229. ULONG32 AtomID, 
  230. UINT16 uChildCount)
  231. : CQTAtom(ulOffset, ulSize, pParent)
  232. , m_AtomID(AtomID)
  233. , m_uChildCount(uChildCount) {;}
  234.     ULONG32 m_AtomID;
  235.     UINT16  m_uChildCount;
  236. };
  237. class CQTPagingAtom : public CQTAtom
  238. {
  239. public:
  240.     virtual BOOL IsLeafType(void) = 0;
  241.     virtual QTAtomType GetType(void) = 0;
  242.     virtual BOOL IsPagingAtom(void) { return TRUE; }
  243.     virtual BOOL IsPagingEnabled(void) { return m_pMemPager ? TRUE : FALSE; }
  244.     virtual void SetMemPager(CMemPager* pMemPager);
  245.     virtual BOOL IsFaulted(void);
  246.     virtual void SetBuffer(IHXBuffer *pBuffer);
  247.     HX_RESULT GetLastStatus(void)   { return m_lastStatus; }
  248. protected:
  249.     CQTPagingAtom(ULONG32 ulOffset,
  250.   ULONG32 ulSize, 
  251.   CQTAtom *pParent)
  252.   : CQTAtom(ulOffset, ulSize, pParent)
  253.   , m_pMemPager(NULL)
  254.   , m_lastStatus(HXR_OK) {;}
  255.     virtual ~CQTPagingAtom();
  256.     CMemPager* m_pMemPager;
  257.     HX_RESULT m_lastStatus;
  258. };
  259. #endif  // QTBATOM_H