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

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

Symbian

开发平台：

C/C++

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