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#include <list> 12 13#include "testing/gmock/include/gmock/gmock.h" 14#include "testing/gtest/include/gtest/gtest.h" 15#include "webrtc/modules/pacing/paced_sender.h" 16#include "webrtc/system_wrappers/include/clock.h" 17 18using testing::_; 19using testing::Return; 20 21namespace webrtc { 22namespace test { 23 24static const int kTargetBitrate = 800; 25static const float kPaceMultiplier = 1.5f; 26 27class MockPacedSenderCallback : public PacedSender::Callback { 28 public: 29 MOCK_METHOD4(TimeToSendPacket, 30 bool(uint32_t ssrc, 31 uint16_t sequence_number, 32 int64_t capture_time_ms, 33 bool retransmission)); 34 MOCK_METHOD1(TimeToSendPadding, 35 size_t(size_t bytes)); 36}; 37 38class PacedSenderPadding : public PacedSender::Callback { 39 public: 40 PacedSenderPadding() : padding_sent_(0) {} 41 42 bool TimeToSendPacket(uint32_t ssrc, 43 uint16_t sequence_number, 44 int64_t capture_time_ms, 45 bool retransmission) { 46 return true; 47 } 48 49 size_t TimeToSendPadding(size_t bytes) { 50 const size_t kPaddingPacketSize = 224; 51 size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize; 52 padding_sent_ += kPaddingPacketSize * num_packets; 53 return kPaddingPacketSize * num_packets; 54 } 55 56 size_t padding_sent() { return padding_sent_; } 57 58 private: 59 size_t padding_sent_; 60}; 61 62class PacedSenderProbing : public PacedSender::Callback { 63 public: 64 PacedSenderProbing(const std::list<int>& expected_deltas, Clock* clock) 65 : prev_packet_time_ms_(-1), 66 expected_deltas_(expected_deltas), 67 packets_sent_(0), 68 clock_(clock) {} 69 70 bool TimeToSendPacket(uint32_t ssrc, 71 uint16_t sequence_number, 72 int64_t capture_time_ms, 73 bool retransmission) { 74 ExpectAndCountPacket(); 75 return true; 76 } 77 78 size_t TimeToSendPadding(size_t bytes) { 79 ExpectAndCountPacket(); 80 return bytes; 81 } 82 83 void ExpectAndCountPacket() { 84 ++packets_sent_; 85 EXPECT_FALSE(expected_deltas_.empty()); 86 if (expected_deltas_.empty()) 87 return; 88 int64_t now_ms = clock_->TimeInMilliseconds(); 89 if (prev_packet_time_ms_ >= 0) { 90 EXPECT_EQ(expected_deltas_.front(), now_ms - prev_packet_time_ms_); 91 expected_deltas_.pop_front(); 92 } 93 prev_packet_time_ms_ = now_ms; 94 } 95 96 int packets_sent() const { return packets_sent_; } 97 98 private: 99 int64_t prev_packet_time_ms_; 100 std::list<int> expected_deltas_; 101 int packets_sent_; 102 Clock* clock_; 103}; 104 105class PacedSenderTest : public ::testing::Test { 106 protected: 107 PacedSenderTest() : clock_(123456) { 108 srand(0); 109 // Need to initialize PacedSender after we initialize clock. 110 send_bucket_.reset(new PacedSender(&clock_, 111 &callback_, 112 kTargetBitrate, 113 kPaceMultiplier * kTargetBitrate, 114 0)); 115 // Default to bitrate probing disabled for testing purposes. Probing tests 116 // have to enable probing, either by creating a new PacedSender instance or 117 // by calling SetProbingEnabled(true). 118 send_bucket_->SetProbingEnabled(false); 119 } 120 121 void SendAndExpectPacket(PacedSender::Priority priority, 122 uint32_t ssrc, 123 uint16_t sequence_number, 124 int64_t capture_time_ms, 125 size_t size, 126 bool retransmission) { 127 send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms, 128 size, retransmission); 129 EXPECT_CALL(callback_, 130 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false)) 131 .Times(1) 132 .WillRepeatedly(Return(true)); 133 } 134 135 SimulatedClock clock_; 136 MockPacedSenderCallback callback_; 137 rtc::scoped_ptr<PacedSender> send_bucket_; 138}; 139 140TEST_F(PacedSenderTest, QueuePacket) { 141 uint32_t ssrc = 12345; 142 uint16_t sequence_number = 1234; 143 // Due to the multiplicative factor we can send 3 packets not 2 packets. 144 SendAndExpectPacket(PacedSender::kNormalPriority, 145 ssrc, 146 sequence_number++, 147 clock_.TimeInMilliseconds(), 148 250, 149 false); 150 SendAndExpectPacket(PacedSender::kNormalPriority, 151 ssrc, 152 sequence_number++, 153 clock_.TimeInMilliseconds(), 154 250, 155 false); 156 SendAndExpectPacket(PacedSender::kNormalPriority, 157 ssrc, 158 sequence_number++, 159 clock_.TimeInMilliseconds(), 160 250, 161 false); 162 int64_t queued_packet_timestamp = clock_.TimeInMilliseconds(); 163 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 164 sequence_number, queued_packet_timestamp, 250, 165 false); 166 send_bucket_->Process(); 167 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 168 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 169 clock_.AdvanceTimeMilliseconds(4); 170 EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess()); 171 clock_.AdvanceTimeMilliseconds(1); 172 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 173 EXPECT_CALL( 174 callback_, 175 TimeToSendPacket(ssrc, sequence_number++, queued_packet_timestamp, false)) 176 .Times(1) 177 .WillRepeatedly(Return(true)); 178 send_bucket_->Process(); 179 sequence_number++; 180 SendAndExpectPacket(PacedSender::kNormalPriority, 181 ssrc, 182 sequence_number++, 183 clock_.TimeInMilliseconds(), 184 250, 185 false); 186 SendAndExpectPacket(PacedSender::kNormalPriority, 187 ssrc, 188 sequence_number++, 189 clock_.TimeInMilliseconds(), 190 250, 191 false); 192 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 193 sequence_number++, clock_.TimeInMilliseconds(), 194 250, false); 195 send_bucket_->Process(); 196} 197 198TEST_F(PacedSenderTest, PaceQueuedPackets) { 199 uint32_t ssrc = 12345; 200 uint16_t sequence_number = 1234; 201 202 // Due to the multiplicative factor we can send 3 packets not 2 packets. 203 for (int i = 0; i < 3; ++i) { 204 SendAndExpectPacket(PacedSender::kNormalPriority, 205 ssrc, 206 sequence_number++, 207 clock_.TimeInMilliseconds(), 208 250, 209 false); 210 } 211 for (int j = 0; j < 30; ++j) { 212 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 213 sequence_number++, clock_.TimeInMilliseconds(), 214 250, false); 215 } 216 send_bucket_->Process(); 217 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 218 for (int k = 0; k < 10; ++k) { 219 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 220 clock_.AdvanceTimeMilliseconds(5); 221 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false)) 222 .Times(3) 223 .WillRepeatedly(Return(true)); 224 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 225 EXPECT_EQ(0, send_bucket_->Process()); 226 } 227 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 228 clock_.AdvanceTimeMilliseconds(5); 229 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 230 EXPECT_EQ(0, send_bucket_->Process()); 231 SendAndExpectPacket(PacedSender::kNormalPriority, 232 ssrc, 233 sequence_number++, 234 clock_.TimeInMilliseconds(), 235 250, 236 false); 237 SendAndExpectPacket(PacedSender::kNormalPriority, 238 ssrc, 239 sequence_number++, 240 clock_.TimeInMilliseconds(), 241 250, 242 false); 243 SendAndExpectPacket(PacedSender::kNormalPriority, 244 ssrc, 245 sequence_number++, 246 clock_.TimeInMilliseconds(), 247 250, 248 false); 249 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 250 sequence_number, clock_.TimeInMilliseconds(), 250, 251 false); 252 send_bucket_->Process(); 253} 254 255TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) { 256 uint32_t ssrc = 12345; 257 uint16_t sequence_number = 1234; 258 uint16_t queued_sequence_number; 259 260 // Due to the multiplicative factor we can send 3 packets not 2 packets. 261 for (int i = 0; i < 3; ++i) { 262 SendAndExpectPacket(PacedSender::kNormalPriority, 263 ssrc, 264 sequence_number++, 265 clock_.TimeInMilliseconds(), 266 250, 267 false); 268 } 269 queued_sequence_number = sequence_number; 270 271 for (int j = 0; j < 30; ++j) { 272 // Send in duplicate packets. 273 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 274 sequence_number, clock_.TimeInMilliseconds(), 275 250, false); 276 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 277 sequence_number++, clock_.TimeInMilliseconds(), 278 250, false); 279 } 280 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 281 send_bucket_->Process(); 282 for (int k = 0; k < 10; ++k) { 283 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 284 clock_.AdvanceTimeMilliseconds(5); 285 286 for (int i = 0; i < 3; ++i) { 287 EXPECT_CALL(callback_, 288 TimeToSendPacket(ssrc, queued_sequence_number++, _, false)) 289 .Times(1) 290 .WillRepeatedly(Return(true)); 291 } 292 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 293 EXPECT_EQ(0, send_bucket_->Process()); 294 } 295 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 296 clock_.AdvanceTimeMilliseconds(5); 297 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 298 EXPECT_EQ(0, send_bucket_->Process()); 299 SendAndExpectPacket(PacedSender::kNormalPriority, 300 ssrc, 301 sequence_number++, 302 clock_.TimeInMilliseconds(), 303 250, 304 false); 305 SendAndExpectPacket(PacedSender::kNormalPriority, 306 ssrc, 307 sequence_number++, 308 clock_.TimeInMilliseconds(), 309 250, 310 false); 311 SendAndExpectPacket(PacedSender::kNormalPriority, 312 ssrc, 313 sequence_number++, 314 clock_.TimeInMilliseconds(), 315 250, 316 false); 317 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 318 sequence_number++, clock_.TimeInMilliseconds(), 319 250, false); 320 send_bucket_->Process(); 321} 322 323TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) { 324 uint32_t ssrc = 12345; 325 uint16_t sequence_number = 1234; 326 327 SendAndExpectPacket(PacedSender::kNormalPriority, 328 ssrc, 329 sequence_number, 330 clock_.TimeInMilliseconds(), 331 250, 332 false); 333 334 // Expect packet on second ssrc to be queued and sent as well. 335 SendAndExpectPacket(PacedSender::kNormalPriority, 336 ssrc + 1, 337 sequence_number, 338 clock_.TimeInMilliseconds(), 339 250, 340 false); 341 342 clock_.AdvanceTimeMilliseconds(1000); 343 send_bucket_->Process(); 344} 345 346TEST_F(PacedSenderTest, Padding) { 347 uint32_t ssrc = 12345; 348 uint16_t sequence_number = 1234; 349 350 send_bucket_->UpdateBitrate( 351 kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate); 352 // Due to the multiplicative factor we can send 3 packets not 2 packets. 353 SendAndExpectPacket(PacedSender::kNormalPriority, 354 ssrc, 355 sequence_number++, 356 clock_.TimeInMilliseconds(), 357 250, 358 false); 359 SendAndExpectPacket(PacedSender::kNormalPriority, 360 ssrc, 361 sequence_number++, 362 clock_.TimeInMilliseconds(), 363 250, 364 false); 365 SendAndExpectPacket(PacedSender::kNormalPriority, 366 ssrc, 367 sequence_number++, 368 clock_.TimeInMilliseconds(), 369 250, 370 false); 371 // No padding is expected since we have sent too much already. 372 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 373 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 374 clock_.AdvanceTimeMilliseconds(5); 375 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 376 EXPECT_EQ(0, send_bucket_->Process()); 377 378 // 5 milliseconds later we have enough budget to send some padding. 379 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). 380 WillOnce(Return(250)); 381 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 382 clock_.AdvanceTimeMilliseconds(5); 383 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 384 EXPECT_EQ(0, send_bucket_->Process()); 385} 386 387TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) { 388 uint32_t ssrc = 12345; 389 uint16_t sequence_number = 1234; 390 int64_t capture_time_ms = 56789; 391 const int kTimeStep = 5; 392 const int64_t kBitrateWindow = 100; 393 send_bucket_->UpdateBitrate( 394 kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate); 395 int64_t start_time = clock_.TimeInMilliseconds(); 396 while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { 397 SendAndExpectPacket(PacedSender::kNormalPriority, 398 ssrc, 399 sequence_number++, 400 capture_time_ms, 401 250, 402 false); 403 clock_.AdvanceTimeMilliseconds(kTimeStep); 404 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). 405 WillOnce(Return(250)); 406 send_bucket_->Process(); 407 } 408} 409 410TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) { 411 uint32_t ssrc = 12345; 412 uint16_t sequence_number = 1234; 413 int64_t capture_time_ms = 56789; 414 const int kTimeStep = 5; 415 const int64_t kBitrateWindow = 10000; 416 PacedSenderPadding callback; 417 send_bucket_.reset(new PacedSender( 418 &clock_, &callback, kTargetBitrate, kPaceMultiplier * kTargetBitrate, 0)); 419 send_bucket_->SetProbingEnabled(false); 420 send_bucket_->UpdateBitrate( 421 kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate); 422 int64_t start_time = clock_.TimeInMilliseconds(); 423 size_t media_bytes = 0; 424 while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { 425 size_t media_payload = rand() % 100 + 200; // [200, 300] bytes. 426 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 427 sequence_number++, capture_time_ms, 428 media_payload, false); 429 media_bytes += media_payload; 430 clock_.AdvanceTimeMilliseconds(kTimeStep); 431 send_bucket_->Process(); 432 } 433 EXPECT_NEAR(kTargetBitrate, 434 static_cast<int>(8 * (media_bytes + callback.padding_sent()) / 435 kBitrateWindow), 1); 436} 437 438TEST_F(PacedSenderTest, Priority) { 439 uint32_t ssrc_low_priority = 12345; 440 uint32_t ssrc = 12346; 441 uint16_t sequence_number = 1234; 442 int64_t capture_time_ms = 56789; 443 int64_t capture_time_ms_low_priority = 1234567; 444 445 // Due to the multiplicative factor we can send 3 packets not 2 packets. 446 SendAndExpectPacket(PacedSender::kLowPriority, 447 ssrc, 448 sequence_number++, 449 capture_time_ms, 450 250, 451 false); 452 SendAndExpectPacket(PacedSender::kNormalPriority, 453 ssrc, 454 sequence_number++, 455 capture_time_ms, 456 250, 457 false); 458 SendAndExpectPacket(PacedSender::kNormalPriority, 459 ssrc, 460 sequence_number++, 461 capture_time_ms, 462 250, 463 false); 464 send_bucket_->Process(); 465 466 // Expect normal and low priority to be queued and high to pass through. 467 send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority, 468 sequence_number++, capture_time_ms_low_priority, 469 250, false); 470 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 471 sequence_number++, capture_time_ms, 250, false); 472 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 473 sequence_number++, capture_time_ms, 250, false); 474 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 475 sequence_number++, capture_time_ms, 250, false); 476 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, 477 sequence_number++, capture_time_ms, 250, false); 478 479 // Expect all high and normal priority to be sent out first. 480 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 481 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false)) 482 .Times(4) 483 .WillRepeatedly(Return(true)); 484 485 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 486 clock_.AdvanceTimeMilliseconds(5); 487 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 488 EXPECT_EQ(0, send_bucket_->Process()); 489 490 EXPECT_CALL(callback_, 491 TimeToSendPacket( 492 ssrc_low_priority, _, capture_time_ms_low_priority, false)) 493 .Times(1) 494 .WillRepeatedly(Return(true)); 495 496 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 497 clock_.AdvanceTimeMilliseconds(5); 498 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 499 EXPECT_EQ(0, send_bucket_->Process()); 500} 501 502TEST_F(PacedSenderTest, HighPrioDoesntAffectBudget) { 503 uint32_t ssrc = 12346; 504 uint16_t sequence_number = 1234; 505 int64_t capture_time_ms = 56789; 506 507 // As high prio packets doesn't affect the budget, we should be able to send 508 // a high number of them at once. 509 for (int i = 0; i < 25; ++i) { 510 SendAndExpectPacket(PacedSender::kHighPriority, ssrc, sequence_number++, 511 capture_time_ms, 250, false); 512 } 513 send_bucket_->Process(); 514 // Low prio packets does affect the budget, so we should only be able to send 515 // 3 at once, the 4th should be queued. 516 for (int i = 0; i < 3; ++i) { 517 SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++, 518 capture_time_ms, 250, false); 519 } 520 send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc, sequence_number, 521 capture_time_ms, 250, false); 522 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 523 clock_.AdvanceTimeMilliseconds(5); 524 send_bucket_->Process(); 525 EXPECT_CALL(callback_, 526 TimeToSendPacket(ssrc, sequence_number++, capture_time_ms, false)) 527 .Times(1); 528 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 529 clock_.AdvanceTimeMilliseconds(5); 530 send_bucket_->Process(); 531} 532 533TEST_F(PacedSenderTest, Pause) { 534 uint32_t ssrc_low_priority = 12345; 535 uint32_t ssrc = 12346; 536 uint16_t sequence_number = 1234; 537 int64_t capture_time_ms = clock_.TimeInMilliseconds(); 538 539 EXPECT_EQ(0, send_bucket_->QueueInMs()); 540 541 // Due to the multiplicative factor we can send 3 packets not 2 packets. 542 SendAndExpectPacket(PacedSender::kLowPriority, 543 ssrc, 544 sequence_number++, 545 capture_time_ms, 546 250, 547 false); 548 SendAndExpectPacket(PacedSender::kNormalPriority, 549 ssrc, 550 sequence_number++, 551 capture_time_ms, 552 250, 553 false); 554 SendAndExpectPacket(PacedSender::kNormalPriority, 555 ssrc, 556 sequence_number++, 557 capture_time_ms, 558 250, 559 false); 560 send_bucket_->Process(); 561 562 send_bucket_->Pause(); 563 564 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 565 sequence_number++, capture_time_ms, 250, false); 566 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 567 sequence_number++, capture_time_ms, 250, false); 568 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, 569 sequence_number++, capture_time_ms, 250, false); 570 571 clock_.AdvanceTimeMilliseconds(10000); 572 int64_t second_capture_time_ms = clock_.TimeInMilliseconds(); 573 574 // Expect everything to be queued. 575 send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority, 576 sequence_number++, second_capture_time_ms, 250, 577 false); 578 579 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 580 send_bucket_->QueueInMs()); 581 582 // Expect no packet to come out while paused. 583 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 584 EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0); 585 586 for (int i = 0; i < 10; ++i) { 587 clock_.AdvanceTimeMilliseconds(5); 588 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 589 EXPECT_EQ(0, send_bucket_->Process()); 590 } 591 // Expect high prio packets to come out first followed by all packets in the 592 // way they were added. 593 EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false)) 594 .Times(3) 595 .WillRepeatedly(Return(true)); 596 EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false)) 597 .Times(1) 598 .WillRepeatedly(Return(true)); 599 send_bucket_->Resume(); 600 601 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 602 clock_.AdvanceTimeMilliseconds(5); 603 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 604 EXPECT_EQ(0, send_bucket_->Process()); 605 606 EXPECT_EQ(0, send_bucket_->QueueInMs()); 607} 608 609TEST_F(PacedSenderTest, ResendPacket) { 610 uint32_t ssrc = 12346; 611 uint16_t sequence_number = 1234; 612 int64_t capture_time_ms = clock_.TimeInMilliseconds(); 613 EXPECT_EQ(0, send_bucket_->QueueInMs()); 614 615 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 616 sequence_number, capture_time_ms, 250, false); 617 clock_.AdvanceTimeMilliseconds(1); 618 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 619 sequence_number + 1, capture_time_ms + 1, 250, 620 false); 621 clock_.AdvanceTimeMilliseconds(9999); 622 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 623 send_bucket_->QueueInMs()); 624 // Fails to send first packet so only one call. 625 EXPECT_CALL(callback_, 626 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false)) 627 .Times(1) 628 .WillOnce(Return(false)); 629 clock_.AdvanceTimeMilliseconds(10000); 630 send_bucket_->Process(); 631 632 // Queue remains unchanged. 633 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 634 send_bucket_->QueueInMs()); 635 636 // Fails to send second packet. 637 EXPECT_CALL(callback_, 638 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false)) 639 .Times(1) 640 .WillOnce(Return(true)); 641 EXPECT_CALL( 642 callback_, 643 TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false)) 644 .Times(1) 645 .WillOnce(Return(false)); 646 clock_.AdvanceTimeMilliseconds(10000); 647 send_bucket_->Process(); 648 649 // Queue is reduced by 1 packet. 650 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1, 651 send_bucket_->QueueInMs()); 652 653 // Send second packet and queue becomes empty. 654 EXPECT_CALL( 655 callback_, 656 TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false)) 657 .Times(1) 658 .WillOnce(Return(true)); 659 clock_.AdvanceTimeMilliseconds(10000); 660 send_bucket_->Process(); 661 EXPECT_EQ(0, send_bucket_->QueueInMs()); 662} 663 664TEST_F(PacedSenderTest, ExpectedQueueTimeMs) { 665 uint32_t ssrc = 12346; 666 uint16_t sequence_number = 1234; 667 const size_t kNumPackets = 60; 668 const size_t kPacketSize = 1200; 669 const int32_t kMaxBitrate = kPaceMultiplier * 30; 670 EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs()); 671 672 send_bucket_->UpdateBitrate(30, kMaxBitrate, 0); 673 for (size_t i = 0; i < kNumPackets; ++i) { 674 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 675 clock_.TimeInMilliseconds(), kPacketSize, false); 676 } 677 678 // Queue in ms = 1000 * (bytes in queue) / (kbit per second * 1000 / 8) 679 int64_t queue_in_ms = 680 static_cast<int64_t>(kNumPackets * kPacketSize * 8 / kMaxBitrate); 681 EXPECT_EQ(queue_in_ms, send_bucket_->ExpectedQueueTimeMs()); 682 683 int64_t time_start = clock_.TimeInMilliseconds(); 684 while (send_bucket_->QueueSizePackets() > 0) { 685 int time_until_process = send_bucket_->TimeUntilNextProcess(); 686 if (time_until_process <= 0) { 687 send_bucket_->Process(); 688 } else { 689 clock_.AdvanceTimeMilliseconds(time_until_process); 690 } 691 } 692 int64_t duration = clock_.TimeInMilliseconds() - time_start; 693 694 EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs()); 695 696 // Allow for aliasing, duration should be within one pack of max time limit. 697 EXPECT_NEAR(duration, PacedSender::kMaxQueueLengthMs, 698 static_cast<int64_t>(kPacketSize * 8 / kMaxBitrate)); 699} 700 701TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) { 702 uint32_t ssrc = 12346; 703 uint16_t sequence_number = 1234; 704 EXPECT_EQ(0, send_bucket_->QueueInMs()); 705 706 send_bucket_->UpdateBitrate(30, kPaceMultiplier * 30, 0); 707 SendAndExpectPacket(PacedSender::kNormalPriority, 708 ssrc, 709 sequence_number, 710 clock_.TimeInMilliseconds(), 711 1200, 712 false); 713 714 clock_.AdvanceTimeMilliseconds(500); 715 EXPECT_EQ(500, send_bucket_->QueueInMs()); 716 send_bucket_->Process(); 717 EXPECT_EQ(0, send_bucket_->QueueInMs()); 718} 719 720TEST_F(PacedSenderTest, ProbingWithInitialFrame) { 721 const int kNumPackets = 11; 722 const int kNumDeltas = kNumPackets - 1; 723 const size_t kPacketSize = 1200; 724 const int kInitialBitrateKbps = 300; 725 uint32_t ssrc = 12346; 726 uint16_t sequence_number = 1234; 727 const int expected_deltas[kNumDeltas] = { 728 10, 10, 10, 10, 10, 5, 5, 5, 5, 5}; 729 std::list<int> expected_deltas_list(expected_deltas, 730 expected_deltas + kNumPackets - 1); 731 PacedSenderProbing callback(expected_deltas_list, &clock_); 732 send_bucket_.reset( 733 new PacedSender(&clock_, 734 &callback, 735 kInitialBitrateKbps, 736 kPaceMultiplier * kInitialBitrateKbps, 737 0)); 738 739 for (int i = 0; i < kNumPackets; ++i) { 740 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 741 sequence_number++, clock_.TimeInMilliseconds(), 742 kPacketSize, false); 743 } 744 while (callback.packets_sent() < kNumPackets) { 745 int time_until_process = send_bucket_->TimeUntilNextProcess(); 746 if (time_until_process <= 0) { 747 send_bucket_->Process(); 748 } else { 749 clock_.AdvanceTimeMilliseconds(time_until_process); 750 } 751 } 752} 753 754TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) { 755 const int kNumPackets = 11; 756 const int kNumDeltas = kNumPackets - 1; 757 const size_t kPacketSize = 1200; 758 const int kInitialBitrateKbps = 300; 759 uint32_t ssrc = 12346; 760 uint16_t sequence_number = 1234; 761 const int expected_deltas[kNumDeltas] = {10, 10, 10, 10, 10, 5, 5, 5, 5, 5}; 762 std::list<int> expected_deltas_list(expected_deltas, 763 expected_deltas + kNumPackets - 1); 764 PacedSenderProbing callback(expected_deltas_list, &clock_); 765 send_bucket_.reset(new PacedSender(&clock_, &callback, kInitialBitrateKbps, 766 kPaceMultiplier * kInitialBitrateKbps, 0)); 767 768 for (int i = 0; i < kNumPackets - 5; ++i) { 769 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 770 sequence_number++, clock_.TimeInMilliseconds(), 771 kPacketSize, false); 772 } 773 while (callback.packets_sent() < kNumPackets) { 774 int time_until_process = send_bucket_->TimeUntilNextProcess(); 775 if (time_until_process <= 0) { 776 send_bucket_->Process(); 777 } else { 778 clock_.AdvanceTimeMilliseconds(time_until_process); 779 } 780 } 781 782 // Process one more time and make sure we don't send any more probes. 783 int time_until_process = send_bucket_->TimeUntilNextProcess(); 784 clock_.AdvanceTimeMilliseconds(time_until_process); 785 send_bucket_->Process(); 786 EXPECT_EQ(kNumPackets, callback.packets_sent()); 787} 788 789TEST_F(PacedSenderTest, PriorityInversion) { 790 uint32_t ssrc = 12346; 791 uint16_t sequence_number = 1234; 792 const size_t kPacketSize = 1200; 793 794 send_bucket_->InsertPacket( 795 PacedSender::kHighPriority, ssrc, sequence_number + 3, 796 clock_.TimeInMilliseconds() + 33, kPacketSize, true); 797 798 send_bucket_->InsertPacket( 799 PacedSender::kHighPriority, ssrc, sequence_number + 2, 800 clock_.TimeInMilliseconds() + 33, kPacketSize, true); 801 802 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number, 803 clock_.TimeInMilliseconds(), kPacketSize, true); 804 805 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, 806 sequence_number + 1, clock_.TimeInMilliseconds(), 807 kPacketSize, true); 808 809 // Packets from earlier frames should be sent first. 810 { 811 ::testing::InSequence sequence; 812 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number, 813 clock_.TimeInMilliseconds(), true)) 814 .WillOnce(Return(true)); 815 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1, 816 clock_.TimeInMilliseconds(), true)) 817 .WillOnce(Return(true)); 818 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 3, 819 clock_.TimeInMilliseconds() + 33, 820 true)).WillOnce(Return(true)); 821 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 2, 822 clock_.TimeInMilliseconds() + 33, 823 true)).WillOnce(Return(true)); 824 825 while (send_bucket_->QueueSizePackets() > 0) { 826 int time_until_process = send_bucket_->TimeUntilNextProcess(); 827 if (time_until_process <= 0) { 828 send_bucket_->Process(); 829 } else { 830 clock_.AdvanceTimeMilliseconds(time_until_process); 831 } 832 } 833 } 834} 835 836TEST_F(PacedSenderTest, PaddingOveruse) { 837 uint32_t ssrc = 12346; 838 uint16_t sequence_number = 1234; 839 const size_t kPacketSize = 1200; 840 841 // Min bitrate 0 => no padding, padding budget will stay at 0. 842 send_bucket_->UpdateBitrate(60, 90, 0); 843 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 844 clock_.TimeInMilliseconds(), kPacketSize, false); 845 send_bucket_->Process(); 846 847 // Add 30kbit padding. When increasing budget, media budget will increase from 848 // negative (overuse) while padding budget will increase form 0. 849 clock_.AdvanceTimeMilliseconds(5); 850 send_bucket_->UpdateBitrate(60, 90, 30); 851 852 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, 853 sequence_number++, clock_.TimeInMilliseconds(), 854 kPacketSize, false); 855 856 // Don't send padding if queue is non-empty, even if padding budget > 0. 857 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 858 send_bucket_->Process(); 859} 860 861TEST_F(PacedSenderTest, AverageQueueTime) { 862 uint32_t ssrc = 12346; 863 uint16_t sequence_number = 1234; 864 const size_t kPacketSize = 1200; 865 const int kBitrateBps = 10 * kPacketSize * 8; // 10 packets per second. 866 const int kBitrateKbps = (kBitrateBps + 500) / 1000; 867 868 send_bucket_->UpdateBitrate(kBitrateKbps, kBitrateKbps, kBitrateKbps); 869 870 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); 871 872 int64_t first_capture_time = clock_.TimeInMilliseconds(); 873 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 874 sequence_number, first_capture_time, kPacketSize, 875 false); 876 clock_.AdvanceTimeMilliseconds(10); 877 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, 878 sequence_number + 1, clock_.TimeInMilliseconds(), 879 kPacketSize, false); 880 clock_.AdvanceTimeMilliseconds(10); 881 882 EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs()); 883 884 // Only first packet (queued for 20ms) should be removed, leave the second 885 // packet (queued for 10ms) alone in the queue. 886 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number, 887 first_capture_time, false)) 888 .Times(1) 889 .WillRepeatedly(Return(true)); 890 send_bucket_->Process(); 891 892 EXPECT_EQ(10, send_bucket_->AverageQueueTimeMs()); 893 894 clock_.AdvanceTimeMilliseconds(10); 895 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1, 896 first_capture_time + 10, false)) 897 .Times(1) 898 .WillRepeatedly(Return(true)); 899 for (int i = 0; i < 3; ++i) { 900 clock_.AdvanceTimeMilliseconds(30); // Max delta. 901 send_bucket_->Process(); 902 } 903 904 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); 905} 906 907} // namespace test 908} // namespace webrtc 909