ccRTP
rtcppkt.h
Go to the documentation of this file.
1 // Copyright (C) 2001,2002,2004,2007 Federico Montesino Pouzols <fedemp@altern.org>.
2 //
3 // This program is free software; you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation; either version 2 of the License, or
6 // (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16 //
17 // As a special exception, you may use this file as part of a free software
18 // library without restriction. Specifically, if other files instantiate
19 // templates or use macros or inline functions from this file, or you compile
20 // this file and link it with other files to produce an executable, this
21 // file does not by itself cause the resulting executable to be covered by
22 // the GNU General Public License. This exception does not however
23 // invalidate any other reasons why the executable file might be covered by
24 // the GNU General Public License.
25 //
26 // This exception applies only to the code released under the name GNU
27 // ccRTP. If you copy code from other releases into a copy of GNU
28 // ccRTP, as the General Public License permits, the exception does
29 // not apply to the code that you add in this way. To avoid misleading
30 // anyone as to the status of such modified files, you must delete
31 // this exception notice from them.
32 //
33 // If you write modifications of your own for GNU ccRTP, it is your choice
34 // whether to permit this exception to apply to your modifications.
35 // If you do not wish that, delete this exception notice.
36 //
37 
38 #ifndef CCXX_RTP_RTCPPKT_H_
39 #define CCXX_RTP_RTCPPKT_H_
40 
41 #include <ccrtp/base.h>
42 
43 NAMESPACE_COMMONCPP
44 
65 typedef enum
66 {
78 } SDESItemType;
79 
90 class __EXPORT RTCPCompoundHandler
91 {
92 public:
93  inline void setPathMTU(uint16 mtu)
94  { pathMTU = mtu; }
95 
96  inline uint16 getPathMTU()
97  { return pathMTU; }
98 
99 #ifdef CCXX_PACKED
100 #pragma pack(1)
101 #endif
102 
110  {
111  uint8 fractionLost;
112  uint8 lostMSB;
113  uint16 lostLSW;
114  uint32 highestSeqNum;
115  uint32 jitter;
116  uint32 lsr;
117  uint32 dlsr;
118  };
119 
126  struct RRBlock
127  {
128  uint32 ssrc;
130  };
131 
138  struct RecvReport
139  {
140  uint32 ssrc;
141  RRBlock blocks[1];
142  };
143 
150  struct SenderInfo
151  {
152  uint32 NTPMSW;
153  uint32 NTPLSW;
154  uint32 RTPTimestamp;
155  uint32 packetCount;
156  uint32 octetCount;
157  };
158 
164  struct SendReport
165  {
166  uint32 ssrc;
168  RRBlock blocks[1];
169  };
170 
176  struct SDESItem
177  {
178  uint8 type;
179  uint8 len;
180  char data[1];
181  };
182 
188  struct SDESChunk
189  {
190  uint32 getSSRC() const
191  { return (ntohl(ssrc)); }
192 
193  uint32 ssrc;
195  };
196 
202  struct BYEPacket
203  {
204  uint32 ssrc;
205  uint8 length;
206  };
207 
213  struct APPPacket
214  {
215  uint32 ssrc;
216  char name [4];
217 
218 
219  unsigned char data[1];
220  };
221 
228  struct FIRPacket
229  {
230  uint32 ssrc;
231  };
232 
239  struct NACKPacket
240  {
241  uint32 ssrc;
242  uint16 fsn;
243  uint16 blp;
244  };
245 
252  {
253 #if __BYTE_ORDER == __BIG_ENDIAN
254 
255  unsigned char version:2;
256  unsigned char padding:1;
257  unsigned char block_count:5;
258 #else
259 
260  unsigned char block_count:5;
261  unsigned char padding:1;
262  unsigned char version:2;
263 #endif
264  uint8 type;
265  uint16 length;
266  };
267 
278  struct RTCPPacket
279  {
285  typedef enum {
286  tSR = 200,
287  tRR,
291  tFIR = 192,
292  tNACK = 193,
293  tXR
294  } Type;
295 
300  uint32 getLength() const
301  { return ((ntohs(fh.length) + 1) << 2); }
302 
307  uint32 getSSRC() const
308  { return (ntohl(info.RR.ssrc)); } // SSRC is always the first
309  // word after fh.
310 
312 
313  // An RTCP packet may be of any of the types defined
314  // above, including APP specific ones.
315  union
316  {
324  } info;
325  };
326 #ifdef CCXX_PACKED
327 #pragma pack()
328 #endif
329 
330 protected:
331  enum { defaultPathMTU = 1500 };
332 
333  RTCPCompoundHandler(uint16 mtu = defaultPathMTU);
334 
336 
348  bool
349  checkCompoundRTCPHeader(size_t len);
350 
351  // buffer to hold RTCP compound packets being sent. Allocated
352  // in construction time
353  unsigned char* rtcpSendBuffer;
354  // buffer to hold RTCP compound packets being
355  // received. Allocated at construction time
356  unsigned char* rtcpRecvBuffer;
357 
358  friend class RTCPSenderInfo;
359  friend class RTCPReceiverInfo;
360 private:
361  // path MTU. RTCP packets should not be greater than this
362  uint16 pathMTU;
363  // masks for RTCP header validation;
364  static const uint16 RTCP_VALID_MASK;
365  static const uint16 RTCP_VALID_VALUE;
366 };
367 
374 class __EXPORT RTCPReceiverInfo
375 {
376 public:
378  { memcpy(&receiverInfo,&ri,
380 
382  : receiverInfo( si )
383  {
384  }
385 
387  { }
388 
393  inline uint8
394  getFractionLost() const
395  { return receiverInfo.fractionLost; }
396 
397  inline uint32
398  getCumulativePacketLost() const
399  { return ( ((uint32)ntohs(receiverInfo.lostLSW)) +
400  (((uint32)receiverInfo.lostMSB) << 16) ); }
401 
402  inline uint32
403  getExtendedSeqNum() const
404  { return ntohl(receiverInfo.highestSeqNum); }
405 
412  uint32
413  getJitter() const
414  { return ntohl(receiverInfo.jitter); }
415 
421  uint16
422  getLastSRNTPTimestampInt() const
423  { return (uint16)((ntohl(receiverInfo.lsr) & 0xFFFF0000) >> 16); }
424 
430  uint16
431  getLastSRNTPTimestampFrac() const
432  { return (uint16)(ntohl(receiverInfo.lsr) & 0xFFFF); }
433 
440  uint32
441  getDelayLastSR() const
442  { return ntohl(receiverInfo.dlsr); }
443 
444 private:
446 };
447 
454 class __EXPORT RTCPSenderInfo
455 {
456 public:
457  RTCPSenderInfo(void* si)
458  { memcpy(&senderInfo,&si,
460 
462  : senderInfo( si )
463  {
464  }
465 
467  { }
468 
473  uint32
474  getNTPTimestampInt() const
475  { return ntohl(senderInfo.NTPMSW); }
476 
481  uint32
482  getNTPTimestampFrac() const
483  { return ntohl(senderInfo.NTPLSW); }
484 
485  inline uint32
486  getRTPTimestamp() const
487  { return ntohl(senderInfo.RTPTimestamp); }
488 
492  inline uint32
493  getPacketCount() const
494  { return ntohl(senderInfo.packetCount); }
495 
496  inline uint32
497  getOctetCount() const
498  { return ntohl(senderInfo.octetCount); }
499 
500 private:
502 };
503 
512 timeval
513 NTP2Timeval(uint32 msw, uint32 lsw);
514 
522 uint32
523 timevalIntervalTo65536(timeval& t);
524  // rtcppacket
526 
527 END_NAMESPACE
528 
529 #endif // ndef CCXX_RTP_RTCPPKT_H_
530