receive_statistics_unittest.cc (36948B)
1 /* 2 * Copyright (c) 2013 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 #include "modules/rtp_rtcp/include/receive_statistics.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <memory> 16 #include <vector> 17 18 #include "api/units/time_delta.h" 19 #include "api/units/timestamp.h" 20 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 21 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" 22 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 23 #include "rtc_base/checks.h" 24 #include "system_wrappers/include/clock.h" 25 #include "test/gmock.h" 26 #include "test/gtest.h" 27 28 namespace webrtc { 29 namespace { 30 31 using ::testing::SizeIs; 32 using ::testing::UnorderedElementsAre; 33 34 constexpr size_t kPacketSize1 = 100; 35 constexpr size_t kPacketSize2 = 300; 36 constexpr uint32_t kSsrc1 = 101; 37 constexpr uint32_t kSsrc2 = 202; 38 constexpr uint32_t kSsrc3 = 203; 39 constexpr uint32_t kSsrc4 = 304; 40 41 RtpPacketReceived CreateRtpPacket(uint32_t ssrc, 42 size_t header_size, 43 size_t payload_size, 44 size_t padding_size) { 45 RtpPacketReceived packet; 46 packet.SetSsrc(ssrc); 47 packet.SetSequenceNumber(100); 48 packet.set_payload_type_frequency(90000); 49 RTC_CHECK_GE(header_size, 12); 50 RTC_CHECK_EQ(header_size % 4, 0); 51 if (header_size > 12) { 52 // Insert csrcs to increase header size. 53 const int num_csrcs = (header_size - 12) / 4; 54 std::vector<uint32_t> csrcs(num_csrcs); 55 packet.SetCsrcs(csrcs); 56 } 57 packet.SetPayloadSize(payload_size); 58 packet.SetPadding(padding_size); 59 return packet; 60 } 61 62 RtpPacketReceived MakeRtpPacket(int payload_type_frequency, 63 uint32_t timestamp) { 64 RtpPacketReceived packet = 65 CreateRtpPacket(kSsrc1, 66 /*header_size=*/12, kPacketSize1 - 12, 67 /*padding_size=*/0); 68 packet.SetTimestamp(timestamp); 69 packet.set_payload_type_frequency(payload_type_frequency); 70 return packet; 71 } 72 73 RtpPacketReceived MakeNextRtpPacket(const RtpPacketReceived& previous_packet, 74 int payload_type_frequency, 75 uint32_t timestamp) { 76 RtpPacketReceived packet = MakeRtpPacket(payload_type_frequency, timestamp); 77 packet.SetSequenceNumber(previous_packet.SequenceNumber() + 1); 78 return packet; 79 } 80 81 RtpPacketReceived CreateRtpPacket(uint32_t ssrc, size_t packet_size) { 82 return CreateRtpPacket(ssrc, 12, packet_size - 12, 0); 83 } 84 85 void IncrementSequenceNumber(RtpPacketReceived* packet, uint16_t incr) { 86 packet->SetSequenceNumber(packet->SequenceNumber() + incr); 87 } 88 89 void IncrementSequenceNumber(RtpPacketReceived* packet) { 90 IncrementSequenceNumber(packet, 1); 91 } 92 93 uint32_t GetJitter(const ReceiveStatistics& stats) { 94 return stats.GetStatistician(kSsrc1)->GetStats().jitter; 95 } 96 97 class ReceiveStatisticsTest : public ::testing::TestWithParam<bool> { 98 public: 99 ReceiveStatisticsTest() 100 : clock_(0), 101 receive_statistics_( 102 GetParam() ? ReceiveStatistics::Create(&clock_) 103 : ReceiveStatistics::CreateThreadCompatible(&clock_)) { 104 packet1_ = CreateRtpPacket(kSsrc1, kPacketSize1); 105 packet2_ = CreateRtpPacket(kSsrc2, kPacketSize2); 106 } 107 108 protected: 109 SimulatedClock clock_; 110 std::unique_ptr<ReceiveStatistics> receive_statistics_; 111 RtpPacketReceived packet1_; 112 RtpPacketReceived packet2_; 113 }; 114 115 INSTANTIATE_TEST_SUITE_P(All, 116 ReceiveStatisticsTest, 117 ::testing::Bool(), 118 [](::testing::TestParamInfo<bool> info) { 119 return info.param ? "WithMutex" : "WithoutMutex"; 120 }); 121 122 TEST_P(ReceiveStatisticsTest, TwoIncomingSsrcs) { 123 receive_statistics_->OnRtpPacket(packet1_); 124 IncrementSequenceNumber(&packet1_); 125 receive_statistics_->OnRtpPacket(packet2_); 126 IncrementSequenceNumber(&packet2_); 127 clock_.AdvanceTimeMilliseconds(100); 128 receive_statistics_->OnRtpPacket(packet1_); 129 IncrementSequenceNumber(&packet1_); 130 receive_statistics_->OnRtpPacket(packet2_); 131 IncrementSequenceNumber(&packet2_); 132 133 StreamStatistician* statistician = 134 receive_statistics_->GetStatistician(kSsrc1); 135 ASSERT_TRUE(statistician != nullptr); 136 EXPECT_GT(statistician->BitrateReceived(), 0u); 137 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters(); 138 EXPECT_EQ(176u, counters.transmitted.payload_bytes); 139 EXPECT_EQ(24u, counters.transmitted.header_bytes); 140 EXPECT_EQ(0u, counters.transmitted.padding_bytes); 141 EXPECT_EQ(2u, counters.transmitted.packets); 142 143 statistician = receive_statistics_->GetStatistician(kSsrc2); 144 ASSERT_TRUE(statistician != nullptr); 145 EXPECT_GT(statistician->BitrateReceived(), 0u); 146 counters = statistician->GetReceiveStreamDataCounters(); 147 EXPECT_EQ(576u, counters.transmitted.payload_bytes); 148 EXPECT_EQ(24u, counters.transmitted.header_bytes); 149 EXPECT_EQ(0u, counters.transmitted.padding_bytes); 150 EXPECT_EQ(2u, counters.transmitted.packets); 151 152 EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size()); 153 // Add more incoming packets and verify that they are registered in both 154 // access methods. 155 receive_statistics_->OnRtpPacket(packet1_); 156 IncrementSequenceNumber(&packet1_); 157 receive_statistics_->OnRtpPacket(packet2_); 158 IncrementSequenceNumber(&packet2_); 159 160 counters = receive_statistics_->GetStatistician(kSsrc1) 161 ->GetReceiveStreamDataCounters(); 162 EXPECT_EQ(264u, counters.transmitted.payload_bytes); 163 EXPECT_EQ(36u, counters.transmitted.header_bytes); 164 EXPECT_EQ(0u, counters.transmitted.padding_bytes); 165 EXPECT_EQ(3u, counters.transmitted.packets); 166 167 counters = receive_statistics_->GetStatistician(kSsrc2) 168 ->GetReceiveStreamDataCounters(); 169 EXPECT_EQ(864u, counters.transmitted.payload_bytes); 170 EXPECT_EQ(36u, counters.transmitted.header_bytes); 171 EXPECT_EQ(0u, counters.transmitted.padding_bytes); 172 EXPECT_EQ(3u, counters.transmitted.packets); 173 } 174 175 TEST_P(ReceiveStatisticsTest, 176 RtcpReportBlocksReturnsMaxBlocksWhenThereAreMoreStatisticians) { 177 RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1); 178 RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1); 179 RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1); 180 receive_statistics_->OnRtpPacket(packet1); 181 receive_statistics_->OnRtpPacket(packet2); 182 receive_statistics_->OnRtpPacket(packet3); 183 184 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2)); 185 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2)); 186 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2)); 187 } 188 189 TEST_P(ReceiveStatisticsTest, 190 RtcpReportBlocksReturnsAllObservedSsrcsWithMultipleCalls) { 191 RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1); 192 RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1); 193 RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1); 194 RtpPacketReceived packet4 = CreateRtpPacket(kSsrc4, kPacketSize1); 195 receive_statistics_->OnRtpPacket(packet1); 196 receive_statistics_->OnRtpPacket(packet2); 197 receive_statistics_->OnRtpPacket(packet3); 198 receive_statistics_->OnRtpPacket(packet4); 199 200 std::vector<uint32_t> observed_ssrcs; 201 std::vector<rtcp::ReportBlock> report_blocks = 202 receive_statistics_->RtcpReportBlocks(2); 203 ASSERT_THAT(report_blocks, SizeIs(2)); 204 observed_ssrcs.push_back(report_blocks[0].source_ssrc()); 205 observed_ssrcs.push_back(report_blocks[1].source_ssrc()); 206 207 report_blocks = receive_statistics_->RtcpReportBlocks(2); 208 ASSERT_THAT(report_blocks, SizeIs(2)); 209 observed_ssrcs.push_back(report_blocks[0].source_ssrc()); 210 observed_ssrcs.push_back(report_blocks[1].source_ssrc()); 211 212 EXPECT_THAT(observed_ssrcs, 213 UnorderedElementsAre(kSsrc1, kSsrc2, kSsrc3, kSsrc4)); 214 } 215 216 TEST_P(ReceiveStatisticsTest, ActiveStatisticians) { 217 receive_statistics_->OnRtpPacket(packet1_); 218 IncrementSequenceNumber(&packet1_); 219 clock_.AdvanceTimeMilliseconds(1000); 220 receive_statistics_->OnRtpPacket(packet2_); 221 IncrementSequenceNumber(&packet2_); 222 // Nothing should time out since only 1000 ms has passed since the first 223 // packet came in. 224 EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size()); 225 226 clock_.AdvanceTimeMilliseconds(7000); 227 // kSsrc1 should have timed out. 228 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size()); 229 230 clock_.AdvanceTimeMilliseconds(1000); 231 // kSsrc2 should have timed out. 232 EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size()); 233 234 receive_statistics_->OnRtpPacket(packet1_); 235 IncrementSequenceNumber(&packet1_); 236 // kSsrc1 should be active again and the data counters should have survived. 237 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size()); 238 StreamStatistician* statistician = 239 receive_statistics_->GetStatistician(kSsrc1); 240 ASSERT_TRUE(statistician != nullptr); 241 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters(); 242 EXPECT_EQ(176u, counters.transmitted.payload_bytes); 243 EXPECT_EQ(24u, counters.transmitted.header_bytes); 244 EXPECT_EQ(0u, counters.transmitted.padding_bytes); 245 EXPECT_EQ(2u, counters.transmitted.packets); 246 } 247 248 TEST_P(ReceiveStatisticsTest, 249 DoesntCreateRtcpReportBlockUntilFirstReceivedPacketForSsrc) { 250 // Creates a statistician object for the ssrc. 251 receive_statistics_->EnableRetransmitDetection(kSsrc1, true); 252 EXPECT_TRUE(receive_statistics_->GetStatistician(kSsrc1) != nullptr); 253 EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size()); 254 // Receive first packet 255 receive_statistics_->OnRtpPacket(packet1_); 256 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size()); 257 } 258 259 TEST_P(ReceiveStatisticsTest, GetReceiveStreamDataCounters) { 260 receive_statistics_->OnRtpPacket(packet1_); 261 StreamStatistician* statistician = 262 receive_statistics_->GetStatistician(kSsrc1); 263 ASSERT_TRUE(statistician != nullptr); 264 265 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters(); 266 EXPECT_TRUE(counters.first_packet_time.IsFinite()); 267 EXPECT_EQ(1u, counters.transmitted.packets); 268 269 receive_statistics_->OnRtpPacket(packet1_); 270 counters = statistician->GetReceiveStreamDataCounters(); 271 EXPECT_TRUE(counters.first_packet_time.IsFinite()); 272 EXPECT_EQ(2u, counters.transmitted.packets); 273 } 274 275 TEST_P(ReceiveStatisticsTest, SimpleLossComputation) { 276 packet1_.SetSequenceNumber(1); 277 receive_statistics_->OnRtpPacket(packet1_); 278 packet1_.SetSequenceNumber(3); 279 receive_statistics_->OnRtpPacket(packet1_); 280 packet1_.SetSequenceNumber(4); 281 receive_statistics_->OnRtpPacket(packet1_); 282 packet1_.SetSequenceNumber(5); 283 receive_statistics_->OnRtpPacket(packet1_); 284 285 std::vector<rtcp::ReportBlock> report_blocks = 286 receive_statistics_->RtcpReportBlocks(1); 287 ASSERT_THAT(report_blocks, SizeIs(1)); 288 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 289 290 // 20% = 51/255. 291 EXPECT_EQ(51u, report_blocks[0].fraction_lost()); 292 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 293 StreamStatistician* statistician = 294 receive_statistics_->GetStatistician(kSsrc1); 295 EXPECT_EQ(20, statistician->GetFractionLostInPercent()); 296 } 297 298 TEST_P(ReceiveStatisticsTest, LossComputationWithReordering) { 299 packet1_.SetSequenceNumber(1); 300 receive_statistics_->OnRtpPacket(packet1_); 301 packet1_.SetSequenceNumber(3); 302 receive_statistics_->OnRtpPacket(packet1_); 303 packet1_.SetSequenceNumber(2); 304 receive_statistics_->OnRtpPacket(packet1_); 305 packet1_.SetSequenceNumber(5); 306 receive_statistics_->OnRtpPacket(packet1_); 307 308 std::vector<rtcp::ReportBlock> report_blocks = 309 receive_statistics_->RtcpReportBlocks(1); 310 ASSERT_THAT(report_blocks, SizeIs(1)); 311 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 312 313 // 20% = 51/255. 314 EXPECT_EQ(51u, report_blocks[0].fraction_lost()); 315 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 316 StreamStatistician* statistician = 317 receive_statistics_->GetStatistician(kSsrc1); 318 EXPECT_EQ(20, statistician->GetFractionLostInPercent()); 319 } 320 321 TEST_P(ReceiveStatisticsTest, LossComputationWithDuplicates) { 322 // Lose 2 packets, but also receive 1 duplicate. Should actually count as 323 // only 1 packet being lost. 324 packet1_.SetSequenceNumber(1); 325 receive_statistics_->OnRtpPacket(packet1_); 326 packet1_.SetSequenceNumber(4); 327 receive_statistics_->OnRtpPacket(packet1_); 328 packet1_.SetSequenceNumber(4); 329 receive_statistics_->OnRtpPacket(packet1_); 330 packet1_.SetSequenceNumber(5); 331 receive_statistics_->OnRtpPacket(packet1_); 332 333 std::vector<rtcp::ReportBlock> report_blocks = 334 receive_statistics_->RtcpReportBlocks(1); 335 ASSERT_THAT(report_blocks, SizeIs(1)); 336 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 337 338 // 20% = 51/255. 339 EXPECT_EQ(51u, report_blocks[0].fraction_lost()); 340 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 341 StreamStatistician* statistician = 342 receive_statistics_->GetStatistician(kSsrc1); 343 EXPECT_EQ(20, statistician->GetFractionLostInPercent()); 344 } 345 346 TEST_P(ReceiveStatisticsTest, LossComputationWithSequenceNumberWrapping) { 347 // First, test loss computation over a period that included a sequence number 348 // rollover. 349 packet1_.SetSequenceNumber(0xfffd); 350 receive_statistics_->OnRtpPacket(packet1_); 351 packet1_.SetSequenceNumber(0); 352 receive_statistics_->OnRtpPacket(packet1_); 353 packet1_.SetSequenceNumber(0xfffe); 354 receive_statistics_->OnRtpPacket(packet1_); 355 packet1_.SetSequenceNumber(1); 356 receive_statistics_->OnRtpPacket(packet1_); 357 358 // Only one packet was actually lost, 0xffff. 359 std::vector<rtcp::ReportBlock> report_blocks = 360 receive_statistics_->RtcpReportBlocks(1); 361 ASSERT_THAT(report_blocks, SizeIs(1)); 362 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 363 364 // 20% = 51/255. 365 EXPECT_EQ(51u, report_blocks[0].fraction_lost()); 366 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 367 StreamStatistician* statistician = 368 receive_statistics_->GetStatistician(kSsrc1); 369 EXPECT_EQ(20, statistician->GetFractionLostInPercent()); 370 371 // Now test losing one packet *after* the rollover. 372 packet1_.SetSequenceNumber(3); 373 receive_statistics_->OnRtpPacket(packet1_); 374 375 report_blocks = receive_statistics_->RtcpReportBlocks(1); 376 ASSERT_THAT(report_blocks, SizeIs(1)); 377 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 378 379 // 50% = 127/255. 380 EXPECT_EQ(127u, report_blocks[0].fraction_lost()); 381 EXPECT_EQ(2, report_blocks[0].cumulative_lost()); 382 // 2 packets lost, 7 expected 383 EXPECT_EQ(28, statistician->GetFractionLostInPercent()); 384 } 385 386 TEST_P(ReceiveStatisticsTest, StreamRestartDoesntCountAsLoss) { 387 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200); 388 389 packet1_.SetSequenceNumber(0); 390 receive_statistics_->OnRtpPacket(packet1_); 391 packet1_.SetSequenceNumber(1); 392 receive_statistics_->OnRtpPacket(packet1_); 393 394 packet1_.SetSequenceNumber(400); 395 receive_statistics_->OnRtpPacket(packet1_); 396 397 std::vector<rtcp::ReportBlock> report_blocks = 398 receive_statistics_->RtcpReportBlocks(1); 399 ASSERT_THAT(report_blocks, SizeIs(1)); 400 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 401 402 EXPECT_EQ(0, report_blocks[0].fraction_lost()); 403 EXPECT_EQ(0, report_blocks[0].cumulative_lost()); 404 StreamStatistician* statistician = 405 receive_statistics_->GetStatistician(kSsrc1); 406 EXPECT_EQ(0, statistician->GetFractionLostInPercent()); 407 408 packet1_.SetSequenceNumber(401); 409 receive_statistics_->OnRtpPacket(packet1_); 410 report_blocks = receive_statistics_->RtcpReportBlocks(1); 411 ASSERT_THAT(report_blocks, SizeIs(1)); 412 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 413 414 EXPECT_EQ(0, report_blocks[0].fraction_lost()); 415 EXPECT_EQ(0, report_blocks[0].cumulative_lost()); 416 EXPECT_EQ(0, statistician->GetFractionLostInPercent()); 417 } 418 419 TEST_P(ReceiveStatisticsTest, CountsLossAfterStreamRestart) { 420 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200); 421 422 packet1_.SetSequenceNumber(0); 423 receive_statistics_->OnRtpPacket(packet1_); 424 packet1_.SetSequenceNumber(1); 425 receive_statistics_->OnRtpPacket(packet1_); 426 427 packet1_.SetSequenceNumber(400); 428 receive_statistics_->OnRtpPacket(packet1_); 429 packet1_.SetSequenceNumber(401); 430 receive_statistics_->OnRtpPacket(packet1_); 431 packet1_.SetSequenceNumber(403); 432 receive_statistics_->OnRtpPacket(packet1_); 433 434 std::vector<rtcp::ReportBlock> report_blocks = 435 receive_statistics_->RtcpReportBlocks(1); 436 ASSERT_THAT(report_blocks, SizeIs(1)); 437 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 438 439 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 440 441 StreamStatistician* statistician = 442 receive_statistics_->GetStatistician(kSsrc1); 443 // Is this reasonable? */ 444 EXPECT_EQ(0, statistician->GetFractionLostInPercent()); 445 } 446 447 TEST_P(ReceiveStatisticsTest, StreamCanRestartAtSequenceNumberWrapAround) { 448 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200); 449 450 packet1_.SetSequenceNumber(0xffff - 401); 451 receive_statistics_->OnRtpPacket(packet1_); 452 packet1_.SetSequenceNumber(0xffff - 400); 453 receive_statistics_->OnRtpPacket(packet1_); 454 455 packet1_.SetSequenceNumber(0xffff); 456 receive_statistics_->OnRtpPacket(packet1_); 457 packet1_.SetSequenceNumber(0); 458 receive_statistics_->OnRtpPacket(packet1_); 459 packet1_.SetSequenceNumber(2); 460 receive_statistics_->OnRtpPacket(packet1_); 461 462 std::vector<rtcp::ReportBlock> report_blocks = 463 receive_statistics_->RtcpReportBlocks(1); 464 ASSERT_THAT(report_blocks, SizeIs(1)); 465 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 466 467 EXPECT_EQ(1, report_blocks[0].cumulative_lost()); 468 } 469 470 TEST_P(ReceiveStatisticsTest, StreamRestartNeedsTwoConsecutivePackets) { 471 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200); 472 473 packet1_.SetSequenceNumber(400); 474 receive_statistics_->OnRtpPacket(packet1_); 475 packet1_.SetSequenceNumber(401); 476 receive_statistics_->OnRtpPacket(packet1_); 477 478 packet1_.SetSequenceNumber(1); 479 receive_statistics_->OnRtpPacket(packet1_); 480 packet1_.SetSequenceNumber(3); 481 receive_statistics_->OnRtpPacket(packet1_); 482 483 std::vector<rtcp::ReportBlock> report_blocks = 484 receive_statistics_->RtcpReportBlocks(1); 485 ASSERT_THAT(report_blocks, SizeIs(1)); 486 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 487 488 EXPECT_EQ(401u, report_blocks[0].extended_high_seq_num()); 489 490 packet1_.SetSequenceNumber(4); 491 receive_statistics_->OnRtpPacket(packet1_); 492 493 report_blocks = receive_statistics_->RtcpReportBlocks(1); 494 ASSERT_THAT(report_blocks, SizeIs(1)); 495 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 496 497 EXPECT_EQ(4u, report_blocks[0].extended_high_seq_num()); 498 } 499 500 TEST_P(ReceiveStatisticsTest, WrapsAroundExtendedHighestSequenceNumber) { 501 packet1_.SetSequenceNumber(0xffff); 502 receive_statistics_->OnRtpPacket(packet1_); 503 504 std::vector<rtcp::ReportBlock> report_blocks = 505 receive_statistics_->RtcpReportBlocks(1); 506 ASSERT_THAT(report_blocks, SizeIs(1)); 507 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 508 509 EXPECT_EQ(0xffffu, report_blocks[0].extended_high_seq_num()); 510 511 // Wrap around. 512 packet1_.SetSequenceNumber(1); 513 receive_statistics_->OnRtpPacket(packet1_); 514 515 report_blocks = receive_statistics_->RtcpReportBlocks(1); 516 ASSERT_THAT(report_blocks, SizeIs(1)); 517 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 518 519 EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num()); 520 521 // Should be treated as out of order; shouldn't increment highest extended 522 // sequence number. 523 packet1_.SetSequenceNumber(0x10000 - 6); 524 report_blocks = receive_statistics_->RtcpReportBlocks(1); 525 ASSERT_THAT(report_blocks, SizeIs(1)); 526 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 527 528 EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num()); 529 530 // Receive a couple packets then wrap around again. 531 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200); 532 for (int i = 10; i < 0xffff; i += 150) { 533 packet1_.SetSequenceNumber(i); 534 receive_statistics_->OnRtpPacket(packet1_); 535 } 536 packet1_.SetSequenceNumber(1); 537 receive_statistics_->OnRtpPacket(packet1_); 538 report_blocks = receive_statistics_->RtcpReportBlocks(1); 539 ASSERT_THAT(report_blocks, SizeIs(1)); 540 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc()); 541 542 EXPECT_EQ(0x20001u, report_blocks[0].extended_high_seq_num()); 543 } 544 545 TEST_P(ReceiveStatisticsTest, StreamDataCounters) { 546 receive_statistics_->EnableRetransmitDetection(kSsrc1, true); 547 548 const size_t kHeaderLength = 20; 549 const size_t kPaddingLength = 9; 550 551 // One packet with payload size kPacketSize1. 552 RtpPacketReceived packet1 = 553 CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 0); 554 receive_statistics_->OnRtpPacket(packet1); 555 StreamDataCounters counters = receive_statistics_->GetStatistician(kSsrc1) 556 ->GetReceiveStreamDataCounters(); 557 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1); 558 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength); 559 EXPECT_EQ(counters.transmitted.padding_bytes, 0u); 560 EXPECT_EQ(counters.transmitted.packets, 1u); 561 EXPECT_EQ(counters.retransmitted.payload_bytes, 0u); 562 EXPECT_EQ(counters.retransmitted.header_bytes, 0u); 563 EXPECT_EQ(counters.retransmitted.padding_bytes, 0u); 564 EXPECT_EQ(counters.retransmitted.packets, 0u); 565 EXPECT_EQ(counters.fec.packets, 0u); 566 567 // Another packet of size kPacketSize1 with 9 bytes padding. 568 RtpPacketReceived packet2 = 569 CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 9); 570 packet2.SetSequenceNumber(packet1.SequenceNumber() + 1); 571 clock_.AdvanceTimeMilliseconds(5); 572 receive_statistics_->OnRtpPacket(packet2); 573 counters = receive_statistics_->GetStatistician(kSsrc1) 574 ->GetReceiveStreamDataCounters(); 575 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 2); 576 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 2); 577 EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength); 578 EXPECT_EQ(counters.transmitted.packets, 2u); 579 580 clock_.AdvanceTimeMilliseconds(5); 581 // Retransmit last packet. 582 receive_statistics_->OnRtpPacket(packet2); 583 counters = receive_statistics_->GetStatistician(kSsrc1) 584 ->GetReceiveStreamDataCounters(); 585 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 3); 586 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 3); 587 EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength * 2); 588 EXPECT_EQ(counters.transmitted.packets, 3u); 589 EXPECT_EQ(counters.retransmitted.payload_bytes, kPacketSize1); 590 EXPECT_EQ(counters.retransmitted.header_bytes, kHeaderLength); 591 EXPECT_EQ(counters.retransmitted.padding_bytes, kPaddingLength); 592 EXPECT_EQ(counters.retransmitted.packets, 1u); 593 } 594 595 TEST_P(ReceiveStatisticsTest, LastPacketReceivedTimestamp) { 596 clock_.AdvanceTimeMilliseconds(42); 597 packet1_.SetSequenceNumber(100); 598 receive_statistics_->OnRtpPacket(packet1_); 599 RtpReceiveStats counters = 600 receive_statistics_->GetStatistician(kSsrc1)->GetStats(); 601 602 EXPECT_EQ(counters.last_packet_received, Timestamp::Millis(42)); 603 604 clock_.AdvanceTimeMilliseconds(3); 605 packet1_.SetSequenceNumber(101); 606 receive_statistics_->OnRtpPacket(packet1_); 607 counters = receive_statistics_->GetStatistician(kSsrc1)->GetStats(); 608 EXPECT_EQ(counters.last_packet_received, Timestamp::Millis(45)); 609 } 610 611 TEST_P(ReceiveStatisticsTest, SimpleJitterComputation) { 612 const int kMsPerPacket = 20; 613 const int kCodecSampleRate = 48'000; 614 const int kSamplesPerPacket = kMsPerPacket * kCodecSampleRate / 1'000; 615 const int kLateArrivalDeltaMs = 100; 616 const int kLateArrivalDeltaSamples = 617 kLateArrivalDeltaMs * kCodecSampleRate / 1'000; 618 619 packet1_.set_payload_type_frequency(kCodecSampleRate); 620 packet1_.SetSequenceNumber(1); 621 packet1_.SetTimestamp(0); 622 receive_statistics_->OnRtpPacket(packet1_); 623 packet1_.SetSequenceNumber(2); 624 packet1_.SetTimestamp(kSamplesPerPacket); 625 // Arrives 100 ms late. 626 clock_.AdvanceTimeMilliseconds(kMsPerPacket + kLateArrivalDeltaMs); 627 receive_statistics_->OnRtpPacket(packet1_); 628 629 StreamStatistician* statistician = 630 receive_statistics_->GetStatistician(kSsrc1); 631 // See jitter caluculation in https://www.rfc-editor.org/rfc/rfc3550 6.4.1. 632 const uint32_t expected_jitter = (kLateArrivalDeltaSamples) / 16; 633 EXPECT_EQ(expected_jitter, statistician->GetStats().jitter); 634 EXPECT_EQ(TimeDelta::Seconds(expected_jitter) / kCodecSampleRate, 635 statistician->GetStats().interarrival_jitter); 636 } 637 638 TEST(ReviseJitterTest, AllPacketsHaveSamePayloadTypeFrequency) { 639 SimulatedClock clock(0); 640 std::unique_ptr<ReceiveStatistics> statistics = 641 ReceiveStatistics::Create(&clock); 642 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000, 643 /*timestamp=*/1); 644 RtpPacketReceived packet2 = MakeNextRtpPacket( 645 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160); 646 647 RtpPacketReceived packet3 = MakeNextRtpPacket( 648 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 2 * 160); 649 650 statistics->OnRtpPacket(packet1); 651 clock.AdvanceTimeMilliseconds(50); 652 statistics->OnRtpPacket(packet2); 653 clock.AdvanceTimeMilliseconds(50); 654 statistics->OnRtpPacket(packet3); 655 656 // packet1: no jitter calculation 657 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 658 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 659 // / 16 = 240 660 // packet3: jitter = 240[jitter] + (abs(50[receive time ms] * 661 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8) 662 // / 16 = 465 663 // final jitter: 465 / 16 = 29 664 EXPECT_EQ(GetJitter(*statistics), 29U); 665 } 666 667 TEST(ReviseJitterTest, AllPacketsHaveDifferentPayloadTypeFrequency) { 668 SimulatedClock clock(0); 669 std::unique_ptr<ReceiveStatistics> statistics = 670 ReceiveStatistics::Create(&clock); 671 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000, 672 /*timestamp=*/1); 673 RtpPacketReceived packet2 = MakeNextRtpPacket( 674 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160); 675 RtpPacketReceived packet3 = MakeNextRtpPacket( 676 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960); 677 678 statistics->OnRtpPacket(packet1); 679 clock.AdvanceTimeMilliseconds(50); 680 statistics->OnRtpPacket(packet2); 681 clock.AdvanceTimeMilliseconds(50); 682 statistics->OnRtpPacket(packet3); 683 684 // packet1: no jitter calculation 685 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 686 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 687 // / 16 = 240 688 // packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440 689 // jitter = 1'440[jitter] + (abs(50[receive time ms] * 690 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8) 691 // / 16 = 2'790 692 // final jitter: 2'790 / 16 = 174 693 EXPECT_EQ(GetJitter(*statistics), 174U); 694 } 695 696 TEST(ReviseJitterTest, 697 FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) { 698 SimulatedClock clock(0); 699 std::unique_ptr<ReceiveStatistics> statistics = 700 ReceiveStatistics::Create(&clock); 701 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0, 702 /*timestamp=*/1); 703 RtpPacketReceived packet2 = MakeNextRtpPacket( 704 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160); 705 RtpPacketReceived packet3 = MakeNextRtpPacket( 706 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960); 707 708 statistics->OnRtpPacket(packet1); 709 clock.AdvanceTimeMilliseconds(50); 710 statistics->OnRtpPacket(packet2); 711 clock.AdvanceTimeMilliseconds(50); 712 statistics->OnRtpPacket(packet3); 713 714 // packet1: no jitter calculation 715 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 716 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 717 // / 16 = 240 718 // packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440 719 // jitter = 1'440[jitter] + (abs(50[receive time ms] * 720 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8) 721 // / 16 = 2'790 722 // final jitter: 2'790 / 16 = 174 723 EXPECT_EQ(GetJitter(*statistics), 174U); 724 } 725 726 TEST(ReviseJitterTest, 727 FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) { 728 SimulatedClock clock(0); 729 std::unique_ptr<ReceiveStatistics> statistics = 730 ReceiveStatistics::Create(&clock); 731 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0, 732 /*timestamp=*/1); 733 RtpPacketReceived packet2 = MakeNextRtpPacket( 734 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160); 735 RtpPacketReceived packet3 = MakeNextRtpPacket( 736 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160); 737 738 statistics->OnRtpPacket(packet1); 739 clock.AdvanceTimeMilliseconds(50); 740 statistics->OnRtpPacket(packet2); 741 clock.AdvanceTimeMilliseconds(50); 742 statistics->OnRtpPacket(packet3); 743 744 // packet1: no jitter calculation 745 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 746 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 747 // / 16 = 240 748 // packet3: jitter = 240[jitter] + (abs(50[receive time ms] * 749 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8) 750 // / 16 = 465 751 // final jitter: 465 / 16 = 29 752 EXPECT_EQ(GetJitter(*statistics), 29U); 753 } 754 755 TEST(ReviseJitterTest, 756 TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) { 757 SimulatedClock clock(0); 758 std::unique_ptr<ReceiveStatistics> statistics = 759 ReceiveStatistics::Create(&clock); 760 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0, 761 /*timestamp=*/1); 762 RtpPacketReceived packet2 = MakeNextRtpPacket( 763 packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160); 764 RtpPacketReceived packet3 = MakeNextRtpPacket( 765 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960); 766 RtpPacketReceived packet4 = 767 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000, 768 /*timestamp=*/1 + 160 + 960 + 160); 769 770 statistics->OnRtpPacket(packet1); 771 clock.AdvanceTimeMilliseconds(50); 772 statistics->OnRtpPacket(packet2); 773 clock.AdvanceTimeMilliseconds(50); 774 statistics->OnRtpPacket(packet3); 775 clock.AdvanceTimeMilliseconds(50); 776 statistics->OnRtpPacket(packet4); 777 778 // packet1: no jitter calculation 779 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 780 // 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 781 // / 16 = 160 782 // packet3: jitter = 160[jitter] + (abs(50[receive time ms] * 783 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 160[jitter] + 8) 784 // / 16 = 1'590 785 // packet4: revised jitter: 1'590 * 8[frequency KHz] / 48[frequency KHz] = 265 786 // packet4: jitter = 265[jitter] + (abs(50[receive time ms] * 787 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 265[jitter] + 8) 788 // / 16 = 488 789 // final jitter: 488 / 16 = 30 790 EXPECT_EQ(GetJitter(*statistics), 30U); 791 } 792 793 TEST(ReviseJitterTest, 794 TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) { 795 SimulatedClock clock(0); 796 std::unique_ptr<ReceiveStatistics> statistics = 797 ReceiveStatistics::Create(&clock); 798 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0, 799 /*timestamp=*/1); 800 RtpPacketReceived packet2 = MakeNextRtpPacket( 801 packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160); 802 RtpPacketReceived packet3 = MakeNextRtpPacket( 803 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160); 804 RtpPacketReceived packet4 = 805 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000, 806 /*timestamp=*/1 + 160 + 160 + 160); 807 808 statistics->OnRtpPacket(packet1); 809 clock.AdvanceTimeMilliseconds(50); 810 statistics->OnRtpPacket(packet2); 811 clock.AdvanceTimeMilliseconds(50); 812 statistics->OnRtpPacket(packet3); 813 clock.AdvanceTimeMilliseconds(50); 814 statistics->OnRtpPacket(packet4); 815 816 // packet1: no jitter calculation 817 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 818 // 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8) 819 // / 16 = 160 820 // packet3: jitter = 160[jitter] + (abs(50[receive time ms] * 821 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 160[jitter] + 8) 822 // / 16 = 390 823 // packet4: jitter = 390[jitter] + (abs(50[receive time ms] * 824 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 390[jitter] + 8) 825 // / 16 = 606 826 // final jitter: 606 / 16 = 37 827 EXPECT_EQ(GetJitter(*statistics), 37U); 828 } 829 830 TEST(ReviseJitterTest, 831 MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) { 832 SimulatedClock clock(0); 833 std::unique_ptr<ReceiveStatistics> statistics = 834 ReceiveStatistics::Create(&clock); 835 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000, 836 /*timestamp=*/1); 837 RtpPacketReceived packet2 = MakeNextRtpPacket( 838 packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960); 839 RtpPacketReceived packet3 = MakeNextRtpPacket( 840 packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55); 841 RtpPacketReceived packet4 = 842 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000, 843 /*timestamp=*/1 + 960 + 55 + 160); 844 845 statistics->OnRtpPacket(packet1); 846 clock.AdvanceTimeMilliseconds(50); 847 statistics->OnRtpPacket(packet2); 848 clock.AdvanceTimeMilliseconds(50); 849 statistics->OnRtpPacket(packet3); 850 clock.AdvanceTimeMilliseconds(50); 851 statistics->OnRtpPacket(packet4); 852 853 // packet1: no jitter calculation 854 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 855 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8) 856 // / 16 = 1'440 857 // packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] * 858 // 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8) 859 // / 16 = 1'405 860 // packet4: revised jitter: 1'405 * 8[frequency KHz] / 48[frequency KHz] = 234 861 // jitter = 234[jitter] + (abs(50[receive time ms] * 862 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 234[jitter] + 8) 863 // / 16 = 459 864 // final jitter: 459 / 16 = 28 865 EXPECT_EQ(GetJitter(*statistics), 28U); 866 } 867 868 TEST(ReviseJitterTest, 869 MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) { 870 SimulatedClock clock(0); 871 std::unique_ptr<ReceiveStatistics> statistics = 872 ReceiveStatistics::Create(&clock); 873 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000, 874 /*timestamp=*/1); 875 RtpPacketReceived packet2 = MakeNextRtpPacket( 876 packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960); 877 RtpPacketReceived packet3 = MakeNextRtpPacket( 878 packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55); 879 RtpPacketReceived packet4 = 880 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/48'000, 881 /*timestamp=*/1 + 960 + 55 + 960); 882 883 statistics->OnRtpPacket(packet1); 884 clock.AdvanceTimeMilliseconds(50); 885 statistics->OnRtpPacket(packet2); 886 clock.AdvanceTimeMilliseconds(50); 887 statistics->OnRtpPacket(packet3); 888 clock.AdvanceTimeMilliseconds(50); 889 statistics->OnRtpPacket(packet4); 890 891 // packet1: no jitter calculation 892 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] * 893 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8) 894 // / 16 = 1'440 895 // packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] * 896 // 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8) 897 // / 16 = 1'405 898 // packet4: jitter = 1'405[jitter] + (abs(50[receive time ms] * 899 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'405[jitter] + 8) 900 // / 16 = 2'757 901 // final jitter: 2'757 / 16 = 172 902 EXPECT_EQ(GetJitter(*statistics), 172U); 903 } 904 905 TEST(ReviseJitterTest, TwoPacketsWithMaximumRtpTimestampDifference) { 906 SimulatedClock clock(0); 907 std::unique_ptr<ReceiveStatistics> statistics = 908 ReceiveStatistics::Create(&clock); 909 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/90'000, 910 /*timestamp=*/0x01234567); 911 RtpPacketReceived packet2 = 912 MakeNextRtpPacket(packet1, 913 /*payload_type_frequency=*/90'000, 914 /*timestamp=*/0x81234567); 915 statistics->OnRtpPacket(packet1); 916 statistics->OnRtpPacket(packet2); 917 918 // Expect large jump in RTP timestamp is ignored for jitter calculation. 919 EXPECT_EQ(GetJitter(*statistics), 0U); 920 } 921 922 } // namespace 923 } // namespace webrtc