1/*
2 *  Copyright (c) 2014 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
12#ifndef WEBRTC_TEST_RTCP_PACKET_PARSER_H_
13#define WEBRTC_TEST_RTCP_PACKET_PARSER_H_
14
15#include <map>
16#include <string>
17#include <vector>
18
19#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
20#include "webrtc/typedefs.h"
21
22namespace webrtc {
23namespace test {
24
25class RtcpPacketParser;
26
27class PacketType {
28 public:
29  virtual ~PacketType() {}
30
31  int num_packets() const { return num_packets_; }
32
33 protected:
34  PacketType() : num_packets_(0) {}
35
36  int num_packets_;
37};
38
39class SenderReport : public PacketType {
40 public:
41  SenderReport() {}
42  virtual ~SenderReport() {}
43
44  uint32_t Ssrc() const { return sr_.SenderSSRC; }
45  uint32_t NtpSec() const { return sr_.NTPMostSignificant; }
46  uint32_t NtpFrac() const { return sr_.NTPLeastSignificant; }
47  uint32_t RtpTimestamp() const { return sr_.RTPTimestamp; }
48  uint32_t PacketCount() const { return sr_.SenderPacketCount; }
49  uint32_t OctetCount() const { return sr_.SenderOctetCount; }
50
51 private:
52  friend class RtcpPacketParser;
53
54  void Set(const RTCPUtility::RTCPPacketSR& sr) {
55    sr_ = sr;
56    ++num_packets_;
57  }
58
59  RTCPUtility::RTCPPacketSR sr_;
60};
61
62class ReceiverReport : public PacketType {
63 public:
64  ReceiverReport() {}
65  virtual ~ReceiverReport() {}
66
67  uint32_t Ssrc() const { return rr_.SenderSSRC; }
68
69 private:
70  friend class RtcpPacketParser;
71
72  void Set(const RTCPUtility::RTCPPacketRR& rr) {
73    rr_ = rr;
74    ++num_packets_;
75  }
76
77  RTCPUtility::RTCPPacketRR rr_;
78};
79
80class ReportBlock : public PacketType {
81 public:
82  ReportBlock() {}
83  virtual ~ReportBlock() {}
84
85  uint32_t Ssrc() const { return rb_.SSRC; }
86  uint8_t FractionLost() const { return rb_.FractionLost; }
87  uint32_t CumPacketLost() const { return rb_.CumulativeNumOfPacketsLost; }
88  uint32_t ExtHighestSeqNum() const { return rb_.ExtendedHighestSequenceNumber;}
89  uint32_t Jitter() const { return rb_.Jitter; }
90  uint32_t LastSr() const { return rb_.LastSR; }
91  uint32_t DelayLastSr()const  { return rb_.DelayLastSR; }
92
93 private:
94  friend class RtcpPacketParser;
95
96  void Set(const RTCPUtility::RTCPPacketReportBlockItem& rb) {
97    rb_ = rb;
98    ++num_packets_;
99  }
100
101  RTCPUtility::RTCPPacketReportBlockItem rb_;
102};
103
104class Ij : public PacketType {
105 public:
106  Ij() {}
107  virtual ~Ij() {}
108
109 private:
110  friend class RtcpPacketParser;
111
112  void Set() { ++num_packets_; }
113};
114
115class IjItem : public PacketType {
116 public:
117  IjItem() {}
118  virtual ~IjItem() {}
119
120  uint32_t Jitter() const { return ij_item_.Jitter; }
121
122 private:
123  friend class RtcpPacketParser;
124
125  void Set(const RTCPUtility::RTCPPacketExtendedJitterReportItem& ij_item) {
126    ij_item_ = ij_item;
127    ++num_packets_;
128  }
129
130  RTCPUtility::RTCPPacketExtendedJitterReportItem ij_item_;
131};
132
133class Sdes : public PacketType {
134 public:
135  Sdes() {}
136  virtual ~Sdes() {}
137
138 private:
139  friend class RtcpPacketParser;
140
141  void Set() { ++num_packets_; }
142};
143
144class SdesChunk : public PacketType {
145 public:
146  SdesChunk() {}
147  virtual ~SdesChunk() {}
148
149  uint32_t Ssrc() const { return cname_.SenderSSRC; }
150  std::string Cname() const { return cname_.CName; }
151
152 private:
153  friend class RtcpPacketParser;
154
155  void Set(const RTCPUtility::RTCPPacketSDESCName& cname) {
156    cname_ = cname;
157    ++num_packets_;
158  }
159
160  RTCPUtility::RTCPPacketSDESCName cname_;
161};
162
163class Bye : public PacketType {
164 public:
165  Bye() {}
166  virtual ~Bye() {}
167
168  uint32_t Ssrc() const { return bye_.SenderSSRC; }
169
170 private:
171  friend class RtcpPacketParser;
172
173  void Set(const RTCPUtility::RTCPPacketBYE& bye) {
174    bye_ = bye;
175    ++num_packets_;
176  }
177
178  RTCPUtility::RTCPPacketBYE bye_;
179};
180
181class Rpsi : public PacketType {
182 public:
183  Rpsi() {}
184  virtual ~Rpsi() {}
185
186  uint32_t Ssrc() const { return rpsi_.SenderSSRC; }
187  uint32_t MediaSsrc() const { return rpsi_.MediaSSRC; }
188  uint8_t PayloadType() const { return rpsi_.PayloadType; }
189  uint16_t NumberOfValidBits() const { return rpsi_.NumberOfValidBits; }
190  uint64_t PictureId() const;
191
192 private:
193  friend class RtcpPacketParser;
194
195  void Set(const RTCPUtility::RTCPPacketPSFBRPSI& rpsi) {
196    rpsi_ = rpsi;
197    ++num_packets_;
198  }
199
200  RTCPUtility::RTCPPacketPSFBRPSI rpsi_;
201};
202
203class App : public PacketType {
204 public:
205  App() {}
206  virtual ~App() {}
207
208  uint8_t SubType() const { return app_.SubType; }
209  uint32_t Name() const { return app_.Name; }
210
211 private:
212  friend class RtcpPacketParser;
213
214  void Set(const RTCPUtility::RTCPPacketAPP& app) {
215    app_ = app;
216    ++num_packets_;
217  }
218
219  RTCPUtility::RTCPPacketAPP app_;
220};
221
222class AppItem : public PacketType {
223 public:
224  AppItem() {}
225  virtual ~AppItem() {}
226
227  uint8_t* Data() { return app_item_.Data; }
228  uint16_t DataLength() const { return app_item_.Size; }
229
230 private:
231  friend class RtcpPacketParser;
232
233  void Set(const RTCPUtility::RTCPPacketAPP& app) {
234    app_item_ = app;
235    ++num_packets_;
236  }
237
238  RTCPUtility::RTCPPacketAPP app_item_;
239};
240
241class Pli : public PacketType {
242 public:
243  Pli() {}
244  virtual ~Pli() {}
245
246  uint32_t Ssrc() const { return pli_.SenderSSRC; }
247  uint32_t MediaSsrc() const { return pli_.MediaSSRC; }
248
249 private:
250  friend class RtcpPacketParser;
251
252  void Set(const RTCPUtility::RTCPPacketPSFBPLI& pli) {
253    pli_ = pli;
254    ++num_packets_;
255  }
256
257  RTCPUtility::RTCPPacketPSFBPLI pli_;
258};
259
260class Sli : public PacketType {
261 public:
262  Sli() {}
263  virtual ~Sli() {}
264
265  uint32_t Ssrc() const { return sli_.SenderSSRC; }
266  uint32_t MediaSsrc() const { return sli_.MediaSSRC; }
267
268 private:
269  friend class RtcpPacketParser;
270
271  void Set(const RTCPUtility::RTCPPacketPSFBSLI& sli) {
272    sli_ = sli;
273    ++num_packets_;
274  }
275
276  RTCPUtility::RTCPPacketPSFBSLI sli_;
277};
278
279class SliItem : public PacketType {
280 public:
281  SliItem() {}
282  virtual ~SliItem() {}
283
284  uint16_t FirstMb() const { return sli_item_.FirstMB; }
285  uint16_t NumberOfMb() const { return sli_item_.NumberOfMB; }
286  uint8_t PictureId() const { return sli_item_.PictureId; }
287
288 private:
289  friend class RtcpPacketParser;
290
291  void Set(const RTCPUtility::RTCPPacketPSFBSLIItem& sli_item) {
292    sli_item_ = sli_item;
293    ++num_packets_;
294  }
295
296  RTCPUtility::RTCPPacketPSFBSLIItem sli_item_;
297};
298
299class Fir : public PacketType {
300 public:
301  Fir() {}
302  virtual ~Fir() {}
303
304  uint32_t Ssrc() const { return fir_.SenderSSRC; }
305
306 private:
307  friend class RtcpPacketParser;
308
309  void Set(const RTCPUtility::RTCPPacketPSFBFIR& fir) {
310    fir_ = fir;
311    ++num_packets_;
312  }
313
314  RTCPUtility::RTCPPacketPSFBFIR fir_;
315};
316
317class FirItem : public PacketType {
318 public:
319  FirItem() {}
320  virtual ~FirItem() {}
321
322  uint32_t Ssrc() const { return fir_item_.SSRC; }
323  uint8_t SeqNum() const { return fir_item_.CommandSequenceNumber; }
324
325 private:
326  friend class RtcpPacketParser;
327
328  void Set(const RTCPUtility::RTCPPacketPSFBFIRItem& fir_item) {
329    fir_item_ = fir_item;
330    ++num_packets_;
331  }
332
333  RTCPUtility::RTCPPacketPSFBFIRItem fir_item_;
334};
335
336class Nack : public PacketType {
337 public:
338  Nack() {}
339  virtual ~Nack() {}
340
341  uint32_t Ssrc() const { return nack_.SenderSSRC; }
342  uint32_t MediaSsrc() const { return nack_.MediaSSRC; }
343
344 private:
345  friend class RtcpPacketParser;
346
347  void Set(const RTCPUtility::RTCPPacketRTPFBNACK& nack) {
348    nack_ = nack;
349    ++num_packets_;
350  }
351
352  RTCPUtility::RTCPPacketRTPFBNACK nack_;
353};
354
355class NackItem : public PacketType {
356 public:
357  NackItem() {}
358  virtual ~NackItem() {}
359
360  std::vector<uint16_t> last_nack_list() const {
361    return last_nack_list_;
362  }
363
364 private:
365  friend class RtcpPacketParser;
366
367  void Set(const RTCPUtility::RTCPPacketRTPFBNACKItem& nack_item) {
368    last_nack_list_.push_back(nack_item.PacketID);
369    for (int i = 0; i < 16; ++i) {
370      if (nack_item.BitMask & (1 << i)) {
371        last_nack_list_.push_back(nack_item.PacketID + i + 1);
372      }
373    }
374    ++num_packets_;
375  }
376  void Clear() { last_nack_list_.clear(); }
377
378  std::vector<uint16_t> last_nack_list_;
379};
380
381class PsfbApp : public PacketType {
382 public:
383  PsfbApp() {}
384  virtual ~PsfbApp() {}
385
386  uint32_t Ssrc() const { return psfb_app_.SenderSSRC; }
387
388 private:
389  friend class RtcpPacketParser;
390
391  void Set(const RTCPUtility::RTCPPacketPSFBAPP& psfb_app) {
392    psfb_app_ = psfb_app;
393    ++num_packets_;
394  }
395
396  RTCPUtility::RTCPPacketPSFBAPP psfb_app_;
397};
398
399class RembItem : public PacketType {
400 public:
401  RembItem() : last_bitrate_bps_(0) {}
402  virtual ~RembItem() {}
403
404  int last_bitrate_bps() const { return last_bitrate_bps_; }
405  std::vector<uint32_t> last_ssrc_list() {
406    return last_ssrc_list_;
407  }
408
409 private:
410  friend class RtcpPacketParser;
411
412  void Set(const RTCPUtility::RTCPPacketPSFBREMBItem& remb_item) {
413    last_bitrate_bps_ = remb_item.BitRate;
414    last_ssrc_list_.clear();
415    last_ssrc_list_.insert(
416        last_ssrc_list_.end(),
417        remb_item.SSRCs,
418        remb_item.SSRCs + remb_item.NumberOfSSRCs);
419    ++num_packets_;
420  }
421
422  uint32_t last_bitrate_bps_;
423  std::vector<uint32_t> last_ssrc_list_;
424};
425
426class Tmmbr : public PacketType {
427 public:
428  Tmmbr() {}
429  virtual ~Tmmbr() {}
430
431  uint32_t Ssrc() const { return tmmbr_.SenderSSRC; }
432
433 private:
434  friend class RtcpPacketParser;
435
436  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBR& tmmbr) {
437    tmmbr_ = tmmbr;
438    ++num_packets_;
439  }
440
441  RTCPUtility::RTCPPacketRTPFBTMMBR tmmbr_;
442};
443
444class TmmbrItem : public PacketType {
445 public:
446  TmmbrItem() {}
447  virtual ~TmmbrItem() {}
448
449  uint32_t Ssrc() const { return tmmbr_item_.SSRC; }
450  uint32_t BitrateKbps() const { return tmmbr_item_.MaxTotalMediaBitRate; }
451  uint32_t Overhead() const { return tmmbr_item_.MeasuredOverhead; }
452
453 private:
454  friend class RtcpPacketParser;
455
456  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBRItem& tmmbr_item) {
457    tmmbr_item_ = tmmbr_item;
458    ++num_packets_;
459  }
460
461  RTCPUtility::RTCPPacketRTPFBTMMBRItem tmmbr_item_;
462};
463
464
465class Tmmbn : public PacketType {
466 public:
467  Tmmbn() {}
468  virtual ~Tmmbn() {}
469
470  uint32_t Ssrc() const { return tmmbn_.SenderSSRC; }
471
472 private:
473  friend class RtcpPacketParser;
474
475  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBN& tmmbn) {
476    tmmbn_ = tmmbn;
477    ++num_packets_;
478  }
479
480  RTCPUtility::RTCPPacketRTPFBTMMBN tmmbn_;
481};
482
483class TmmbnItems : public PacketType {
484 public:
485  TmmbnItems() {}
486  virtual ~TmmbnItems() {}
487
488  uint32_t Ssrc(uint8_t num) const {
489    assert(num < tmmbns_.size());
490    return tmmbns_[num].SSRC;
491  }
492  uint32_t BitrateKbps(uint8_t num) const {
493    assert(num < tmmbns_.size());
494    return tmmbns_[num].MaxTotalMediaBitRate;
495  }
496  uint32_t Overhead(uint8_t num) const {
497    assert(num < tmmbns_.size());
498    return tmmbns_[num].MeasuredOverhead;
499  }
500
501 private:
502  friend class RtcpPacketParser;
503
504  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBNItem& tmmbn_item) {
505    tmmbns_.push_back(tmmbn_item);
506    ++num_packets_;
507  }
508  void Clear() { tmmbns_.clear(); }
509
510  std::vector<RTCPUtility::RTCPPacketRTPFBTMMBNItem> tmmbns_;
511};
512
513class XrHeader : public PacketType {
514 public:
515  XrHeader() {}
516  virtual ~XrHeader() {}
517
518  uint32_t Ssrc() const { return xr_header_.OriginatorSSRC; }
519
520 private:
521  friend class RtcpPacketParser;
522
523  void Set(const RTCPUtility::RTCPPacketXR& xr_header) {
524    xr_header_ = xr_header;
525    ++num_packets_;
526  }
527
528  RTCPUtility::RTCPPacketXR xr_header_;
529};
530
531class Rrtr : public PacketType {
532 public:
533  Rrtr() {}
534  virtual ~Rrtr() {}
535
536  uint32_t NtpSec() const { return rrtr_.NTPMostSignificant; }
537  uint32_t NtpFrac() const { return rrtr_.NTPLeastSignificant; }
538
539 private:
540  friend class RtcpPacketParser;
541
542  void Set(const RTCPUtility::RTCPPacketXRReceiverReferenceTimeItem& rrtr) {
543    rrtr_ = rrtr;
544    ++num_packets_;
545  }
546
547  RTCPUtility::RTCPPacketXRReceiverReferenceTimeItem rrtr_;
548};
549
550class Dlrr : public PacketType {
551 public:
552  Dlrr() {}
553  virtual ~Dlrr() {}
554
555 private:
556  friend class RtcpPacketParser;
557
558  void Set() { ++num_packets_; }
559};
560
561class DlrrItems : public PacketType {
562 public:
563  DlrrItems() {}
564  virtual ~DlrrItems() {}
565
566  uint32_t Ssrc(uint8_t num) const {
567    assert(num < dlrrs_.size());
568    return dlrrs_[num].SSRC;
569  }
570  uint32_t LastRr(uint8_t num) const {
571    assert(num < dlrrs_.size());
572    return dlrrs_[num].LastRR;
573  }
574  uint32_t DelayLastRr(uint8_t num) const {
575    assert(num < dlrrs_.size());
576    return dlrrs_[num].DelayLastRR;
577  }
578
579 private:
580  friend class RtcpPacketParser;
581
582  void Set(const RTCPUtility::RTCPPacketXRDLRRReportBlockItem& dlrr) {
583    dlrrs_.push_back(dlrr);
584    ++num_packets_;
585  }
586  void Clear() { dlrrs_.clear(); }
587
588  std::vector<RTCPUtility::RTCPPacketXRDLRRReportBlockItem> dlrrs_;
589};
590
591class VoipMetric : public PacketType {
592 public:
593  VoipMetric() {}
594  virtual ~VoipMetric() {}
595
596  uint32_t Ssrc() const { return voip_metric_.SSRC; }
597  uint8_t LossRate() { return voip_metric_.lossRate; }
598  uint8_t DiscardRate() { return voip_metric_.discardRate; }
599  uint8_t BurstDensity() { return voip_metric_.burstDensity; }
600  uint8_t GapDensity() { return voip_metric_.gapDensity; }
601  uint16_t BurstDuration() { return voip_metric_.burstDuration; }
602  uint16_t GapDuration() { return voip_metric_.gapDuration; }
603  uint16_t RoundTripDelay() { return voip_metric_.roundTripDelay; }
604  uint16_t EndSystemDelay() { return voip_metric_.endSystemDelay; }
605  uint8_t SignalLevel() { return voip_metric_.signalLevel; }
606  uint8_t NoiseLevel() { return voip_metric_.noiseLevel; }
607  uint8_t Rerl() { return voip_metric_.RERL; }
608  uint8_t Gmin() { return voip_metric_.Gmin; }
609  uint8_t Rfactor() { return voip_metric_.Rfactor; }
610  uint8_t ExtRfactor() { return voip_metric_.extRfactor; }
611  uint8_t MosLq() { return voip_metric_.MOSLQ; }
612  uint8_t MosCq() { return voip_metric_.MOSCQ; }
613  uint8_t RxConfig() { return voip_metric_.RXconfig; }
614  uint16_t JbNominal() { return voip_metric_.JBnominal; }
615  uint16_t JbMax() { return voip_metric_.JBmax; }
616  uint16_t JbAbsMax() { return voip_metric_.JBabsMax; }
617
618 private:
619  friend class RtcpPacketParser;
620
621  void Set(const RTCPUtility::RTCPPacketXRVOIPMetricItem& voip_metric) {
622    voip_metric_ = voip_metric;
623    ++num_packets_;
624  }
625
626  RTCPUtility::RTCPPacketXRVOIPMetricItem voip_metric_;
627};
628
629class RtcpPacketParser {
630 public:
631  RtcpPacketParser();
632  ~RtcpPacketParser();
633
634  void Parse(const void *packet, int packet_len);
635
636  SenderReport* sender_report() { return &sender_report_; }
637  ReceiverReport* receiver_report() { return &receiver_report_; }
638  ReportBlock* report_block() { return &report_block_; }
639  Sdes* sdes() { return &sdes_; }
640  SdesChunk* sdes_chunk() { return &sdes_chunk_; }
641  Bye* bye() { return &bye_; }
642  App* app() { return &app_; }
643  AppItem* app_item() { return &app_item_; }
644  Ij* ij() { return &ij_; }
645  IjItem* ij_item() { return &ij_item_; }
646  Pli* pli() { return &pli_; }
647  Sli* sli() { return &sli_; }
648  SliItem* sli_item() { return &sli_item_; }
649  Rpsi* rpsi() { return &rpsi_; }
650  Fir* fir() { return &fir_; }
651  FirItem* fir_item() { return &fir_item_; }
652  Nack* nack() { return &nack_; }
653  NackItem* nack_item() { return &nack_item_; }
654  PsfbApp* psfb_app() { return &psfb_app_; }
655  RembItem* remb_item() { return &remb_item_; }
656  Tmmbr* tmmbr() { return &tmmbr_; }
657  TmmbrItem* tmmbr_item() { return &tmmbr_item_; }
658  Tmmbn* tmmbn() { return &tmmbn_; }
659  TmmbnItems* tmmbn_items() { return &tmmbn_items_; }
660  XrHeader* xr_header() { return &xr_header_; }
661  Rrtr* rrtr() { return &rrtr_; }
662  Dlrr* dlrr() { return &dlrr_; }
663  DlrrItems* dlrr_items() { return &dlrr_items_; }
664  VoipMetric* voip_metric() { return &voip_metric_; }
665
666  int report_blocks_per_ssrc(uint32_t ssrc) {
667    return report_blocks_per_ssrc_[ssrc];
668  }
669
670 private:
671  SenderReport sender_report_;
672  ReceiverReport receiver_report_;
673  ReportBlock report_block_;
674  Sdes sdes_;
675  SdesChunk sdes_chunk_;
676  Bye bye_;
677  App app_;
678  AppItem app_item_;
679  Ij ij_;
680  IjItem ij_item_;
681  Pli pli_;
682  Sli sli_;
683  SliItem sli_item_;
684  Rpsi rpsi_;
685  Fir fir_;
686  FirItem fir_item_;
687  Nack nack_;
688  NackItem nack_item_;
689  PsfbApp psfb_app_;
690  RembItem remb_item_;
691  Tmmbr tmmbr_;
692  TmmbrItem tmmbr_item_;
693  Tmmbn tmmbn_;
694  TmmbnItems tmmbn_items_;
695  XrHeader xr_header_;
696  Rrtr rrtr_;
697  Dlrr dlrr_;
698  DlrrItems dlrr_items_;
699  VoipMetric voip_metric_;
700
701  std::map<uint32_t, int> report_blocks_per_ssrc_;
702};
703}  // namespace test
704}  // namespace webrtc
705#endif  // WEBRTC_TEST_RTCP_PACKET_PARSER_H_
706