mdpkt.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:7k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: mdpkt.h,v 1.1.1.1.46.1 2004/07/09 01:55:29 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #ifndef _MDPKT_H_
  50. #define _MDPKT_H_
  51. /****************************************************************************
  52.  *  Includes
  53.  */
  54. #include "hxtypes.h"
  55. #include "hxresult.h"
  56. #include "hxassert.h"
  57. /****************************************************************************
  58.  *  Globals
  59.  */
  60. typedef void (*MPBufferKillerFunc) (void* pBuffer, 
  61.     void* pUserData);
  62. typedef void (*MPSampleDescKillerFunc) (void* pSampleDesc, 
  63. void* pUserData);
  64. enum
  65. {
  66.     MDPCKT_IS_KEYFRAME_FLAG     = 1,
  67.     MDPCKT_FOLLOWS_LOSS_FLAG     = 2,
  68.     MDPCKT_HAS_UKNOWN_TIME_FLAG     = 4,
  69.     MDPCKT_HAS_MARKER_FLAG     = 8,
  70.     MDPCKT_USES_IHXBUFFER_FLAG     = 128
  71. };
  72. /****************************************************************************
  73.  *  CMediaPacket
  74.  */
  75. class CMediaPacket
  76. {
  77. public:
  78.     CMediaPacket(void)
  79. : m_pBuffer(NULL)
  80. , m_pData(NULL)
  81. , m_ulDataSize(0)
  82. , m_ulBufferSize(0)
  83. , m_ulTime(0)
  84. , m_ulFlags(0)
  85. , m_pSampleDesc(NULL)
  86. , m_pUserData(NULL)
  87. , m_fpSampleDescKiller(NULL)
  88. , m_fpBufferKiller(NULL)
  89.     {
  90. ;
  91.     }
  92.  
  93.     CMediaPacket(void* pBuffer,
  94.  UINT8* pData, 
  95.  ULONG32 ulBufferSize,
  96.  ULONG32 ulDataSize,
  97.  ULONG32 ulTime,
  98.  ULONG32 ulFlags,
  99.  void* pSampleDesc)
  100. : m_pBuffer(pBuffer)
  101. , m_pData(pData)
  102. , m_ulBufferSize(ulBufferSize)
  103. , m_ulDataSize(ulDataSize)
  104. , m_ulTime(ulTime)
  105. , m_ulFlags(ulFlags)
  106. , m_pSampleDesc(pSampleDesc)
  107. , m_pUserData(NULL)
  108. , m_fpSampleDescKiller(NULL)
  109. , m_fpBufferKiller(NULL)
  110.     {
  111. if (IsUsingIHXBuffer())
  112. {
  113.     ((IHXBuffer*) pBuffer)->AddRef();
  114. }
  115.     }
  116.     
  117.     CMediaPacket(void* pBuffer,
  118.  ULONG32 ulBufferSize,
  119.  ULONG32 ulFlags = 0)
  120. : m_pBuffer(pBuffer)
  121. , m_pData(0)
  122. , m_ulBufferSize(ulBufferSize)
  123. , m_ulDataSize(0)
  124. , m_ulTime(0)
  125. , m_ulFlags(ulFlags)
  126. , m_pSampleDesc(NULL)
  127. , m_pUserData(NULL)
  128. , m_fpSampleDescKiller(NULL)
  129. , m_fpBufferKiller(NULL)
  130.     {
  131. if (IsUsingIHXBuffer())
  132. {
  133.     ((IHXBuffer*) pBuffer)->AddRef();
  134. }
  135.     }
  136.     ~CMediaPacket()
  137.     {
  138. ;
  139.     }
  140.     
  141.     void Init(UINT8* pData,
  142.       ULONG32 ulDataSize,
  143.       ULONG32 ulTime,
  144.       ULONG32 ulFlags,
  145.       void* pSampleDesc)
  146.     {
  147. m_pData = pData;
  148. m_ulDataSize = ulDataSize;
  149. m_ulTime = ulTime;
  150. if (IsUsingIHXBuffer())
  151. {
  152.     m_ulFlags = ulFlags | MDPCKT_USES_IHXBUFFER_FLAG;
  153. }
  154. else
  155. {
  156.     m_ulFlags = ulFlags;
  157. }
  158. if (m_pSampleDesc && m_fpSampleDescKiller)
  159. {
  160.     (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  161. }
  162. m_pSampleDesc = pSampleDesc;
  163.     }
  164.     void Clear(void)
  165.     {
  166. if (m_pBuffer)
  167. {
  168.     if (IsUsingIHXBuffer())
  169.     {
  170. ((IHXBuffer*) m_pBuffer)->Release();
  171.     }
  172.     else
  173.     {
  174. if (m_fpBufferKiller)
  175. {
  176.     (*m_fpBufferKiller)(m_pBuffer, m_pUserData);
  177. }
  178. else
  179. {
  180.     delete [] ((UINT8*) m_pBuffer);
  181. }
  182.     }
  183.     m_pBuffer = NULL;
  184. }
  185. m_pData = NULL;
  186. if (m_pSampleDesc)
  187. {
  188.     if (m_fpSampleDescKiller)
  189.     {
  190. (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  191.     }
  192.     m_pSampleDesc = NULL;
  193. }
  194.     }
  195.     void SetBuffer(void* pBuffer,
  196.    UINT8* pData, 
  197.    ULONG32 ulBufferSize,
  198.    ULONG32 ulDataSize,
  199.    ULONG32 ulBufferFlag = 0)
  200.     {
  201. if (m_pBuffer)
  202. {
  203.     if (IsUsingIHXBuffer())
  204.     {
  205. ((IHXBuffer*) m_pBuffer)->Release();
  206.     }
  207.     else
  208.     {
  209. if (m_fpBufferKiller)
  210. {
  211.     (*m_fpBufferKiller)(m_pBuffer, m_pUserData);
  212. }
  213. else
  214. {
  215.     delete [] ((UINT8*) m_pBuffer);
  216. }
  217.     }  
  218. }
  219. m_pBuffer = pBuffer;
  220. NoteIHXBuffer(ulBufferFlag == MDPCKT_USES_IHXBUFFER_FLAG);
  221. if (IsUsingIHXBuffer())
  222. {
  223.     ((IHXBuffer*) m_pBuffer)->AddRef();
  224. }
  225. m_pData = pData;
  226. m_ulBufferSize = ulBufferSize;
  227. m_ulDataSize = ulDataSize;
  228.     }
  229.     BOOL IsUsingIHXBuffer(void)
  230.     {
  231. return ((m_ulFlags & MDPCKT_USES_IHXBUFFER_FLAG) != 0);
  232.     }
  233.     void SetSampleDesc(void* pSampleDesc)
  234.     {
  235. if (m_pSampleDesc && m_fpSampleDescKiller)
  236. {
  237.     (*m_fpSampleDescKiller)(m_pSampleDesc, m_pUserData);
  238. }
  239. m_pSampleDesc = pSampleDesc;
  240.     }
  241.     void SetSampleDescKiller(MPSampleDescKillerFunc fpSampleDescKiller)
  242.     {
  243. m_fpSampleDescKiller = fpSampleDescKiller;
  244.     }
  245.     void SetBufferKiller(MPBufferKillerFunc fpBufferKiller)
  246.     {
  247. m_fpBufferKiller = fpBufferKiller;
  248.     }
  249.     static ULONG32 GetBufferSize(CMediaPacket* pPacket)
  250.     {
  251. return pPacket->m_ulBufferSize;
  252.     }
  253.     static void DeletePacket(CMediaPacket* pPacket)
  254.     {
  255. pPacket->Clear();
  256. delete pPacket;
  257.     }
  258.     
  259.     UCHAR* m_pData;
  260.     ULONG32 m_ulDataSize;  
  261.     ULONG32 m_ulTime;
  262.     ULONG32 m_ulFlags;
  263.     void* m_pSampleDesc;
  264.     void* m_pUserData;
  265. private:
  266.     MPBufferKillerFunc m_fpBufferKiller;
  267.     MPSampleDescKillerFunc m_fpSampleDescKiller;
  268.     void NoteIHXBuffer(BOOL bUsesIHXBuffer)
  269.     {
  270. m_ulFlags = m_ulFlags & (~MDPCKT_USES_IHXBUFFER_FLAG);
  271. m_ulFlags |= (bUsesIHXBuffer ? MDPCKT_USES_IHXBUFFER_FLAG : 0);
  272.     }
  273.     void*   m_pBuffer;
  274.     ULONG32 m_ulBufferSize;
  275. };
  276. #endif // _MDPKT_H_