rtcp_utility.h revision 14b43beb7ce4440b30dcea31196de5b4a529cb6b 
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 <cstddef> // size_t, ptrdiff_t
15
16#include "typedefs.h"
17#include "rtp_rtcp_config.h"
18#include "rtp_rtcp_defines.h"
19
20namespace webrtc {
21namespace RTCPUtility {
22    // CNAME
23    struct RTCPCnameInformation
24    {
25        char name[RTCP_CNAME_SIZE];
26    };
27    struct RTCPPacketRR
28    {
29        WebRtc_UWord32 SenderSSRC;
30        WebRtc_UWord8  NumberOfReportBlocks;
31    };
32    struct RTCPPacketSR
33    {
34        WebRtc_UWord32 SenderSSRC;
35        WebRtc_UWord8  NumberOfReportBlocks;
36
37        // sender info
38        WebRtc_UWord32 NTPMostSignificant;
39        WebRtc_UWord32 NTPLeastSignificant;
40        WebRtc_UWord32 RTPTimestamp;
41        WebRtc_UWord32 SenderPacketCount;
42        WebRtc_UWord32 SenderOctetCount;
43    };
44    struct RTCPPacketReportBlockItem
45    {
46        // report block
47        WebRtc_UWord32 SSRC;
48        WebRtc_UWord8  FractionLost;
49        WebRtc_UWord32 CumulativeNumOfPacketsLost;
50        WebRtc_UWord32 ExtendedHighestSequenceNumber;
51        WebRtc_UWord32 Jitter;
52        WebRtc_UWord32 LastSR;
53        WebRtc_UWord32 DelayLastSR;
54    };
55    struct RTCPPacketSDESCName
56    {
57        // RFC3550
58        WebRtc_UWord32 SenderSSRC;
59        char CName[RTCP_CNAME_SIZE];
60    };
61
62    struct RTCPPacketExtendedJitterReportItem
63    {
64        // RFC 5450
65        WebRtc_UWord32 Jitter;
66    };
67
68    struct RTCPPacketBYE
69    {
70        WebRtc_UWord32 SenderSSRC;
71    };
72    struct RTCPPacketXR
73    {
74        // RFC 3611
75        WebRtc_UWord32 OriginatorSSRC;
76    };
77    struct RTCPPacketXRVOIPMetricItem
78    {
79        // RFC 3611 4.7
80        WebRtc_UWord32    SSRC;
81        WebRtc_UWord8     lossRate;
82        WebRtc_UWord8     discardRate;
83        WebRtc_UWord8     burstDensity;
84        WebRtc_UWord8     gapDensity;
85        WebRtc_UWord16    burstDuration;
86        WebRtc_UWord16    gapDuration;
87        WebRtc_UWord16    roundTripDelay;
88        WebRtc_UWord16    endSystemDelay;
89        WebRtc_UWord8     signalLevel;
90        WebRtc_UWord8     noiseLevel;
91        WebRtc_UWord8     RERL;
92        WebRtc_UWord8     Gmin;
93        WebRtc_UWord8     Rfactor;
94        WebRtc_UWord8     extRfactor;
95        WebRtc_UWord8     MOSLQ;
96        WebRtc_UWord8     MOSCQ;
97        WebRtc_UWord8     RXconfig;
98        WebRtc_UWord16    JBnominal;
99        WebRtc_UWord16    JBmax;
100        WebRtc_UWord16    JBabsMax;
101    };
102
103    struct RTCPPacketRTPFBNACK
104    {
105        WebRtc_UWord32 SenderSSRC;
106        WebRtc_UWord32 MediaSSRC;
107    };
108    struct RTCPPacketRTPFBNACKItem
109    {
110        // RFC4585
111        WebRtc_UWord16 PacketID;
112        WebRtc_UWord16 BitMask;
113    };
114
115    struct RTCPPacketRTPFBTMMBR
116    {
117        WebRtc_UWord32 SenderSSRC;
118        WebRtc_UWord32 MediaSSRC; // zero!
119    };
120    struct RTCPPacketRTPFBTMMBRItem
121    {
122        // RFC5104
123        WebRtc_UWord32 SSRC;
124        WebRtc_UWord32 MaxTotalMediaBitRate; // In Kbit/s
125        WebRtc_UWord32 MeasuredOverhead;
126    };
127
128    struct RTCPPacketRTPFBTMMBN
129    {
130        WebRtc_UWord32 SenderSSRC;
131        WebRtc_UWord32 MediaSSRC; // zero!
132    };
133    struct RTCPPacketRTPFBTMMBNItem
134    {
135        // RFC5104
136        WebRtc_UWord32 SSRC; // "Owner"
137        WebRtc_UWord32 MaxTotalMediaBitRate;
138        WebRtc_UWord32 MeasuredOverhead;
139    };
140
141    struct RTCPPacketPSFBFIR
142    {
143        WebRtc_UWord32 SenderSSRC;
144        WebRtc_UWord32 MediaSSRC; // zero!
145    };
146    struct RTCPPacketPSFBFIRItem
147    {
148        // RFC5104
149        WebRtc_UWord32 SSRC;
150        WebRtc_UWord8  CommandSequenceNumber;
151    };
152
153    struct RTCPPacketPSFBPLI
154    {
155        // RFC4585
156        WebRtc_UWord32 SenderSSRC;
157        WebRtc_UWord32 MediaSSRC;
158    };
159
160    struct RTCPPacketPSFBSLI
161    {
162        // RFC4585
163        WebRtc_UWord32 SenderSSRC;
164        WebRtc_UWord32 MediaSSRC;
165    };
166    struct RTCPPacketPSFBSLIItem
167    {
168        // RFC4585
169        WebRtc_UWord16 FirstMB;
170        WebRtc_UWord16 NumberOfMB;
171        WebRtc_UWord8 PictureId;
172    };
173    struct RTCPPacketPSFBRPSI
174    {
175        // RFC4585
176        WebRtc_UWord32 SenderSSRC;
177        WebRtc_UWord32 MediaSSRC;
178        WebRtc_UWord8  PayloadType;
179        WebRtc_UWord16 NumberOfValidBits;
180        WebRtc_UWord8  NativeBitString[RTCP_RPSI_DATA_SIZE];
181    };
182    struct RTCPPacketPSFBAPP
183    {
184        WebRtc_UWord32 SenderSSRC;
185        WebRtc_UWord32 MediaSSRC;
186    };
187    struct RTCPPacketPSFBREMBItem
188    {
189        WebRtc_UWord32 BitRate;
190        WebRtc_UWord8 NumberOfSSRCs;
191        WebRtc_UWord32 SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
192    };
193    // generic name APP
194    struct RTCPPacketAPP
195    {
196        WebRtc_UWord8     SubType;
197        WebRtc_UWord32    Name;
198        WebRtc_UWord8     Data[kRtcpAppCode_DATA_SIZE];
199        WebRtc_UWord16    Size;
200    };
201
202    union RTCPPacket
203    {
204        RTCPPacketRR              RR;
205        RTCPPacketSR              SR;
206        RTCPPacketReportBlockItem ReportBlockItem;
207
208        RTCPPacketSDESCName       CName;
209        RTCPPacketBYE             BYE;
210
211        RTCPPacketExtendedJitterReportItem ExtendedJitterReportItem;
212
213        RTCPPacketRTPFBNACK       NACK;
214        RTCPPacketRTPFBNACKItem   NACKItem;
215
216        RTCPPacketPSFBPLI         PLI;
217        RTCPPacketPSFBSLI         SLI;
218        RTCPPacketPSFBSLIItem     SLIItem;
219        RTCPPacketPSFBRPSI        RPSI;
220        RTCPPacketPSFBAPP         PSFBAPP;
221        RTCPPacketPSFBREMBItem    REMBItem;
222
223        RTCPPacketRTPFBTMMBR      TMMBR;
224        RTCPPacketRTPFBTMMBRItem  TMMBRItem;
225        RTCPPacketRTPFBTMMBN      TMMBN;
226        RTCPPacketRTPFBTMMBNItem  TMMBNItem;
227        RTCPPacketPSFBFIR         FIR;
228        RTCPPacketPSFBFIRItem     FIRItem;
229
230        RTCPPacketXR               XR;
231        RTCPPacketXRVOIPMetricItem XRVOIPMetricItem;
232
233        RTCPPacketAPP             APP;
234    };
235
236    enum RTCPPacketTypes
237    {
238        kRtcpNotValidCode,
239
240        // RFC3550
241        kRtcpRrCode,
242        kRtcpSrCode,
243        kRtcpReportBlockItemCode,
244
245        kRtcpSdesCode,
246        kRtcpSdesChunkCode,
247        kRtcpByeCode,
248
249        // RFC5450
250        kRtcpExtendedIjCode,
251        kRtcpExtendedIjItemCode,
252
253        // RFC4585
254        kRtcpRtpfbNackCode,
255        kRtcpRtpfbNackItemCode,
256
257        kRtcpPsfbPliCode,
258        kRtcpPsfbRpsiCode,
259        kRtcpPsfbSliCode,
260        kRtcpPsfbSliItemCode,
261        kRtcpPsfbAppCode,
262        kRtcpPsfbRembCode,
263        kRtcpPsfbRembItemCode,
264
265        // RFC5104
266        kRtcpRtpfbTmmbrCode,
267        kRtcpRtpfbTmmbrItemCode,
268        kRtcpRtpfbTmmbnCode,
269        kRtcpRtpfbTmmbnItemCode,
270        kRtcpPsfbFirCode,
271        kRtcpPsfbFirItemCode,
272
273        // draft-perkins-avt-rapid-rtp-sync
274        kRtcpRtpfbSrReqCode,
275
276        // RFC 3611
277        kRtcpXrVoipMetricCode,
278
279        kRtcpAppCode,
280        kRtcpAppItemCode,
281    };
282
283    struct RTCPRawPacket
284    {
285        const WebRtc_UWord8* _ptrPacketBegin;
286        const WebRtc_UWord8* _ptrPacketEnd;
287    };
288
289    struct RTCPModRawPacket
290    {
291        WebRtc_UWord8* _ptrPacketBegin;
292        WebRtc_UWord8* _ptrPacketEnd;
293    };
294
295    struct RTCPCommonHeader
296    {
297        WebRtc_UWord8  V;  // Version
298        bool           P;  // Padding
299        WebRtc_UWord8  IC; // Item count/subtype
300        WebRtc_UWord8  PT; // Packet Type
301        WebRtc_UWord16 LengthInOctets;
302    };
303
304    enum RTCPPT
305    {
306        PT_IJ    = 195,
307        PT_SR    = 200,
308        PT_RR    = 201,
309        PT_SDES  = 202,
310        PT_BYE   = 203,
311        PT_APP   = 204,
312        PT_RTPFB = 205,
313        PT_PSFB  = 206,
314        PT_XR    = 207
315    };
316
317    bool RTCPParseCommonHeader( const WebRtc_UWord8* ptrDataBegin,
318                                const WebRtc_UWord8* ptrDataEnd,
319                                RTCPCommonHeader& parsedHeader);
320
321    class RTCPParserV2
322    {
323    public:
324        RTCPParserV2(const WebRtc_UWord8* rtcpData,
325                     size_t rtcpDataLength,
326                     bool rtcpReducedSizeEnable); // Set to true, to allow non-compound RTCP!
327        ~RTCPParserV2();
328
329        RTCPPacketTypes PacketType() const;
330        const RTCPPacket& Packet() const;
331        const RTCPRawPacket& RawPacket() const;
332        ptrdiff_t LengthLeft() const;
333
334        bool IsValid() const;
335
336        RTCPPacketTypes Begin();
337        RTCPPacketTypes Iterate();
338
339    private:
340        enum ParseState
341        {
342            State_TopLevel,        // Top level packet
343            State_ReportBlockItem, // SR/RR report block
344            State_SDESChunk,       // SDES chunk
345            State_BYEItem,         // BYE item
346            State_ExtendedJitterItem, // Extended jitter report item
347            State_RTPFB_NACKItem,  // NACK FCI item
348            State_RTPFB_TMMBRItem, // TMMBR FCI item
349            State_RTPFB_TMMBNItem, // TMMBN FCI item
350            State_PSFB_SLIItem,    // SLI FCI item
351            State_PSFB_RPSIItem,   // RPSI FCI item
352            State_PSFB_FIRItem,    // FIR FCI item
353            State_PSFB_AppItem,    // Application specific FCI item
354            State_PSFB_REMBItem,   // Application specific REMB item
355            State_XRItem,
356            State_AppItem
357        };
358
359    private:
360        void IterateTopLevel();
361        void IterateReportBlockItem();
362        void IterateSDESChunk();
363        void IterateBYEItem();
364        void IterateExtendedJitterItem();
365        void IterateNACKItem();
366        void IterateTMMBRItem();
367        void IterateTMMBNItem();
368        void IterateSLIItem();
369        void IterateRPSIItem();
370        void IterateFIRItem();
371        void IteratePsfbAppItem();
372        void IteratePsfbREMBItem();
373        void IterateAppItem();
374
375        void Validate();
376        void EndCurrentBlock();
377
378        bool ParseRR();
379        bool ParseSR();
380        bool ParseReportBlockItem();
381
382        bool ParseSDES();
383        bool ParseSDESChunk();
384        bool ParseSDESItem();
385
386        bool ParseBYE();
387        bool ParseBYEItem();
388
389        bool ParseIJ();
390        bool ParseIJItem();
391
392        bool ParseXR();
393        bool ParseXRItem();
394        bool ParseXRVOIPMetricItem();
395
396        bool ParseFBCommon(const RTCPCommonHeader& header);
397        bool ParseNACKItem();
398        bool ParseTMMBRItem();
399        bool ParseTMMBNItem();
400        bool ParseSLIItem();
401        bool ParseRPSIItem();
402        bool ParseFIRItem();
403        bool ParsePsfbAppItem();
404        bool ParsePsfbREMBItem();
405
406        bool ParseAPP(const RTCPCommonHeader& header);
407        bool ParseAPPItem();
408
409    private:
410        const WebRtc_UWord8* const _ptrRTCPDataBegin;
411        const bool                 _RTCPReducedSizeEnable;
412        const WebRtc_UWord8* const _ptrRTCPDataEnd;
413
414        bool                     _validPacket;
415        const WebRtc_UWord8*     _ptrRTCPData;
416        const WebRtc_UWord8*     _ptrRTCPBlockEnd;
417
418        ParseState               _state;
419        WebRtc_UWord8            _numberOfBlocks;
420
421        RTCPPacketTypes          _packetType;
422        RTCPPacket               _packet;
423    };
424
425    class RTCPPacketIterator
426    {
427    public:
428        RTCPPacketIterator(WebRtc_UWord8* rtcpData,
429                            size_t rtcpDataLength);
430        ~RTCPPacketIterator();
431
432        const RTCPCommonHeader* Begin();
433        const RTCPCommonHeader* Iterate();
434        const RTCPCommonHeader* Current();
435
436    private:
437        WebRtc_UWord8* const     _ptrBegin;
438        WebRtc_UWord8* const     _ptrEnd;
439
440        WebRtc_UWord8*           _ptrBlock;
441
442        RTCPCommonHeader         _header;
443    };
444} // RTCPUtility
445} // namespace webrtc
446#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
447