• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10 
11 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
12 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
13 
14 #include <stddef.h> // size_t, ptrdiff_t
15 
16 #include "webrtc/base/scoped_ptr.h"
17 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
18 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
19 #include "webrtc/typedefs.h"
20 
21 namespace webrtc {
22 namespace rtcp {
23 class RtcpPacket;
24 }
25 namespace RTCPUtility {
26 
27 class NackStats {
28  public:
29   NackStats();
30   ~NackStats();
31 
32   // Updates stats with requested sequence number.
33   // This function should be called for each NACK request to calculate the
34   // number of unique NACKed RTP packets.
35   void ReportRequest(uint16_t sequence_number);
36 
37   // Gets the number of NACKed RTP packets.
requests()38   uint32_t requests() const { return requests_; }
39 
40   // Gets the number of unique NACKed RTP packets.
unique_requests()41   uint32_t unique_requests() const { return unique_requests_; }
42 
43  private:
44   uint16_t max_sequence_number_;
45   uint32_t requests_;
46   uint32_t unique_requests_;
47 };
48 
49 uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac);
50 
51 // CNAME
52 struct RTCPCnameInformation {
53   char name[RTCP_CNAME_SIZE];
54 };
55 struct RTCPPacketRR {
56   uint32_t SenderSSRC;
57   uint8_t NumberOfReportBlocks;
58 };
59 struct RTCPPacketSR {
60   uint32_t SenderSSRC;
61   uint8_t NumberOfReportBlocks;
62 
63   // sender info
64   uint32_t NTPMostSignificant;
65   uint32_t NTPLeastSignificant;
66   uint32_t RTPTimestamp;
67   uint32_t SenderPacketCount;
68   uint32_t SenderOctetCount;
69 };
70 struct RTCPPacketReportBlockItem {
71   // report block
72   uint32_t SSRC;
73   uint8_t FractionLost;
74   uint32_t CumulativeNumOfPacketsLost;
75   uint32_t ExtendedHighestSequenceNumber;
76   uint32_t Jitter;
77   uint32_t LastSR;
78   uint32_t DelayLastSR;
79 };
80 struct RTCPPacketSDESCName {
81   // RFC3550
82   uint32_t SenderSSRC;
83   char CName[RTCP_CNAME_SIZE];
84 };
85 
86 struct RTCPPacketExtendedJitterReportItem {
87   // RFC 5450
88   uint32_t Jitter;
89 };
90 
91 struct RTCPPacketBYE {
92   uint32_t SenderSSRC;
93 };
94 struct RTCPPacketXR {
95   // RFC 3611
96   uint32_t OriginatorSSRC;
97 };
98 struct RTCPPacketXRReceiverReferenceTimeItem {
99   // RFC 3611 4.4
100   uint32_t NTPMostSignificant;
101   uint32_t NTPLeastSignificant;
102 };
103 struct RTCPPacketXRDLRRReportBlockItem {
104   // RFC 3611 4.5
105   uint32_t SSRC;
106   uint32_t LastRR;
107   uint32_t DelayLastRR;
108 };
109 struct RTCPPacketXRVOIPMetricItem {
110   // RFC 3611 4.7
111   uint32_t SSRC;
112   uint8_t lossRate;
113   uint8_t discardRate;
114   uint8_t burstDensity;
115   uint8_t gapDensity;
116   uint16_t burstDuration;
117   uint16_t gapDuration;
118   uint16_t roundTripDelay;
119   uint16_t endSystemDelay;
120   uint8_t signalLevel;
121   uint8_t noiseLevel;
122   uint8_t RERL;
123   uint8_t Gmin;
124   uint8_t Rfactor;
125   uint8_t extRfactor;
126   uint8_t MOSLQ;
127   uint8_t MOSCQ;
128   uint8_t RXconfig;
129   uint16_t JBnominal;
130   uint16_t JBmax;
131   uint16_t JBabsMax;
132 };
133 
134 struct RTCPPacketRTPFBNACK {
135   uint32_t SenderSSRC;
136   uint32_t MediaSSRC;
137 };
138 struct RTCPPacketRTPFBNACKItem {
139   // RFC4585
140   uint16_t PacketID;
141   uint16_t BitMask;
142 };
143 
144 struct RTCPPacketRTPFBTMMBR {
145   uint32_t SenderSSRC;
146   uint32_t MediaSSRC;  // zero!
147 };
148 struct RTCPPacketRTPFBTMMBRItem {
149   // RFC5104
150   uint32_t SSRC;
151   uint32_t MaxTotalMediaBitRate;  // In Kbit/s
152   uint32_t MeasuredOverhead;
153 };
154 
155 struct RTCPPacketRTPFBTMMBN {
156   uint32_t SenderSSRC;
157   uint32_t MediaSSRC;  // zero!
158 };
159 struct RTCPPacketRTPFBTMMBNItem {
160   // RFC5104
161   uint32_t SSRC;  // "Owner"
162   uint32_t MaxTotalMediaBitRate;
163   uint32_t MeasuredOverhead;
164 };
165 
166 struct RTCPPacketPSFBFIR {
167   uint32_t SenderSSRC;
168   uint32_t MediaSSRC;  // zero!
169 };
170 struct RTCPPacketPSFBFIRItem {
171   // RFC5104
172   uint32_t SSRC;
173   uint8_t CommandSequenceNumber;
174 };
175 
176 struct RTCPPacketPSFBPLI {
177   // RFC4585
178   uint32_t SenderSSRC;
179   uint32_t MediaSSRC;
180 };
181 
182 struct RTCPPacketPSFBSLI {
183   // RFC4585
184   uint32_t SenderSSRC;
185   uint32_t MediaSSRC;
186 };
187 struct RTCPPacketPSFBSLIItem {
188   // RFC4585
189   uint16_t FirstMB;
190   uint16_t NumberOfMB;
191   uint8_t PictureId;
192 };
193 struct RTCPPacketPSFBRPSI {
194   // RFC4585
195   uint32_t SenderSSRC;
196   uint32_t MediaSSRC;
197   uint8_t PayloadType;
198   uint16_t NumberOfValidBits;
199   uint8_t NativeBitString[RTCP_RPSI_DATA_SIZE];
200 };
201 struct RTCPPacketPSFBAPP {
202   uint32_t SenderSSRC;
203   uint32_t MediaSSRC;
204 };
205 struct RTCPPacketPSFBREMBItem {
206   uint32_t BitRate;
207   uint8_t NumberOfSSRCs;
208   uint32_t SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
209 };
210 // generic name APP
211 struct RTCPPacketAPP {
212   uint8_t SubType;
213   uint32_t Name;
214   uint8_t Data[kRtcpAppCode_DATA_SIZE];
215   uint16_t Size;
216 };
217 
218 union RTCPPacket {
219   RTCPPacketRR RR;
220   RTCPPacketSR SR;
221   RTCPPacketReportBlockItem ReportBlockItem;
222 
223   RTCPPacketSDESCName CName;
224   RTCPPacketBYE BYE;
225 
226   RTCPPacketExtendedJitterReportItem ExtendedJitterReportItem;
227 
228   RTCPPacketRTPFBNACK NACK;
229   RTCPPacketRTPFBNACKItem NACKItem;
230 
231   RTCPPacketPSFBPLI PLI;
232   RTCPPacketPSFBSLI SLI;
233   RTCPPacketPSFBSLIItem SLIItem;
234   RTCPPacketPSFBRPSI RPSI;
235   RTCPPacketPSFBAPP PSFBAPP;
236   RTCPPacketPSFBREMBItem REMBItem;
237 
238   RTCPPacketRTPFBTMMBR TMMBR;
239   RTCPPacketRTPFBTMMBRItem TMMBRItem;
240   RTCPPacketRTPFBTMMBN TMMBN;
241   RTCPPacketRTPFBTMMBNItem TMMBNItem;
242   RTCPPacketPSFBFIR FIR;
243   RTCPPacketPSFBFIRItem FIRItem;
244 
245   RTCPPacketXR XR;
246   RTCPPacketXRReceiverReferenceTimeItem XRReceiverReferenceTimeItem;
247   RTCPPacketXRDLRRReportBlockItem XRDLRRReportBlockItem;
248   RTCPPacketXRVOIPMetricItem XRVOIPMetricItem;
249 
250   RTCPPacketAPP APP;
251 };
252 
253 enum class RTCPPacketTypes {
254   kInvalid,
255 
256   // RFC3550
257   kRr,
258   kSr,
259   kReportBlockItem,
260 
261   kSdes,
262   kSdesChunk,
263   kBye,
264 
265   // RFC5450
266   kExtendedIj,
267   kExtendedIjItem,
268 
269   // RFC4585
270   kRtpfbNack,
271   kRtpfbNackItem,
272 
273   kPsfbPli,
274   kPsfbRpsi,
275   kPsfbSli,
276   kPsfbSliItem,
277   kPsfbApp,
278   kPsfbRemb,
279   kPsfbRembItem,
280 
281   // RFC5104
282   kRtpfbTmmbr,
283   kRtpfbTmmbrItem,
284   kRtpfbTmmbn,
285   kRtpfbTmmbnItem,
286   kPsfbFir,
287   kPsfbFirItem,
288 
289   // draft-perkins-avt-rapid-rtp-sync
290   kRtpfbSrReq,
291 
292   // RFC 3611
293   kXrHeader,
294   kXrReceiverReferenceTime,
295   kXrDlrrReportBlock,
296   kXrDlrrReportBlockItem,
297   kXrVoipMetric,
298 
299   kApp,
300   kAppItem,
301 
302   // draft-holmer-rmcat-transport-wide-cc-extensions
303   kTransportFeedback,
304 };
305 
306 struct RTCPRawPacket {
307   const uint8_t* _ptrPacketBegin;
308   const uint8_t* _ptrPacketEnd;
309 };
310 
311 struct RTCPModRawPacket {
312   uint8_t* _ptrPacketBegin;
313   uint8_t* _ptrPacketEnd;
314 };
315 
316 struct RtcpCommonHeader {
317   static const uint8_t kHeaderSizeBytes = 4;
RtcpCommonHeaderRtcpCommonHeader318   RtcpCommonHeader()
319       : version(2),
320         count_or_format(0),
321         packet_type(0),
322         payload_size_bytes(0),
323         padding_bytes(0) {}
324 
BlockSizeRtcpCommonHeader325   uint32_t BlockSize() const {
326     return kHeaderSizeBytes + payload_size_bytes + padding_bytes;
327   }
328 
329   uint8_t version;
330   uint8_t count_or_format;
331   uint8_t packet_type;
332   uint32_t payload_size_bytes;
333   uint8_t padding_bytes;
334 };
335 
336 enum RTCPPT : uint8_t {
337   PT_IJ = 195,
338   PT_SR = 200,
339   PT_RR = 201,
340   PT_SDES = 202,
341   PT_BYE = 203,
342   PT_APP = 204,
343   PT_RTPFB = 205,
344   PT_PSFB = 206,
345   PT_XR = 207
346 };
347 
348 // Extended report blocks, RFC 3611.
349 enum RtcpXrBlockType : uint8_t {
350   kBtReceiverReferenceTime = 4,
351   kBtDlrr = 5,
352   kBtVoipMetric = 7
353 };
354 
355 bool RtcpParseCommonHeader(const uint8_t* buffer,
356                            size_t size_bytes,
357                            RtcpCommonHeader* parsed_header);
358 
359 class RTCPParserV2 {
360  public:
361   RTCPParserV2(
362       const uint8_t* rtcpData,
363       size_t rtcpDataLength,
364       bool rtcpReducedSizeEnable);  // Set to true, to allow non-compound RTCP!
365   ~RTCPParserV2();
366 
367   RTCPPacketTypes PacketType() const;
368   const RTCPPacket& Packet() const;
369   rtcp::RtcpPacket* ReleaseRtcpPacket();
370   const RTCPRawPacket& RawPacket() const;
371   ptrdiff_t LengthLeft() const;
372 
373   bool IsValid() const;
374   size_t NumSkippedBlocks() const;
375 
376   RTCPPacketTypes Begin();
377   RTCPPacketTypes Iterate();
378 
379  private:
380   enum class ParseState {
381     State_TopLevel,            // Top level packet
382     State_ReportBlockItem,     // SR/RR report block
383     State_SDESChunk,           // SDES chunk
384     State_BYEItem,             // BYE item
385     State_ExtendedJitterItem,  // Extended jitter report item
386     State_RTPFB_NACKItem,      // NACK FCI item
387     State_RTPFB_TMMBRItem,     // TMMBR FCI item
388     State_RTPFB_TMMBNItem,     // TMMBN FCI item
389     State_PSFB_SLIItem,        // SLI FCI item
390     State_PSFB_RPSIItem,       // RPSI FCI item
391     State_PSFB_FIRItem,        // FIR FCI item
392     State_PSFB_AppItem,        // Application specific FCI item
393     State_PSFB_REMBItem,       // Application specific REMB item
394     State_XRItem,
395     State_XR_DLLRItem,
396     State_AppItem
397   };
398 
399  private:
400   void IterateTopLevel();
401   void IterateReportBlockItem();
402   void IterateSDESChunk();
403   void IterateBYEItem();
404   void IterateExtendedJitterItem();
405   void IterateNACKItem();
406   void IterateTMMBRItem();
407   void IterateTMMBNItem();
408   void IterateSLIItem();
409   void IterateRPSIItem();
410   void IterateFIRItem();
411   void IteratePsfbAppItem();
412   void IteratePsfbREMBItem();
413   void IterateAppItem();
414   void IterateXrItem();
415   void IterateXrDlrrItem();
416 
417   void Validate();
418   void EndCurrentBlock();
419 
420   bool ParseRR();
421   bool ParseSR();
422   bool ParseReportBlockItem();
423 
424   bool ParseSDES();
425   bool ParseSDESChunk();
426   bool ParseSDESItem();
427 
428   bool ParseBYE();
429   bool ParseBYEItem();
430 
431   bool ParseIJ();
432   bool ParseIJItem();
433 
434   bool ParseXr();
435   bool ParseXrItem();
436   bool ParseXrReceiverReferenceTimeItem(int block_length_4bytes);
437   bool ParseXrDlrr(int block_length_4bytes);
438   bool ParseXrDlrrItem();
439   bool ParseXrVoipMetricItem(int block_length_4bytes);
440   bool ParseXrUnsupportedBlockType(int block_length_4bytes);
441 
442   bool ParseFBCommon(const RtcpCommonHeader& header);
443   bool ParseNACKItem();
444   bool ParseTMMBRItem();
445   bool ParseTMMBNItem();
446   bool ParseSLIItem();
447   bool ParseRPSIItem();
448   bool ParseFIRItem();
449   bool ParsePsfbAppItem();
450   bool ParsePsfbREMBItem();
451 
452   bool ParseAPP(const RtcpCommonHeader& header);
453   bool ParseAPPItem();
454 
455  private:
456   const uint8_t* const _ptrRTCPDataBegin;
457   const bool _RTCPReducedSizeEnable;
458   const uint8_t* const _ptrRTCPDataEnd;
459 
460   bool _validPacket;
461   const uint8_t* _ptrRTCPData;
462   const uint8_t* _ptrRTCPBlockEnd;
463 
464   ParseState _state;
465   uint8_t _numberOfBlocks;
466   size_t num_skipped_blocks_;
467 
468   RTCPPacketTypes _packetType;
469   RTCPPacket _packet;
470   rtc::scoped_ptr<webrtc::rtcp::RtcpPacket> rtcp_packet_;
471 };
472 
473 class RTCPPacketIterator {
474  public:
475   RTCPPacketIterator(uint8_t* rtcpData, size_t rtcpDataLength);
476   ~RTCPPacketIterator();
477 
478   const RtcpCommonHeader* Begin();
479   const RtcpCommonHeader* Iterate();
480   const RtcpCommonHeader* Current();
481 
482  private:
483   uint8_t* const _ptrBegin;
484   uint8_t* const _ptrEnd;
485 
486   uint8_t* _ptrBlock;
487 
488   RtcpCommonHeader _header;
489 };
490 }  // namespace RTCPUtility
491 }  // namespace webrtc
492 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
493