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

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 _MDPKT_H_
  36. #define _MDPKT_H_
  37. /****************************************************************************
  38.  *  Includes
  39.  */
  40. #include "hxtypes.h"
  41. #include "hxresult.h"
  42. #include "hxassert.h"
  43. /****************************************************************************
  44.  *  Globals
  45.  */
  46. typedef void (*MPBufferKillerFunc) (void* pBuffer, 
  47.     void* pUserData);
  48. typedef void (*MPSampleDescKillerFunc) (void* pSampleDesc, 
  49. void* pUserData);
  50. enum
  51. {
  52.     MDPCKT_IS_KEYFRAME_FLAG     = 1,
  53.     MDPCKT_FOLLOWS_LOSS_FLAG     = 2,
  54.     MDPCKT_HAS_UKNOWN_TIME_FLAG     = 4,
  55.     MDPCKT_HAS_MARKER_FLAG     = 8,
  56.     MDPCKT_USES_IHXBUFFER_FLAG     = 128
  57. };
  58. /****************************************************************************
  59.  *  CMediaPacket
  60.  */
  61. class CMediaPacket
  62. {
  63. public:
  64.     CMediaPacket(void)
  65. : m_pBuffer(NULL)
  66. , m_pData(NULL)
  67. , m_ulDataSize(0)
  68. , m_ulBufferSize(0)
  69. , m_ulTime(0)
  70. , m_ulFlags(0)
  71. , m_pSampleDesc(NULL)
  72. , m_pUserData(NULL)
  73. , m_fpSampleDescKiller(NULL)
  74. , m_fpBufferKiller(NULL)
  75.     {
  76. ;
  77.     }
  78.  
  79.     CMediaPacket(void* pBuffer,
  80.  UINT8* pData, 
  81.  ULONG32 ulBufferSize,
  82.  ULONG32 ulDataSize,
  83.  ULONG32 ulTime,
  84.  ULONG32 ulFlags,
  85.  void* pSampleDesc)
  86. : m_pBuffer(pBuffer)
  87. , m_pData(pData)
  88. , m_ulBufferSize(ulBufferSize)
  89. , m_ulDataSize(ulDataSize)
  90. , m_ulTime(ulTime)
  91. , m_ulFlags(ulFlags)
  92. , m_pSampleDesc(pSampleDesc)
  93. , m_pUserData(NULL)
  94. , m_fpSampleDescKiller(NULL)
  95. , m_fpBufferKiller(NULL)
  96.     {
  97. if (IsUsingIHXBuffer())
  98. {
  99.     ((IHXBuffer*) pBuffer)->AddRef();
  100. }
  101.     }
  102.     
  103.     CMediaPacket(void* pBuffer,
  104.  ULONG32 ulBufferSize,
  105.  ULONG32 ulFlags = 0)
  106. : m_pBuffer(pBuffer)
  107. , m_pData(0)
  108. , m_ulBufferSize(ulBufferSize)
  109. , m_ulDataSize(0)
  110. , m_ulTime(0)
  111. , m_ulFlags(ulFlags)
  112. , m_pSampleDesc(NULL)
  113. , m_pUserData(NULL)
  114. , m_fpSampleDescKiller(NULL)
  115. , m_fpBufferKiller(NULL)
  116.     {
  117. if (IsUsingIHXBuffer())
  118. {
  119.     ((IHXBuffer*) pBuffer)->AddRef();
  120. }
  121.     }
  122.     ~CMediaPacket()
  123.     {
  124. ;
  125.     }
  126.     
  127.     void Init(UINT8* pData,
  128.       ULONG32 ulDataSize,
  129.       ULONG32 ulTime,
  130.       ULONG32 ulFlags,
  131.       void* pSampleDesc)
  132.     {
  133. m_pData = pData;
  134. m_ulDataSize = ulDataSize;
  135. m_ulTime = ulTime;
  136. if (IsUsingIHXBuffer())
  137. {
  138.     m_ulFlags = ulFlags | MDPCKT_USES_IHXBUFFER_FLAG;
  139. }
  140. else
  141. {
  142.     m_ulFlags = ulFlags;
  143. }
  144. if (m_pSampleDesc && m_fpSampleDescKiller)
  145. {
  146.     (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  147. }
  148. m_pSampleDesc = pSampleDesc;
  149.     }
  150.     void Clear(void)
  151.     {
  152. if (m_pBuffer)
  153. {
  154.     if (IsUsingIHXBuffer())
  155.     {
  156. ((IHXBuffer*) m_pBuffer)->Release();
  157.     }
  158.     else
  159.     {
  160. if (m_fpBufferKiller)
  161. {
  162.     (*m_fpBufferKiller)(m_pBuffer, m_pUserData);
  163. }
  164. else
  165. {
  166.     delete [] ((UINT8*) m_pBuffer);
  167. }
  168.     }
  169.     m_pBuffer = NULL;
  170. }
  171. m_pData = NULL;
  172. if (m_pSampleDesc)
  173. {
  174.     if (m_fpSampleDescKiller)
  175.     {
  176. (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  177.     }
  178.     m_pSampleDesc = NULL;
  179. }
  180.     }
  181.     void SetBuffer(void* pBuffer,
  182.    UINT8* pData, 
  183.    ULONG32 ulBufferSize,
  184.    ULONG32 ulDataSize,
  185.    ULONG32 ulBufferFlag = 0)
  186.     {
  187. if (m_pBuffer)
  188. {
  189.     if (IsUsingIHXBuffer())
  190.     {
  191. ((IHXBuffer*) m_pBuffer)->Release();
  192.     }
  193.     else
  194.     {
  195. if (m_fpBufferKiller)
  196. {
  197.     (*m_fpBufferKiller)(m_pBuffer, m_pUserData);
  198. }
  199. else
  200. {
  201.     delete [] ((UINT8*) m_pBuffer);
  202. }
  203.     }  
  204. }
  205. m_pBuffer = pBuffer;
  206. NoteIHXBuffer(ulBufferFlag == MDPCKT_USES_IHXBUFFER_FLAG);
  207. if (IsUsingIHXBuffer())
  208. {
  209.     ((IHXBuffer*) m_pBuffer)->AddRef();
  210. }
  211. m_pData = pData;
  212. m_ulBufferSize = ulBufferSize;
  213. m_ulDataSize = ulDataSize;
  214.     }
  215.     BOOL IsUsingIHXBuffer(void)
  216.     {
  217. return ((m_ulFlags & MDPCKT_USES_IHXBUFFER_FLAG) != 0);
  218.     }
  219.     void SetSampleDesc(void* pSampleDesc)
  220.     {
  221. if (m_pSampleDesc && m_fpSampleDescKiller)
  222. {
  223.     (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  224. }
  225. m_pSampleDesc = pSampleDesc;
  226.     }
  227.     void SetSampleDescKiller(MPSampleDescKillerFunc fpSampleDescKiller)
  228.     {
  229. m_fpSampleDescKiller = fpSampleDescKiller;
  230.     }
  231.     void SetBufferKiller(MPBufferKillerFunc fpBufferKiller)
  232.     {
  233. m_fpBufferKiller = fpBufferKiller;
  234.     }
  235.     static ULONG32 GetBufferSize(CMediaPacket* pPacket)
  236.     {
  237. return pPacket->m_ulBufferSize;
  238.     }
  239.     static void DeletePacket(CMediaPacket* pPacket)
  240.     {
  241. pPacket->Clear();
  242. delete pPacket;
  243.     }
  244.     
  245.     UCHAR* m_pData;
  246.     ULONG32 m_ulDataSize;  
  247.     ULONG32 m_ulTime;
  248.     ULONG32 m_ulFlags;
  249.     void* m_pSampleDesc;
  250.     void* m_pUserData;
  251. private:
  252.     MPBufferKillerFunc m_fpBufferKiller;
  253.     MPSampleDescKillerFunc m_fpSampleDescKiller;
  254.     void NoteIHXBuffer(BOOL bUsesIHXBuffer)
  255.     {
  256. m_ulFlags = m_ulFlags & (~MDPCKT_USES_IHXBUFFER_FLAG);
  257. m_ulFlags |= (bUsesIHXBuffer ? MDPCKT_USES_IHXBUFFER_FLAG : 0);
  258.     }
  259.     void*   m_pBuffer;
  260.     ULONG32 m_ulBufferSize;
  261. };
  262. #endif // _MDPKT_H_