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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rtppkt.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：17k
源码类别：

Symbian

开发平台：

Visual C++

rtppkt.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rtppkt.h,v 1.7.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 PMC_PREDEFINED_TYPES
  50. #define PMC_PREDEFINED_TYPES
  52. typedef char* pmc_string;
  54. struct buffer {
  55.  UINT32 len;
  56.  INT8* data;
  57. };
  58. #endif/*PMC_PREDEFINED_TYPES*/
  61. /* $Id: rtppkt.h,v 1.7.8.1 2004/07/09 02:04:29 hubbe Exp $ */
  63. #ifndef _RTPPKT_H_
  64. #define _RTPPKT_H_
  66. // op-codes
  67. const int RTP_OP_PACKETFLAGS = 1;   // opcode datalength = 1
  68. const int RTP_OP_ASMRULES = 2;     // packs asm_flags/asm_rule instead
  69.     // of op_code_data
  71. // flags for opcode RTP_OP_PACKETFLAGS
  72. const int RTP_FLAG_LASTPACKET = 0x00000001; // last packet in stream
  73. const int RTP_FLAG_KEYFRAME =   0x00000002; // keyframe packet
  75. // RTCP types
  76. const int RTCP_SR  = 200;
  77. const int RTCP_RR  = 201;
  78. const int RTCP_SDES  = 202;
  79. const int RTCP_BYE  = 203;
  80. const int RTCP_APP  = 204;
  82. // SDES item types
  83. const int SDES_CNAME = 1;
  84. const int SDES_NAME = 2;
  85. const int SDES_EMAIL = 3;
  86. const int SDES_PHONE = 4;
  87. const int SDES_LOC = 5;
  88. const int SDES_TOOL = 6;
  89. const int SDES_NOTE = 7;
  90. const int SDES_PRIV = 8;
  92. // APP tiem Types
  93. const int APP_EOS = 1;
  94. const int APP_BUFINFO = 2;
  96. #include "bufnum.h"
  97. #include "hxinline.h"
  99. class RTPPacketBase
  100. {
  101. public:
  102.     UINT8* pack(UINT8* buf, UINT32 &len);
  103.     UINT8* unpack(UINT8* buf, UINT32 len);
  104.     const UINT32 static_size() {return 20;}
  106.     UINT8 version_flag;
  107.     UINT8 padding_flag;
  108.     UINT8 extension_flag;
  109.     UINT8 csrc_len;
  110.     UINT8 marker_flag;
  111.     UINT8 payload;
  112.     INT16 seq_no;
  113.     INT32 timestamp;
  114.     INT32 ssrc;
  115.     INT32 *csrc;
  116.     INT16 op_code;
  117.     INT16 op_code_data_length;
  118.     INT16 asm_flags;
  119.     INT16 asm_rule;
  120.     INT32 *op_code_data;
  121.     buffer data;
  122. };
  124. class ReceptionReport
  125. {
  126. public:
  127.     UINT8* pack(UINT8* buf, UINT32 &len);
  128.     UINT8* unpack(UINT8* buf, UINT32 len);
  129.     static const UINT32 static_size() {return 24;}
  131.     UINT32 ssrc;
  132.     UINT8 fraction;
  133.     UINT32 lost;
  134.     UINT32 last_seq;
  135.     UINT32 jitter;
  136.     UINT32 lsr;
  137.     UINT32 dlsr;
  138. };
  140. class SDESItem
  141. {
  142. public:
  143.     UINT8* pack(UINT8* buf, UINT32 &len);
  144.     UINT8* unpack(UINT8* buf, UINT32 len);
  145.     const UINT32 static_size() {return 2;}
  147.     UINT8 sdes_type;
  148.     UINT8 length;
  149.     UINT8 *data;
  150. };
  152. class APPItem
  153. {
  154. public:
  155.     UINT8* pack(UINT8* buf, UINT32 &len);
  156.     UINT8* unpack(UINT8* buf, UINT32 len);
  157.     const UINT32 static_size() {return 23;}
  159.     UINT8 app_type;
  160.     UINT8 packet_sent;
  161.     UINT16 seq_no;
  162.     UINT32 timestamp;
  163.     UINT32 lowest_timestamp;
  164.     UINT32 highest_timestamp;
  165.     UINT32 bytes_buffered;
  166.     UINT32 padding0;
  167. };
  169. class RTCPPacketBase
  170. {
  171. public:
  172.     UINT8* pack(UINT8* buf, UINT32 &len);
  173.     UINT8* unpack(UINT8* buf, UINT32 len);
  174.     const UINT32 static_size() {return 40;}
  176.     UINT8 version_flag;
  177.     UINT8 padding_flag;
  178.     UINT8 count;
  179.     UINT8 packet_type;
  180.     UINT16 length;
  181.     UINT32 sr_ssrc;
  182.     UINT32 ntp_sec;
  183.     UINT32 ntp_frac;
  184.     UINT32 rtp_ts;
  185.     UINT32 psent;
  186.     UINT32 osent;
  187.     ReceptionReport *sr_data;
  188.     UINT32 rr_ssrc;
  189.     ReceptionReport *rr_data;
  190.     UINT8 *sdes_data;
  191.     UINT32 *bye_src;
  192.     UINT32 app_ssrc;
  193.     UINT8 app_name[4];
  194.     UINT8 *app_data;
  195. };
  199. #if defined (_DEFINE_INLINE)
  200. HX_INLINE UINT8*
  201. RTPPacketBase::pack(UINT8* buf, UINT32 &len)
  202. {
  203.     UINT8* off = buf;
  205.     {
  206. *off &= ~0xc0; *off |= (version_flag&0x3)<<6;
  207.     }
  208.     {*off &= ~(1<<5); *off |= (padding_flag&1)<<5;}
  209.     {*off &= ~(1<<4); *off |= (extension_flag&1)<<4;}
  210.     {
  211. *off &= ~0xf; *off++ |= csrc_len&0xf;                       
  212.     }
  213.     {*off &= ~(1<<7); *off |= (marker_flag&1)<<7;}
  214.     {
  215. *off &= ~0x7f; *off++ |= payload&0x7f;
  216.     }
  217.     {*off++ = (UINT8) (seq_no>>8); *off++ = (UINT8) (seq_no);}
  218.     {
  219. *off++ = (UINT8) (timestamp>>24); *off++ = (UINT8) (timestamp>>16); *off++ = (UINT8) (timestamp>>8); *off++ = (UINT8) (timestamp);
  220.     }
  221.     {
  222. *off++ = (UINT8) (ssrc>>24); *off++ = (UINT8) (ssrc>>16); *off++ = (UINT8) (ssrc>>8); *off++ = (UINT8) (ssrc);
  223.     }
  224.     if ((csrc_len > 0))
  225.     {
  226.       {for (int i = 0;  i < csrc_len; i++)
  227.   {
  228.       *off++ = (UINT8) (csrc[i]>>24); *off++ = (UINT8) (csrc[i]>>16); *off++ = (UINT8) (csrc[i]>>8); *off++ = (UINT8) (csrc[i]);
  229.   }
  230.       }
  231.     }
  232.     if ((extension_flag == 1))
  233.     {
  234.       {*off++ = (UINT8) (op_code>>8); *off++ = (UINT8) (op_code);}
  235.       {*off++ = (UINT8) (op_code_data_length>>8); *off++ = (UINT8) (op_code_data_length);}
  236.       if ((op_code == 2))
  237.       {
  238. {*off++ = (UINT8) (asm_flags>>8); *off++ = (UINT8) (asm_flags);}
  239. {*off++ = (UINT8) (asm_rule>>8); *off++ = (UINT8) (asm_rule);}
  240.       }
  241.       else
  242.       {
  243. {for (int i = 0;  i < op_code_data_length; i++)
  244.     {
  245. *off++ = (UINT8) (op_code_data[i]>>24); *off++ = (UINT8) (op_code_data[i]>>16); *off++ = (UINT8) (op_code_data[i]>>8); *off++ = (UINT8) (op_code_data[i]);
  246.     }
  247. }
  248.       }
  249.     }
  250.     {
  251. memcpy(off, data.data, data.len); off += data.len; /* Flawfinder: ignore */
  252.     }
  253.     len = off-buf;
  254.     return off;
  255. }
  257. HX_INLINE UINT8*
  258. RTPPacketBase::unpack(UINT8* buf, UINT32 len)
  259. {
  260.     if (!buf || !len)
  261. return 0;
  262.     UINT8* off = buf;
  264.     {
  265. version_flag  = (*off&0xc0)>>6;
  266.     }
  267.     padding_flag = (*off>>5)&1;
  268.     extension_flag = (*off>>4)&1;
  269.     {
  270. csrc_len  = *off++&0xf;
  271.     }
  272.     marker_flag = (*off>>7)&1;
  273.     {
  274. payload  = *off++&0x7f;
  275.     }
  276.     {seq_no = *off++<<8; seq_no |= *off++;}
  277.     {
  278. timestamp = GetDwordFromBufAndInc(off);
  279.     }
  280.     {
  281. ssrc = GetDwordFromBufAndInc(off);
  282.     }
  283.     if ((csrc_len > 0))
  284.     {
  285.       {
  286.   csrc = new INT32[csrc_len];
  287.   for (int i = 0;  i < csrc_len; i++)
  288.   {
  289.       csrc[i] = GetDwordFromBufAndInc(off);
  290.   }
  291.       }
  292.     }
  293.     if ((extension_flag == 1))
  294.     {
  295.       {op_code = *off++<<8; op_code |= *off++;}
  296.       {op_code_data_length = *off++<<8; op_code_data_length |= *off++;}
  297.       if ((op_code == 2))
  298.       {
  299. {asm_flags = *off++<<8; asm_flags |= *off++;}
  300. {asm_rule = *off++<<8; asm_rule |= *off++;}
  301.       }
  302.       else
  303.       {
  304. {
  305.     op_code_data = new INT32[op_code_data_length];
  306.     for (int i = 0;  i < op_code_data_length; i++)
  307.     {
  308. op_code_data[i] = GetDwordFromBufAndInc(off);
  309.     }
  310. }
  311.       }
  312.     }
  313.     {
  314. data.len = len - (off - buf);
  315. if (off-buf+data.len > (int)len)
  316.     return 0;
  317. data.data = (INT8 *)off; off += data.len;
  318.     }
  319.     return off;
  320. }
  322. HX_INLINE UINT8*
  323. ReceptionReport::pack(UINT8* buf, UINT32 &len)
  324. {
  325.     UINT8* off = buf;
  327.     {
  328. *off++ = (UINT8) (ssrc>>24); *off++ = (UINT8) (ssrc>>16); *off++ = (UINT8) (ssrc>>8); *off++ = (UINT8) (ssrc);
  329.     }
  330.     {
  331. *off++ = (UINT8) (fraction);
  332.     }
  333.     {
  334. *off++ = (UINT8) (lost>>16);
  335. *off++ = (UINT8) (lost>>8);
  336. *off++ = (UINT8) (lost);
  337.     }
  338.     {
  339. *off++ = (UINT8) (last_seq>>24); *off++ = (UINT8) (last_seq>>16); *off++ = (UINT8) (last_seq>>8); *off++ = (UINT8) (last_seq);
  340.     }
  341.     {
  342. *off++ = (UINT8) (jitter>>24); *off++ = (UINT8) (jitter>>16); *off++ = (UINT8) (jitter>>8); *off++ = (UINT8) (jitter);
  343.     }
  344.     {
  345. *off++ = (UINT8) (lsr>>24); *off++ = (UINT8) (lsr>>16); *off++ = (UINT8) (lsr>>8); *off++ = (UINT8) (lsr);
  346.     }
  347.     {
  348. *off++ = (UINT8) (dlsr>>24); *off++ = (UINT8) (dlsr>>16); *off++ = (UINT8) (dlsr>>8); *off++ = (UINT8) (dlsr);
  349.     }
  350.     len = off-buf;
  351.     return off;
  352. }
  354. HX_INLINE UINT8*
  355. ReceptionReport::unpack(UINT8* buf, UINT32 len)
  356. {
  357.     if (!buf || !len)
  358. return 0;
  359.     UINT8* off = buf;
  361.     {
  362. ssrc = GetDwordFromBufAndInc(off);
  363.     }
  364.     {
  365. fraction  = *off++;
  366.     }
  367.     {
  368. lost  = *off++<<16;
  369. lost |= *off++<<8;
  370. lost |= *off++;
  371.     }
  372.     {
  373.         last_seq = GetDwordFromBufAndInc(off);
  374.     }
  375.     {
  376.         jitter = GetDwordFromBufAndInc(off);
  377.     }
  378.     {
  379. lsr = GetDwordFromBufAndInc(off);
  380.     }
  381.     {
  382. dlsr = GetDwordFromBufAndInc(off);
  383.     }
  384.     return off;
  385. }
  387. HX_INLINE UINT8*
  388. SDESItem::pack(UINT8* buf, UINT32 &len)
  389. {
  390.     UINT8* off = buf;
  392.     *off++ = sdes_type;
  393.     if ((sdes_type != 0))
  394.     {
  395.       *off++ = length;
  396.       {memcpy(off, data, length); off += length; } /* Flawfinder: ignore */
  397.     }
  398.     len = off-buf;
  399.     return off;
  400. }
  402. HX_INLINE UINT8*
  403. SDESItem::unpack(UINT8* buf, UINT32 len)
  404. {
  405.     if (!buf || !len)
  406. return 0;
  407.     UINT8* off = buf;
  409.     sdes_type = *off++;
  410.     if ((sdes_type != 0))
  411.     {
  412.       length = *off++;
  413.       if (off-buf+length > (int)len)
  414.   return 0;
  415.       {data = (UINT8 *)off; off += length;}
  416.     }
  417.     return off;
  418. }
  420. HX_INLINE UINT8*
  421. APPItem::pack(UINT8* buf, UINT32 &len)
  422. {
  423.     UINT8* off = buf;
  425.     *off++ = app_type;
  426.     if ((1 == app_type))
  427.     {
  428.       {
  429.   *off++ = (UINT8) (packet_sent);
  430.       }
  431.       {*off++ = (UINT8) (seq_no>>8); *off++ = (UINT8) (seq_no);}
  432.       {
  433.   *off++ = (UINT8) (timestamp>>24); *off++ = (UINT8) (timestamp>>16); *off++ = (UINT8) (timestamp>>8); *off++ = (UINT8) (timestamp);
  434.       }
  435.     }
  436.     if ((2 == app_type))
  437.     {
  438.       {
  439.   *off++ = (UINT8) (lowest_timestamp>>24); *off++ = (UINT8) (lowest_timestamp>>16); *off++ = (UINT8) (lowest_timestamp>>8); *off++ = (UINT8) (lowest_timestamp);
  440.       }
  441.       {
  442.   *off++ = (UINT8) (highest_timestamp>>24); *off++ = (UINT8) (highest_timestamp>>16); *off++ = (UINT8) (highest_timestamp>>8); *off++ = (UINT8) (highest_timestamp);
  443.       }
  444.       {
  445.   *off++ = (UINT8) (bytes_buffered>>24); *off++ = (UINT8) (bytes_buffered>>16); *off++ = (UINT8) (bytes_buffered>>8); *off++ = (UINT8) (bytes_buffered);
  446.       }
  447.       {
  448.   *off++ = (UINT8) (padding0>>16);
  449.   *off++ = (UINT8) (padding0>>8);
  450.   *off++ = (UINT8) (padding0);
  451.       }
  452.     }
  453.     len = off-buf;
  454.     return off;
  455. }
  457. HX_INLINE UINT8*
  458. APPItem::unpack(UINT8* buf, UINT32 len)
  459. {
  460.     if (!buf || !len)
  461. return 0;
  462.     UINT8* off = buf;
  464.     app_type = *off++;
  465.     if ((1 == app_type))
  466.     {
  467.       {
  468.   packet_sent  = *off++;
  469.       }
  470.       {seq_no = *off++<<8; seq_no |= *off++;}
  471.       {
  472.   timestamp = GetDwordFromBufAndInc(off);
  473.       }
  474.     }
  475.     if ((2 == app_type))
  476.     {
  477.       {
  478.   lowest_timestamp = GetDwordFromBufAndInc(off);
  479.       }
  480.       {
  481.   highest_timestamp = GetDwordFromBufAndInc(off);
  482.       }
  483.       {
  484.   bytes_buffered = GetDwordFromBufAndInc(off);
  485.       }
  486.       {
  487.   padding0  = *off++<<16;
  488.   padding0 |= *off++<<8;
  489.   padding0 |= *off++;
  490.       }
  491.     }
  492.     return off;
  493. }
  495. HX_INLINE UINT8*
  496. RTCPPacketBase::pack(UINT8* buf, UINT32 &len)
  497. {
  498.     UINT8* off = buf;
  500.     {
  501. *off &= ~0xc0; *off |= (version_flag&0x3)<<6;
  502.     }
  503.     {*off &= ~(1<<5); *off |= (padding_flag&1)<<5;}
  504.     {
  505. *off &= ~0x1f; *off++ |= count&0x1f;
  506.     }
  507.     {
  508. *off++ = (UINT8) (packet_type);
  509.     }
  510.     {*off++ = (UINT8) (length>>8); *off++ = (UINT8) (length);}
  511.     if ((packet_type == 200))
  512.     {
  513.       {
  514.   *off++ = (UINT8) (sr_ssrc>>24); *off++ = (UINT8) (sr_ssrc>>16); *off++ = (UINT8) (sr_ssrc>>8); *off++ = (UINT8) (sr_ssrc);
  515.       }
  516.       {
  517.   *off++ = (UINT8) (ntp_sec>>24); *off++ = (UINT8) (ntp_sec>>16); *off++ = (UINT8) (ntp_sec>>8); *off++ = (UINT8) (ntp_sec);
  518.       }
  519.       {
  520.   *off++ = (UINT8) (ntp_frac>>24); *off++ = (UINT8) (ntp_frac>>16); *off++ = (UINT8) (ntp_frac>>8); *off++ = (UINT8) (ntp_frac);
  521.       }
  522.       {
  523.   *off++ = (UINT8) (rtp_ts>>24); *off++ = (UINT8) (rtp_ts>>16); *off++ = (UINT8) (rtp_ts>>8); *off++ = (UINT8) (rtp_ts);
  524.       }
  525.       {
  526.   *off++ = (UINT8) (psent>>24); *off++ = (UINT8) (psent>>16); *off++ = (UINT8) (psent>>8); *off++ = (UINT8) (psent);
  527.       }
  528.       {
  529.   *off++ = (UINT8) (osent>>24); *off++ = (UINT8) (osent>>16); *off++ = (UINT8) (osent>>8); *off++ = (UINT8) (osent);
  530.       }
  531.       {for (int i = 0;  i < count; i++)
  532.   off = sr_data[i].pack(off, len);
  533.       }
  534.     }
  535.     if ((packet_type == 201))
  536.     {
  537.       {
  538.   *off++ = (UINT8) (rr_ssrc>>24); *off++ = (UINT8) (rr_ssrc>>16); *off++ = (UINT8) (rr_ssrc>>8); *off++ = (UINT8) (rr_ssrc);
  539.       }
  540.       {for (int i = 0;  i < count; i++)
  541.   off = rr_data[i].pack(off, len);
  542.       }
  543.     }
  544.     if ((packet_type == 202))
  545.     {
  546.       {memcpy(off, sdes_data, (length * 4)); off += (length * 4); } /* Flawfinder: ignore */
  547.     }
  548.     if ((packet_type == 203))
  549.     {
  550.       {for (int i = 0;  i < count; i++)
  551.   {
  552.       *off++ = (UINT8) (bye_src[i]>>24); *off++ = (UINT8) (bye_src[i]>>16); *off++ = (UINT8) (bye_src[i]>>8); *off++ = (UINT8) (bye_src[i]);
  553.   }
  554.       }
  555.     }
  556.     if ((packet_type == 204))
  557.     {
  558.       {
  559.   *off++ = (UINT8) (app_ssrc>>24); *off++ = (UINT8) (app_ssrc>>16); *off++ = (UINT8) (app_ssrc>>8); *off++ = (UINT8) (app_ssrc);
  560.       }
  561.       {memcpy(off, app_name, 4); off += 4; } /* Flawfinder: ignore */
  562.       {memcpy(off, app_data, ((length - 2) * 4)); off += ((length - 2) * 4); } /* Flawfinder: ignore */
  563.     }
  564.     len = off-buf;
  565.     return off;
  566. }
  568. HX_INLINE UINT8*
  569. RTCPPacketBase::unpack(UINT8* buf, UINT32 len)
  570. {
  571.     if (!buf || len < 4)
  572. return 0;
  573.     UINT8* off = buf;
  575.     {
  576. version_flag  = (*off&0xc0)>>6;
  577.     }
  578.     padding_flag = (*off>>5)&1;
  579.     {
  580. count  = *off++&0x1f;
  581.     }
  582.     {
  583. packet_type  = *off++;
  584.     }
  585.     {length = *off++<<8; length |= *off++;}
  587.     if (len < (UINT32)4*(length + 1))
  588.     {
  589.         count = 0;
  590.         return 0;
  591.     }
  593.     if ((packet_type == 200))
  594.     {
  595.         if (length < 6)
  596.         {
  597.             count = 0;
  598.             return buf + 4 + 4*length;
  599.         }
  600.       {
  601.   sr_ssrc = GetDwordFromBufAndInc(off);
  602.       }
  603.       {
  604.   ntp_sec = GetDwordFromBufAndInc(off);
  605.       }
  606.       {
  607.   ntp_frac = GetDwordFromBufAndInc(off);
  608.       }
  609.       {
  610.   rtp_ts = GetDwordFromBufAndInc(off);
  611.       }
  612.       {
  613.   psent = GetDwordFromBufAndInc(off);
  614.       }
  615.       {
  616.   osent = GetDwordFromBufAndInc(off);
  617.       }
  618.       if (length < 6 + count*(ReceptionReport::static_size() / 4))
  619.       {
  620.           count = 0;
  621.           return buf + 4 + length*4;
  622.       }
  623.       {
  624.   sr_data = new ReceptionReport[count];
  625.   for (int i = 0;  i < count; i++)
  626.   off = sr_data[i].unpack(off, len);
  627.       }
  628.     }
  629.     if ((packet_type == 201))
  630.     {
  631.         if (length < 1)
  632.         {
  633.             count = 0;
  634.             return buf + 4 + 4*length;
  635.         }
  636.       {
  637.   rr_ssrc = GetDwordFromBufAndInc(off);
  638.       }
  639.         if (length < 1 + count*(ReceptionReport::static_size() / 4))
  640.         {
  641.             count = 0;
  642.             return buf + 4 + length*4;
  643.         }
  644.       {
  645.   rr_data = new ReceptionReport[count];
  646.   for (int i = 0;  i < count; i++)
  647.   off = rr_data[i].unpack(off, len);
  648.       }
  649.     }
  650.     if ((packet_type == 202))
  651.     {
  652.       if (off-buf+(length * 4) > (int)len)
  653.   return 0;
  654.       {sdes_data = (UINT8 *)off; off += (length * 4);}
  655.     }
  656.     if ((packet_type == 203))
  657.     {
  658.         if (length < count)
  659.         {
  660.             count = 0;
  661.             return buf + 4 + length*4;
  662.         }
  663.       {
  664.   bye_src = new UINT32[count];
  665.   for (int i = 0;  i < count; i++)
  666.   {
  667.       bye_src[i] = GetDwordFromBufAndInc(off);
  668.   }
  669.       }
  670.     }
  671.     if ((packet_type == 204))
  672.     {
  673.       {
  674.   app_ssrc = GetDwordFromBufAndInc(off);
  675.       }
  676.       if (off-buf+4 > (int)len)
  677.   return 0;
  678.       {memcpy(app_name, off, 4); off += 4; } /* Flawfinder: ignore */
  679.       if (off-buf+((length - 2) * 4) > (int)len)
  680.   return 0;
  681.       {app_data = (UINT8 *)off; off += ((length - 2) * 4);}
  682.     }
  683.     return off;
  684. }
  686. #endif //_DEFINE_INLINE
  688. #endif /* _RTPPKT_H_ */