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

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

Symbian

开发平台：

C/C++

old_hxpckts.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 _HXPCKTS_H_
  37. #define _HXPCKTS_H_
  39. #include "hxmap.h"
  40. #include "ihxpckts.h"
  41. #include "hxbuffer.h" /* For all the places that just include this */
  43. struct HXPacketInfo
  44. {
  45.     UINT8   lost;
  46.     UINT8   ASMFlags;
  47.     UINT16  ASMRuleNumber;
  48.     UINT16  streamNum;
  49.     UINT32  time;
  50. };
  52. /****************************************************************************
  53.  * 
  54.  * Class:
  55.  *
  56.  * CHXPacket
  57.  *
  58.  * Purpose:
  59.  *
  60.  * PN implementation of a basic packet.
  61.  *
  62.  */
  63. class CHXPacket : public IHXRTPPacket
  64. {
  65. protected:
  66.     LONG32 m_lRefCount;
  67.     IHXBuffer* m_pBuffer;
  68.     ULONG32 m_ulTime;
  69.     UINT16 m_uStreamNumber;
  70.     UINT8 m_unASMFlags;
  71.     UINT16 m_unASMRuleNumber;
  72.     BOOL m_bIsLost;
  73.     
  74.     ~CHXPacket()
  75.     {
  76. if (m_pBuffer)
  77. {
  78.     m_pBuffer->Release();
  79. }
  80.     };
  81.     
  82.     inline HX_RESULT _Get(
  83.                    IHXBuffer* &pBuffer, 
  84.    ULONG32 &ulTime,
  85.    UINT16 &uStreamNumber,
  86.    UINT8 &unASMFlags,
  87.    UINT16 &unASMRuleNumber);
  89.     inline HX_RESULT _Set(
  90.                    IHXBuffer* pBuffer, 
  91.    ULONG32 ulTime,
  92.    UINT16 uStreamNumber,
  93.    UINT8 unASMFlags,
  94.    UINT16 unASMRuleNumber);
  96. public:
  97.     CHXPacket()
  98. : m_lRefCount(0)
  99. , m_pBuffer(NULL)
  100. , m_ulTime(0)
  101. , m_uStreamNumber(0)
  102. , m_unASMFlags(0)
  103. , m_unASMRuleNumber(0)
  104. , m_bIsLost(FALSE)
  105.     {
  106. ;
  107.     }
  109.     /*
  110.      * IUnknown methods
  111.      */
  112.     STDMETHOD(QueryInterface) (THIS_
  113. REFIID riid,
  114. void** ppvObj);
  116.     STDMETHOD_(ULONG32,AddRef) (THIS);
  118.     STDMETHOD_(ULONG32,Release) (THIS);
  120.     /*
  121.      * IHXPacket methods
  122.      */
  123.     STDMETHOD(Get) (THIS_
  124. REF(IHXBuffer*) pBuffer, 
  125. REF(ULONG32) ulTime,
  126. REF(UINT16) uStreamNumber,
  127. REF(UINT8) unASMFlags,
  128. REF(UINT16) unASMRuleNumber);
  130.     STDMETHOD_(IHXBuffer*,GetBuffer) (THIS);
  132.     STDMETHOD_(ULONG32,GetTime) (THIS);
  134.     STDMETHOD_(UINT16,GetStreamNumber) (THIS);
  136.     STDMETHOD_(UINT8,GetASMFlags) (THIS);
  138.     STDMETHOD_(UINT16,GetASMRuleNumber) (THIS);
  140.     STDMETHOD_(BOOL,IsLost) (THIS);
  142.     STDMETHOD(SetAsLost) (THIS);
  144.     STDMETHOD(Set) (THIS_
  145. IHXBuffer* pBuffer, 
  146. ULONG32 ulTime,
  147. UINT16 uStreamNumber,
  148. UINT8 unASMFlags,
  149. UINT16 unASMRuleNumber);
  151.     /*
  152.      * IHXPacket methods
  153.      */
  154.    STDMETHOD(GetRTP) (THIS_
  155. REF(IHXBuffer*) pBuffer, 
  156. REF(ULONG32) ulTime,
  157. REF(ULONG32) ulRTPTime,
  158. REF(UINT16) uStreamNumber,
  159. REF(UINT8) unASMFlags,
  160. REF(UINT16) unASMRuleNumber);
  162.    STDMETHOD_(ULONG32,GetRTPTime) (THIS);
  164.    STDMETHOD(SetRTP) (THIS_
  165. IHXBuffer* pBuffer, 
  166. ULONG32 ulTime,
  167. ULONG32 ulRTPTime,
  168. UINT16 uStreamNumber,
  169. UINT8 unASMFlags,
  170. UINT16 unASMRuleNumber);
  172.    // serialization method
  173.    static void Pack (IHXPacket* pPacket, char* pData, UINT32& ulSize);
  174.    static void UnPack (IHXPacket*& pPacket, char* pData, UINT32 ulSize);
  175. };
  177. /****************************************************************************
  178.  * 
  179.  * Class:
  180.  *
  181.  * CHXRTPPacket
  182.  *
  183.  * Purpose:
  184.  *
  185.  * PN implementation of a RTP packet.
  186.  *
  187.  */
  188. class CHXRTPPacket : public CHXPacket
  189. {
  190. protected:
  191.     ULONG32 m_ulRTPTime;
  193.     ~CHXRTPPacket()
  194.     {
  195. ;
  196.     }
  198. public:
  199.     CHXRTPPacket()
  200. : m_ulRTPTime(0)
  201.     {
  202. ;
  203.     }
  205.     /*
  206.      * IUnknown methods - override
  207.      */
  208.     STDMETHOD(QueryInterface) (THIS_
  209. REFIID riid,
  210. void** ppvObj);
  212.     STDMETHOD_(ULONG32,Release) (THIS);
  214.     /*
  215.      * IHXPacket methods - override
  216.      */
  217.     STDMETHOD(Set) (THIS_
  218. IHXBuffer* pBuffer, 
  219. ULONG32 ulTime,
  220. UINT16 uStreamNumber,
  221. UINT8 unASMFlags,
  222. UINT16 unASMRuleNumber);
  224.     /*
  225.      * IHXRTPPacket methods - override
  226.      */
  227.     STDMETHOD(GetRTP) (THIS_
  228. REF(IHXBuffer*) pBuffer, 
  229. REF(ULONG32) ulTime,
  230. REF(ULONG32) ulRTPTime,
  231. REF(UINT16) uStreamNumber,
  232. REF(UINT8) unASMFlags,
  233. REF(UINT16) unASMRuleNumber);
  235.     STDMETHOD_(ULONG32,GetRTPTime) (THIS);
  237.     STDMETHOD(SetRTP) (THIS_
  238. IHXBuffer* pBuffer, 
  239. ULONG32 ulTime,
  240. ULONG32 ulRTPTime,
  241. UINT16 uStreamNumber,
  242. UINT8 unASMFlags,
  243. UINT16 unASMRuleNumber);
  244. };
  246. class _CStoreName
  247. {
  248. public:
  249.     _CStoreName();
  250.     virtual ~_CStoreName();
  252.     const CHXString& GetName() const;
  253.     void SetName(const char* szName);
  254. private:
  255.     CHXString m_strName;
  256. };
  258. class _CStoreNameUINT32Pair : public _CStoreName
  259. {
  260. public:
  261.     _CStoreNameUINT32Pair();
  262.     ~_CStoreNameUINT32Pair();
  264.     UINT32 GetValue();
  265.     void SetValue(UINT32 ulValue);
  266. private:
  267.     UINT32 m_ulValue;
  268. };
  270. class _CStoreNameBufferPair : public _CStoreName
  271. {
  272. public:
  273.     _CStoreNameBufferPair();
  274.     ~_CStoreNameBufferPair();
  276.     IHXBuffer* GetValue();
  277.     void SetValue(IHXBuffer* pbufValue);
  278. private:
  279.     IHXBuffer* m_pbufValue;
  280. };
  282. /****************************************************************************
  283.  * 
  284.  * Class:
  285.  *
  286.  * CHXHeader
  287.  *
  288.  * Purpose:
  289.  *
  290.  * PN implementation of a basic header.
  291.  *
  292.  */
  294. class CHXHeader : public IHXValues
  295. {
  297. private:
  298. LONG32 m_lRefCount;
  300. CHXMapStringToOb m_ULONG32Map;
  301. CHXMapStringToOb m_BufferMap;
  302. CHXMapStringToOb m_CStringMap;
  304. // set to TRUE if Get/SetPropertyCString is to preserve the case
  305. // of the property name
  306. BOOL m_bPreserveCase;
  308. POSITION m_ULONG32Position;
  309. POSITION m_BufferPosition;
  310. POSITION m_CStringPosition;
  312. ~CHXHeader();
  314. PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  316. protected:
  317. #if 0
  318. // function to encode CString property escape sequences
  319. IHXBuffer* encodeCString(IHXBuffer* pBuffer);
  321. // function to encode buffer property int MIME Base64
  322. IHXBuffer* encodeBuffer(IHXBuffer* pBuffer);
  323. #endif
  325. public:
  326. CHXHeader()
  327. : m_lRefCount(0)
  328. , m_bPreserveCase(FALSE)
  329. , m_ULONG32Position (0)
  330. , m_BufferPosition (0)
  331. , m_CStringPosition (0)
  332. {
  333.         };
  335.     /*
  336.      * IUnknown methods
  337.      */
  338.     STDMETHOD(QueryInterface) (THIS_
  339. REFIID riid,
  340. void** ppvObj);
  342.     STDMETHOD_(ULONG32,AddRef) (THIS);
  344.     STDMETHOD_(ULONG32,Release) (THIS);
  346.     /*
  347.      * IHXValues methods
  348.      */
  350.     STDMETHOD(SetPropertyULONG32) (THIS_
  351. const char*  pPropertyName,
  352. ULONG32  uPropertyValue);
  354.     STDMETHOD(GetPropertyULONG32) (THIS_
  355. const char*  pPropertyName,
  356. REF(ULONG32)  uPropertyValue);
  358.     STDMETHOD(GetFirstPropertyULONG32) (THIS_
  359. REF(const char*) pPropertyName,
  360. REF(ULONG32)  uPropertyValue);
  362.     STDMETHOD(GetNextPropertyULONG32) (THIS_
  363. REF(const char*) pPropertyName,
  364. REF(ULONG32)  uPropertyValue);
  367.     STDMETHOD(SetPropertyBuffer) (THIS_
  368. const char*  pPropertyName,
  369. IHXBuffer*  pPropertyValue);
  371.     STDMETHOD(GetPropertyBuffer) (THIS_
  372. const char*  pPropertyName,
  373. REF(IHXBuffer*) pPropertyValue);
  375. #if 0
  376.     STDMETHOD(GetEncodedPropertyBuffer) (THIS_
  377. const char*  pPropertyName,
  378. REF(IHXBuffer*) pPropertyValue);
  379. #endif
  381.     STDMETHOD(GetFirstPropertyBuffer) (THIS_
  382. REF(const char*) pPropertyName,
  383. REF(IHXBuffer*) pPropertyValue);
  385.     STDMETHOD(GetNextPropertyBuffer) (THIS_
  386. REF(const char*) pPropertyName,
  387. REF(IHXBuffer*) pPropertyValue);
  389.     STDMETHOD(SetPropertyCString) (THIS_
  390. const char*  pPropertyName,
  391. IHXBuffer*  pPropertyValue);
  393.     STDMETHOD(GetPropertyCString) (THIS_
  394. const char*  pPropertyName,
  395. REF(IHXBuffer*) pPropertyValue);
  397. #if 0
  398.     STDMETHOD(GetEncodedPropertyCString)(THIS_
  399. const char*  pPropertyName,
  400. REF(IHXBuffer*) pPropertyValue);
  401. #endif
  403.     STDMETHOD(GetFirstPropertyCString) (THIS_
  404. REF(const char*) pPropertyName,
  405. REF(IHXBuffer*) pPropertyValue);
  407.     STDMETHOD(GetNextPropertyCString) (THIS_
  408. REF(const char*) pPropertyName,
  409. REF(IHXBuffer*) pPropertyValue);
  411.     void PreserveCase (BOOL bPreserve) { m_bPreserveCase = bPreserve; }
  413. public:
  414.     static void mergeHeaders
  415.     (
  416. IHXValues* pIHXValuesDestHeaders, 
  417. IHXValues* pIHXValuesSourceHeaders
  418.     );
  420. };
  422. #endif /* _HXPCKTS_H_ */