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