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 RtcpPacketParser { 382 public: 383 RtcpPacketParser(); 384 ~RtcpPacketParser(); 385 386 void Parse(const void *packet, int packet_len); 387 388 SenderReport* sender_report() { return &sender_report_; } 389 ReceiverReport* receiver_report() { return &receiver_report_; } 390 ReportBlock* report_block() { return &report_block_; } 391 Sdes* sdes() { return &sdes_; } 392 SdesChunk* sdes_chunk() { return &sdes_chunk_; } 393 Bye* bye() { return &bye_; } 394 App* app() { return &app_; } 395 AppItem* app_item() { return &app_item_; } 396 Ij* ij() { return &ij_; } 397 IjItem* ij_item() { return &ij_item_; } 398 Pli* pli() { return &pli_; } 399 Sli* sli() { return &sli_; } 400 SliItem* sli_item() { return &sli_item_; } 401 Rpsi* rpsi() { return &rpsi_; } 402 Fir* fir() { return &fir_; } 403 FirItem* fir_item() { return &fir_item_; } 404 Nack* nack() { return &nack_; } 405 NackItem* nack_item() { return &nack_item_; } 406 407 int report_blocks_per_ssrc(uint32_t ssrc) { 408 return report_blocks_per_ssrc_[ssrc]; 409 } 410 411 private: 412 SenderReport sender_report_; 413 ReceiverReport receiver_report_; 414 ReportBlock report_block_; 415 Sdes sdes_; 416 SdesChunk sdes_chunk_; 417 Bye bye_; 418 App app_; 419 AppItem app_item_; 420 Ij ij_; 421 IjItem ij_item_; 422 Pli pli_; 423 Sli sli_; 424 SliItem sli_item_; 425 Rpsi rpsi_; 426 Fir fir_; 427 FirItem fir_item_; 428 Nack nack_; 429 NackItem nack_item_; 430 431 std::map<uint32_t, int> report_blocks_per_ssrc_; 432 }; 433 } // namespace test 434 } // namespace webrtc 435 #endif // WEBRTC_TEST_RTCP_PACKET_PARSER_H_ 436
