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

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

Symbian

开发平台：

C/C++

basepkt.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 _BASEPKT_H_
  37. #define _BASEPKT_H_
  39. #include "hxcom.h"
  40. #include "ihxpckts.h"
  41. #include "chxpckts.h"
  42. #include "hxtime.h"
  43. #include "timeval.h"
  44. #include "hxassert.h"
  45. #include "hxupgrd.h"
  47. class BasePacket : public IHXClientPacket
  48. {
  49. public:
  50.     BasePacket();
  51.     ~BasePacket();
  53.     STDMETHOD(QueryInterface)           (THIS_
  54.                                         REFIID riid,
  55.                                         void** ppvObj);
  57.     STDMETHOD_(ULONG32,AddRef) (THIS);
  59.     STDMETHOD_(ULONG32,Release) (THIS);
  61.     virtual void SetPacket(IHXPacket* pPacket);
  62.     virtual IHXPacket* GetPacket();
  63.     virtual IHXPacket* PeekPacket(); /* This function violates COM Reference Rules */
  64.     virtual UINT16 GetSequenceNumber();
  65.     virtual UINT16 GetReliableSeqNo();
  66.     STDMETHOD_(ULONG32,GetTime)         (THIS);
  67.     STDMETHOD_(UINT16,GetStreamNumber)  (THIS);
  68.     virtual UINT32 GetSize();
  69.     virtual BOOL IsReliable();
  70.     BOOL IsResendRequested();
  71.     void SetResendRequested();
  73.     /*
  74.      * Leave these public because it's just easier
  75.      */
  77.     UINT16 m_uSequenceNumber;
  78.     UINT16 m_uReliableSeqNo;
  79.     UINT32 m_uPriority;
  80.     BOOL m_bIsReliable;
  81.     BOOL m_bBackToBack;
  82.     BOOL m_bIsResendRequested;
  84. protected:
  85.     LONG32 m_lRefCount;
  86.     IHXPacket* m_pPacket;
  87. };
  89. inline
  90. BasePacket::BasePacket()
  91. {
  92.     m_lRefCount = 0;
  93.     m_pPacket = 0;
  94.     m_uSequenceNumber = 0;
  95.     m_uReliableSeqNo = 0;
  96.     m_uPriority = 0;
  97.     m_bIsReliable = FALSE;
  98.     m_bBackToBack = FALSE;
  99.     m_bIsResendRequested = FALSE;
  100. }
  102. inline
  103. BasePacket::~BasePacket()
  104. {
  105.     if (m_pPacket)
  106.     {
  107. m_pPacket->Release();
  108.     }
  109. }
  111. inline void
  112. BasePacket::SetPacket(IHXPacket* pPacket)
  113. {
  114.     m_pPacket = pPacket;
  116.     if (m_pPacket)
  117.     {
  118. m_pPacket->AddRef();
  119.     }
  120.    
  121. }
  123. inline IHXPacket*
  124. BasePacket::GetPacket()
  125. {
  126.     if (m_pPacket)
  127.     {
  128. m_pPacket->AddRef();
  129.     }
  131.     return m_pPacket;
  132. }
  134. inline IHXPacket*
  135. BasePacket::PeekPacket()
  136. {
  137.     /* This function violates COM Reference Rules */
  139.     return m_pPacket;
  140. }
  142. inline STDMETHODIMP
  143. BasePacket::QueryInterface(REFIID riid,
  144.                              void** ppvObj)
  145. {
  146. QInterfaceList qiList[] =
  147. {
  148. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*) this },
  149. { GET_IIDHANDLE(IID_IHXClientPacket), (IHXClientPacket*) this },
  150. };
  151.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj); 
  152. }
  154. inline ULONG32
  155. BasePacket::AddRef()
  156. {
  157.     return InterlockedIncrement(&m_lRefCount);
  158. }
  160. inline ULONG32
  161. BasePacket::Release()
  162. {
  163.     if (InterlockedDecrement(&m_lRefCount) > 0)
  164.     {
  165. return m_lRefCount;
  166.     }
  168.     delete this;
  169.     return 0;
  170. }
  172. inline UINT16
  173. BasePacket::GetSequenceNumber()
  174. {
  175.     return m_uSequenceNumber;
  176. }
  178. inline UINT16
  179. BasePacket::GetReliableSeqNo()
  180. {
  181.     return m_uReliableSeqNo;
  182. }
  184. inline STDMETHODIMP_(UINT16)
  185. BasePacket::GetStreamNumber()
  186. {
  187.     return m_pPacket->GetStreamNumber();
  188. }
  190. inline STDMETHODIMP_(ULONG32)
  191. BasePacket::GetTime()
  192. {
  193.     return m_pPacket->GetTime();
  194. }
  196. inline UINT32
  197. BasePacket::GetSize()
  198. {
  199.     if (m_pPacket->IsLost())
  200.     {
  201. return 0;
  202.     }
  204.     UINT32 size;
  205.     IHXBuffer* pBuffer = m_pPacket->GetBuffer();
  206.     HX_ASSERT(pBuffer);
  207.     size = pBuffer->GetSize();
  208.     pBuffer->Release();
  209.     return size;
  210. }
  212. inline BOOL
  213. BasePacket::IsReliable()
  214. {
  215.     return m_bIsReliable;
  216. }
  218. inline BOOL
  219. BasePacket::IsResendRequested()
  220. {
  221.     return m_bIsResendRequested;
  222. }
  224. inline void
  225. BasePacket::SetResendRequested()
  226. {
  227.     m_bIsResendRequested = TRUE;
  228. }
  230. struct HXClientPacketInfo
  231. {
  232.     UINT8       reliable;
  233.     UINT8       sanitize;
  234.     UINT16      sequenceNumber;
  235.     UINT16 reliableSeqNo;
  236.     Timeval     startTime;
  237. };
  239. class ClientPacket : public BasePacket
  240. {
  241. public:
  242.     ClientPacket(UINT16      uSequenceNumber,
  243.                  UINT16      uReliableSeqNo,
  244.                  UINT32      uTimestamp,
  245.                  UINT32      uNumBytes,
  246.                  BOOL        bIsReliable,
  247.                  IHXPacket* pPacket,
  248.                  Timeval     StartTime,
  249.  BOOL        bSanitize,
  250.  BOOL        bDropped = FALSE);
  252.     STDMETHOD_(ULONG32,GetTime)         (THIS);
  253.     UINT32 GetByteCount();
  254.     BOOL IsLostPacket();
  255.     BOOL IsDroppedPacket();
  256.     BOOL IsSanitizePacket();
  257.     Timeval GetStartTime();
  259.     // serialization method
  260.     static void Pack (IHXClientPacket* pPacket, char* pData, UINT32& ulSize);
  261.     static void UnPack (IHXClientPacket*& pPacket, char* pData, UINT32 ulSize);
  263. private:
  264.     UINT32 m_uTimestamp;
  265.     UINT32 m_uByteCount;
  266.     Timeval m_StartTime;
  267.     BOOL m_bSanitize;
  268.     BOOL                        m_bDropped;
  269. };
  271. inline
  272. ClientPacket::ClientPacket
  273. (
  274.     UINT16      uSequenceNumber,
  275.     UINT16      uReliableSeqNo,
  276.     UINT32      uTimestamp,
  277.     UINT32      uByteCount,
  278.     BOOL        bIsReliable,
  279.     IHXPacket* pPacket,
  280.     Timeval     StartTime,
  281.     BOOL bSanitize,
  282.     BOOL        bDropped
  283. )
  284. {
  285.     m_uSequenceNumber = uSequenceNumber;
  286.     m_uReliableSeqNo = uReliableSeqNo;
  287.     m_uTimestamp = uTimestamp;
  288.     m_uByteCount = uByteCount;
  289.     m_bIsReliable = bIsReliable;
  290.     SetPacket(pPacket);
  291.     m_StartTime = StartTime;
  292.     m_bSanitize = bSanitize;
  293.     m_bDropped = bDropped;
  294. }
  296. inline STDMETHODIMP_(ULONG32)
  297. ClientPacket::GetTime()
  298. {
  299.     return m_uTimestamp;
  300. }
  302. inline UINT32
  303. ClientPacket::GetByteCount()
  304. {
  305.     return m_uByteCount;
  306. }
  308. inline BOOL
  309. ClientPacket::IsLostPacket()
  310. {
  311.     return (m_pPacket || IsDroppedPacket()) ? FALSE : TRUE;
  312. }
  314. inline BOOL
  315. ClientPacket::IsDroppedPacket()
  316. {
  317.     return m_bDropped;
  318. }
  320. inline BOOL
  321. ClientPacket::IsSanitizePacket()
  322. {
  323.     return m_bSanitize;
  324. }
  326. inline Timeval
  327. ClientPacket::GetStartTime()
  328. {
  329.     return m_StartTime;
  330. }
  332. // serialization method
  333. inline void
  334. ClientPacket::Pack(IHXClientPacket* pHXClientPacket, char* pData, UINT32& ulSize)
  335. {
  336.     UINT16     uValue = 0;
  337.     UINT32     ulValue = 0;
  338.     UINT32     ulPacketSize = 0;
  339.     Timeval     startTime = 0;
  340.     IHXPacket*     pPacket = NULL;
  341.     ClientPacket*   pClientPacket = NULL;
  343.     if (!pHXClientPacket)
  344.     {
  345. goto cleanup;
  346.     }
  348.     pClientPacket = (ClientPacket*)pHXClientPacket;
  350.     pPacket = pClientPacket->GetPacket();
  351.     if (pPacket)
  352.     {
  353. CHXPacket::Pack(pPacket, NULL, ulPacketSize);
  354.     }
  356.     // figure out the size 
  357.     if (!pData)
  358.     {
  359. ulSize = sizeof(HXClientPacketInfo) + ulPacketSize;
  360.     }
  361.     // pack the data
  362.     else
  363.     {
  364. pClientPacket = (ClientPacket*)pClientPacket;
  366. *pData++ = (BYTE)pClientPacket->IsReliable(); ulSize++;
  367. *pData++ = (BYTE)pClientPacket->IsSanitizePacket(); ulSize++;
  369. uValue = pClientPacket->GetSequenceNumber();
  370. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  372. uValue = pClientPacket->GetReliableSeqNo();
  373. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  375. startTime = pClientPacket->GetStartTime();
  376. ulValue = startTime.tv_sec;
  377. *pData++ = (BYTE)ulValue; *pData++ = (BYTE)(ulValue >> 8);
  378. *pData++ = (BYTE)(ulValue >> 16); *pData++ = (BYTE)(ulValue >> 24); ulSize += 4;
  380. ulValue = startTime.tv_usec;
  381. *pData++ = (BYTE)ulValue; *pData++ = (BYTE)(ulValue >> 8);
  382. *pData++ = (BYTE)(ulValue >> 16); *pData++ = (BYTE)(ulValue >> 24); ulSize += 4;
  383.     
  384. if (pPacket)
  385. {
  386.     CHXPacket::Pack(pPacket, pData, ulSize);
  387. }
  388.     }
  389.    
  390. cleanup:
  392.     HX_RELEASE(pPacket);
  394.     return;
  395. }   
  397. inline void
  398. ClientPacket::UnPack(IHXClientPacket*& pClientPacket, char* pData, UINT32 ulSize)
  399. {
  400.     UINT16 uValue = 0;
  401.     UINT32 ulValue = 0;
  402.     IHXPacket* pPacket = NULL;
  403.     IHXBuffer* pBuffer = NULL;
  404.     HXClientPacketInfo clientPacketInfo;
  406.     pClientPacket = NULL;
  408.     if (!pData || !ulSize)
  409.     {
  410. goto cleanup;
  411.     }
  413.     HX_ASSERT(ulSize >= sizeof(HXClientPacketInfo));
  415.     clientPacketInfo.reliable = (BYTE)*pData++;     ulSize--;
  416.     clientPacketInfo.sanitize = (BYTE)*pData++;     ulSize--;
  417.     
  418.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  419.     clientPacketInfo.sequenceNumber = uValue;     ulSize -= 2;
  421.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  422.     clientPacketInfo.reliableSeqNo = uValue;     ulSize -= 2;
  424.     ulValue = (BYTE)*pData++; ulValue |= (((BYTE)*pData++) << 8);
  425.     ulValue |= (((BYTE)*pData++) << 16); ulValue |= (((BYTE)*pData++) << 24);
  426.     clientPacketInfo.startTime.tv_sec = ulValue;    ulSize -= 4;
  428.     ulValue = (BYTE)*pData++; ulValue |= (((BYTE)*pData++) << 8);
  429.     ulValue |= (((BYTE)*pData++) << 16); ulValue |= (((BYTE)*pData++) << 24);
  430.     clientPacketInfo.startTime.tv_usec = ulValue;   ulSize -= 4;
  432.     if (ulSize)
  433.     {
  434. CHXPacket::UnPack(pPacket, pData, ulSize);
  435.     }
  437.     if (pPacket)
  438.     {
  439. pBuffer = pPacket->GetBuffer();
  441. pClientPacket = new ClientPacket(clientPacketInfo.sequenceNumber,
  442.  clientPacketInfo.reliableSeqNo,
  443.  pPacket->GetTime(),
  444.  pBuffer->GetSize(),
  445.  clientPacketInfo.reliable,
  446.  pPacket,
  447.  clientPacketInfo.startTime,
  448.  FALSE);
  449.     }
  450.     else
  451.     {
  452. pClientPacket = new ClientPacket(clientPacketInfo.sequenceNumber,
  453.  clientPacketInfo.reliableSeqNo,
  454.  0,
  455.  0,
  456.  0,
  457.  0,
  458.  clientPacketInfo.startTime,
  459.  FALSE);
  460.     }
  462.     pClientPacket->AddRef();
  464. cleanup:
  466.     HX_RELEASE(pBuffer);
  467.     HX_RELEASE(pPacket);
  468.    
  469.     return;
  470. }
  472. #endif