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

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rtpwrap.h,v 1.8.8.1 2004/07/09 02:04: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 _RTPWRAP_H_
  50. #define _RTPWRAP_H_
  51. #include "rtppkt.h" // Base class definitions from PMC
  52. #include "hxmap.h"
  53. #include "hxslist.h"
  54. #include "hxassert.h"
  55. #include "hxinline.h"
  56. class RTPPacket : public RTPPacketBase
  57. {
  58. public:
  59.     RTPPacket()
  60.     {
  61.         /* 
  62.          * XXXST I should be doing this in the initialization parameters
  63.          * except the PMC generated class doesn't have a constructor so 
  64.          * I cannot set them in this constructor.
  65.          */
  66.      
  67.         version_flag = 0;
  68.         padding_flag = 0;
  69.         extension_flag = 0;
  70.         csrc_len = 0;
  71.         marker_flag = 0;
  72.         payload = 0;
  73.         seq_no = 0;
  74.         timestamp = 0;
  75.         ssrc = 0;
  76.         csrc = 0;
  77.         op_code = 0;
  78.         op_code_data_length = 0;
  79.         asm_flags = 0;
  80.         asm_rule = 0;
  81.         op_code_data = 0;
  82.         data.data = 0;
  83.         data.len = 0;
  84.     }
  85.     ~RTPPacket()
  86.     {
  87.         if (csrc)
  88.     delete [] csrc;
  89.         if (op_code_data)
  90.     delete [] op_code_data;
  91.     }
  92.     void SetCSrc(INT32* pchNewData, UINT32 ulLen)
  93.     {
  94.         if (csrc)
  95.     delete [] csrc;
  96.         csrc = new INT32[ulLen];
  97.         memcpy(csrc, pchNewData, ulLen * sizeof(INT32)); /* Flawfinder: ignore */
  98.     }
  99.     void SetOpCodeData(INT32* pchNewData, UINT32 ulLen)
  100.     {
  101.         if (op_code_data)
  102.     delete [] op_code_data;
  103.         op_code_data = new INT32[ulLen];
  104.         memcpy(op_code_data, pchNewData, ulLen * sizeof(INT32)); /* Flawfinder: ignore */
  105.     }
  106. };
  107. class RTCPPacket : public RTCPPacketBase
  108. {
  109. public:
  110.     RTCPPacket()
  111.     {
  112.         version_flag = 0;
  113.         padding_flag = 0;
  114.         count = 0;
  115.         packet_type = 0;
  116.         length = 0;
  117.         sr_ssrc = 0;
  118.         ntp_sec = 0;
  119.         ntp_frac = 0;
  120.         rtp_ts = 0;
  121.         psent = 0;
  122.         osent = 0;
  123.         sr_data = 0;
  124.         rr_ssrc = 0;
  125.         rr_data = 0;
  126.         sdes_data = 0;
  127.         bye_src = 0;
  128.         // used for APP
  129.     //    app_name = 0;  // not a pointer...
  130.         app_data = 0;
  131.         m_pAPPItems = 0;
  132.     }
  133.     ~RTCPPacket()
  134.     {
  135.         CleanBuffers();
  136.     }
  137.     UINT8*  pack(UINT8* data, UINT32 &len);
  138.     UINT8*  unpack(UINT8* data, UINT32 len);
  139.     void SetSenderReport  (ReceptionReport* pNewData, UINT32 ulLen)
  140.     {
  141.         if (sr_data)
  142.     delete [] sr_data;
  143.         sr_data = new ReceptionReport[ulLen];
  144.         memcpy(sr_data, pNewData, ulLen * sizeof(ReceptionReport)); /* Flawfinder: ignore */
  145.     }
  146.     void SetReceiverReport(ReceptionReport* pNewData, UINT32 ulLen)
  147.     {
  148.         if (rr_data)
  149.     delete [] rr_data;
  150.         rr_data = new ReceptionReport[ulLen];
  151.         memcpy(rr_data, pNewData, ulLen * sizeof(ReceptionReport)); /* Flawfinder: ignore */
  152.     }
  153.     void SetSDES (UINT8* pchNewData, UINT32 ulLen)
  154.     {
  155.         if (sdes_data)
  156.     delete [] sdes_data;
  157.         sdes_data = new UINT8[ulLen];
  158.         memcpy(sdes_data, pchNewData, ulLen * sizeof(UINT8)); /* Flawfinder: ignore */
  159.     }
  160.     void SetByeSrc (UINT32* pulNewData, UINT32 ulLen)
  161.     {
  162.         if (bye_src)
  163.     delete [] bye_src;
  164.         bye_src = new UINT32[ulLen];
  165.         memcpy(bye_src, pulNewData, ulLen * sizeof(UINT32)); /* Flawfinder: ignore */
  166.     }
  167.     SDESItem* AddSDESItem (UINT32 ulSSrc, SDESItem item)
  168.     {
  169.         /*
  170.          * Attempt to lookup this SSRC id from our map
  171.          */
  172.      
  173.         CHXSimpleList*  pList = NULL;
  174.         SDESItem*     pItem = new SDESItem;
  175.         if (!m_mapSDESSources.Lookup(ulSSrc, (void*&)pList))
  176.         {
  177.     /* Not in map */
  178.     
  179.     pList = new CHXSimpleList;
  180.     m_mapSDESSources[ulSSrc] = pList;
  181.         }
  182.         pItem->sdes_type = item.sdes_type;
  183.         pItem->length = item.length;
  184.         pItem->data = new UINT8[pItem->length];
  185.         memcpy(pItem->data, item.data, item.length * sizeof(UINT8)); /* Flawfinder: ignore */
  186.         pList->AddTail(pItem);
  187.         return pItem;
  188.     }
  189.     void SetAPPItem (APPItem* item, UINT32 ulCount)
  190.     {
  191.         HX_VECTOR_DELETE(m_pAPPItems);
  192.         m_pAPPItems = new APPItem[ulCount];
  193.         memcpy(m_pAPPItems, item, ulCount * sizeof (APPItem)); /* Flawfinder: ignore */
  194.     }
  195.     
  196.     // keys off of source id and contains a pointer to a list 
  197.     // of SDESItems.
  198.     CHXMapLongToObj m_mapSDESSources;    
  199.     // array of APPItem
  200.     APPItem* m_pAPPItems;
  201.     void CleanBuffers();
  202. };
  203. #if defined (_DEFINE_INLINE)
  204. HX_INLINE void
  205. RTCPPacket::CleanBuffers()
  206. {
  207.     if (sr_data)
  208. delete [] sr_data;
  209.     if (rr_data)
  210. delete [] rr_data;
  211.     if (sdes_data)
  212. delete [] sdes_data;
  213.     if (bye_src)
  214. delete [] bye_src;
  215.     if (app_data)
  216. delete [] app_data;
  217.     CHXMapLongToObj::Iterator i;
  218.     for (i = m_mapSDESSources.Begin(); i != m_mapSDESSources.End(); ++i)
  219.     {
  220. CHXSimpleList* pItems = (CHXSimpleList*) *i;
  221. while (!pItems->IsEmpty())
  222. {
  223.     SDESItem* pItem = (SDESItem*) pItems->RemoveHead();
  224.     delete pItem;
  225. }
  226. delete pItems;
  227.     }
  228.     if (m_pAPPItems)
  229.     {
  230. delete [] m_pAPPItems;
  231.     }
  232.     
  233. }
  234. HX_INLINE UINT8*
  235. RTCPPacket::unpack(UINT8* data, UINT32 len)
  236. {
  237.     CleanBuffers();
  238.     UINT8* pBaseOff = RTCPPacketBase::unpack(data, len);
  239.     // immediate error return
  240.     if (!pBaseOff) return 0;
  241.     /*
  242.      * check to see if this is an SDES message and if it is then 
  243.      * parse out the SDES source chunks from the sdes_data blob
  244.      */
  245.     if (packet_type == RTCP_SDES)
  246.     {
  247. HX_ASSERT(sdes_data != NULL);
  248. /*
  249.  * the PMC generates code that points the byte pointer into
  250.  * the containing buffer rather than copying it out we may
  251.  * as well do it all the way here.
  252.  */
  253. UINT8* pOff = new UINT8[length * 4];
  254. memcpy(pOff, sdes_data, length * 4 * sizeof(UINT8)); /* Flawfinder: ignore */
  255. sdes_data = pOff;
  256. for (INT32 iSrc = 0; iSrc < count; iSrc++)
  257. {
  258.     INT32     lSrc = 0;
  259.     CHXSimpleList*  pItems = new CHXSimpleList;
  260.     
  261.     lSrc = GetDwordFromBufAndInc(pOff);
  262.     while (pOff && pOff < sdes_data + (length * 4))
  263.     {
  264. SDESItem*   pItem = new SDESItem;
  265. UINT32     ulItemLen = (length * 4) - (pOff - sdes_data);
  266. pOff = pItem->unpack(pOff, ulItemLen);
  267. if (pItem->sdes_type == 0)
  268. {
  269.     /*
  270.      * We are done with this list of items within the source
  271.      * chunk (null terminated)
  272.      */
  273.     delete pItem;
  274.     break;
  275. }
  276. pItems->AddTail(pItem);
  277.     } 
  278.     
  279.     m_mapSDESSources[lSrc] = pItems;
  280. }
  281.     }
  282.     /*
  283.     * Gatta do the same for APP msg!
  284.     */
  285.     else if (packet_type == RTCP_APP)
  286.     {
  287. HX_ASSERT(app_data != NULL);
  288. /*
  289. *   if this is RNWK app, unpack, otherwise, leave it along...
  290. */
  291. // has to be NULL terminated...
  292. char pc[5] = {0}; /* Flawfinder: ignore */
  293. memcpy(pc, app_name, 4); /* Flawfinder: ignore */
  294. // whether this is ours or not, we have to make own buffer
  295. UINT8* pOff = new UINT8[(length - 2) * 4];
  296. memcpy(pOff, app_data, (length - 2) * 4); /* Flawfinder: ignore */
  297. app_data = pOff;
  298. if ((0 == strncmp((const char*)pc, "RNWK", 4)) || 
  299.     (0 == strncmp((const char*)pc, "HELX", 4)))
  300. {
  301.     // it's ours
  302.     m_pAPPItems = new APPItem[count];
  303.     
  304.     for (UINT32 i = 0; i < count; i++)
  305.     {
  306. HX_ASSERT(pOff);
  307. // length is anything other than 0...
  308. pOff = m_pAPPItems[i].unpack(pOff, 1);
  309.     }
  310. }
  311.     }
  312.     return pBaseOff;
  313. }
  314. HX_INLINE UINT8*
  315. RTCPPacket::pack(UINT8* data, UINT32& len)
  316. {
  317.     if (packet_type == RTCP_SDES)
  318.     {
  319.      /*
  320.       * revert the m_mapSDESSources back to blob form
  321.       */
  322.     
  323.      if (sdes_data != NULL)
  324.      {
  325.     delete [] sdes_data;
  326.      }
  327.     
  328.      /* 
  329.       * Order may be important here, using a map will not
  330.       * guarentee order
  331.       */
  332.     
  333.      UINT8*  pBuf = new UINT8[0x1000];
  334.      UINT8*  pOff = pBuf;
  335.      CHXMapLongToObj::Iterator   iSrc = m_mapSDESSources.Begin();
  336.      for (; iSrc != m_mapSDESSources.End(); ++iSrc)
  337.      {
  338.     INT32 lSrc = iSrc.get_key();
  339.     CHXSimpleList* pItems = (CHXSimpleList*) *iSrc;
  340.     CHXSimpleList::Iterator iItem = pItems->Begin();
  341.     
  342.          *pOff++ = (UINT8) (lSrc>>24);   *pOff++ = (UINT8) (lSrc>>16);
  343.          *pOff++ = (UINT8) (lSrc>>8);    *pOff++ = (UINT8) (lSrc);
  344.     
  345.     for (; iItem != pItems->End(); ++iItem)
  346.     {
  347.      UINT32 ulItemLen = pBuf - pOff;
  348.      SDESItem* pSDESItem = (SDESItem*)*iItem;
  349.     
  350.      pOff = pSDESItem->pack(pOff, ulItemLen);
  351. if (pSDESItem->data)
  352. {
  353.     delete [] pSDESItem->data;
  354. }
  355.     }
  356.     
  357.     /*
  358.      * Terminate the list with an item of type 0 (first byte)
  359.      */
  360.     *pOff++ = 0;
  361.     
  362.          /* 
  363.            * Pad until 4 bytes boundary
  364.            */
  365.     
  366.          int lLength = HX_SAFEINT(pOff - pBuf);
  367.          
  368.          if (lLength % 4)
  369.          {
  370.      memset(pOff, 0, 4 - (lLength % 4));
  371.      pOff += 4 - (lLength % 4);
  372.          }            
  373.          HX_ASSERT((HX_SAFEINT(pOff - pBuf) % 4) == 0);
  374.      }
  375.     
  376.      sdes_data = new UINT8[pOff - pBuf];
  377.      memcpy(sdes_data, pBuf, (pOff - pBuf) * sizeof(UINT8)); /* Flawfinder: ignore */
  378.     
  379.      length = (pOff - pBuf) / 4;
  380. delete [] pBuf;
  381.     }
  382.     else if (packet_type == RTCP_APP)
  383.     {
  384.      /*
  385.       * revert the m_mapSDESSources back to blob form
  386.       */
  387.     
  388.      if (app_data != NULL)
  389.      {
  390.     delete [] app_data;
  391.      }
  392.         
  393.      UINT8*  pBuf = new UINT8[0x1000];
  394.      UINT8*  pOff = pBuf;
  395. UINT32  ulDammy = 0;
  396. for (UINT32 i = 0; i < count; i++)
  397. {
  398.     pOff = m_pAPPItems[i].pack(pOff, ulDammy);
  399. }
  400. app_data = new UINT8[pOff - pBuf];
  401. memcpy(app_data, pBuf, (pOff - pBuf) * sizeof(UINT8)); /* Flawfinder: ignore */
  402. delete [] pBuf;
  403.     }
  404.     
  405.     return RTCPPacketBase::pack(data, len);
  406. }
  407. #endif //_DEFINE_INLINE
  408. #endif /* _RTPWRAP_H_ */