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 22 namespace webrtc { 23 namespace test { 24 25 class RtcpPacketParser; 26 27 class 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 39 class 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 62 class 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 80 class 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 104 class 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 115 class 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 133 class 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 144 class 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 163 class 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 181 class 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 203 class 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 222 class 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 241 class 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 260 class 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 279 class 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 299 class 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 317 class 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 336 class 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 355 class 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 381 class 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 399 class 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 426 class 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 444 class 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 465 class 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 483 class 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 513 class 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 531 class 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 550 class 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 561 class 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 591 class 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 629 class 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
