OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 453 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
464 send_bucket_->Process(); | 464 send_bucket_->Process(); |
465 | 465 |
466 // Expect normal and low priority to be queued and high to pass through. | 466 // Expect normal and low priority to be queued and high to pass through. |
467 send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority, | 467 send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority, |
468 sequence_number++, capture_time_ms_low_priority, | 468 sequence_number++, capture_time_ms_low_priority, |
469 250, false); | 469 250, false); |
470 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, | 470 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, |
471 sequence_number++, capture_time_ms, 250, false); | 471 sequence_number++, capture_time_ms, 250, false); |
472 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, | 472 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, |
473 sequence_number++, capture_time_ms, 250, false); | 473 sequence_number++, capture_time_ms, 250, false); |
| 474 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, |
| 475 sequence_number++, capture_time_ms, 250, false); |
474 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, | 476 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, |
475 sequence_number++, capture_time_ms, 250, false); | 477 sequence_number++, capture_time_ms, 250, false); |
476 | 478 |
477 // Expect all high and normal priority to be sent out first. | 479 // Expect all high and normal priority to be sent out first. |
478 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); | 480 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); |
479 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false)) | 481 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false)) |
480 .Times(3) | 482 .Times(4) |
481 .WillRepeatedly(Return(true)); | 483 .WillRepeatedly(Return(true)); |
482 | 484 |
483 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); | 485 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); |
484 clock_.AdvanceTimeMilliseconds(5); | 486 clock_.AdvanceTimeMilliseconds(5); |
485 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); | 487 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); |
486 EXPECT_EQ(0, send_bucket_->Process()); | 488 EXPECT_EQ(0, send_bucket_->Process()); |
487 | 489 |
488 EXPECT_CALL(callback_, | 490 EXPECT_CALL(callback_, |
489 TimeToSendPacket( | 491 TimeToSendPacket( |
490 ssrc_low_priority, _, capture_time_ms_low_priority, false)) | 492 ssrc_low_priority, _, capture_time_ms_low_priority, false)) |
491 .Times(1) | 493 .Times(1) |
492 .WillRepeatedly(Return(true)); | 494 .WillRepeatedly(Return(true)); |
493 | 495 |
494 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); | 496 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); |
495 clock_.AdvanceTimeMilliseconds(5); | 497 clock_.AdvanceTimeMilliseconds(5); |
496 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); | 498 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); |
497 EXPECT_EQ(0, send_bucket_->Process()); | 499 EXPECT_EQ(0, send_bucket_->Process()); |
498 } | 500 } |
499 | 501 |
| 502 TEST_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 |
500 TEST_F(PacedSenderTest, Pause) { | 533 TEST_F(PacedSenderTest, Pause) { |
501 uint32_t ssrc_low_priority = 12345; | 534 uint32_t ssrc_low_priority = 12345; |
502 uint32_t ssrc = 12346; | 535 uint32_t ssrc = 12346; |
503 uint16_t sequence_number = 1234; | 536 uint16_t sequence_number = 1234; |
504 int64_t capture_time_ms = clock_.TimeInMilliseconds(); | 537 int64_t capture_time_ms = clock_.TimeInMilliseconds(); |
505 | 538 |
506 EXPECT_EQ(0, send_bucket_->QueueInMs()); | 539 EXPECT_EQ(0, send_bucket_->QueueInMs()); |
507 | 540 |
508 // Due to the multiplicative factor we can send 3 packets not 2 packets. | 541 // Due to the multiplicative factor we can send 3 packets not 2 packets. |
509 SendAndExpectPacket(PacedSender::kLowPriority, | 542 SendAndExpectPacket(PacedSender::kLowPriority, |
(...skipping 320 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
830 uint16_t sequence_number = 1234; | 863 uint16_t sequence_number = 1234; |
831 const size_t kPacketSize = 1200; | 864 const size_t kPacketSize = 1200; |
832 const int kBitrateBps = 10 * kPacketSize * 8; // 10 packets per second. | 865 const int kBitrateBps = 10 * kPacketSize * 8; // 10 packets per second. |
833 const int kBitrateKbps = (kBitrateBps + 500) / 1000; | 866 const int kBitrateKbps = (kBitrateBps + 500) / 1000; |
834 | 867 |
835 send_bucket_->UpdateBitrate(kBitrateKbps, kBitrateKbps, kBitrateKbps); | 868 send_bucket_->UpdateBitrate(kBitrateKbps, kBitrateKbps, kBitrateKbps); |
836 | 869 |
837 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); | 870 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); |
838 | 871 |
839 int64_t first_capture_time = clock_.TimeInMilliseconds(); | 872 int64_t first_capture_time = clock_.TimeInMilliseconds(); |
840 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number, | 873 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, |
841 first_capture_time, kPacketSize, false); | 874 sequence_number, first_capture_time, kPacketSize, |
| 875 false); |
842 clock_.AdvanceTimeMilliseconds(10); | 876 clock_.AdvanceTimeMilliseconds(10); |
843 send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, | 877 send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, |
844 sequence_number + 1, clock_.TimeInMilliseconds(), | 878 sequence_number + 1, clock_.TimeInMilliseconds(), |
845 kPacketSize, false); | 879 kPacketSize, false); |
846 clock_.AdvanceTimeMilliseconds(10); | 880 clock_.AdvanceTimeMilliseconds(10); |
847 | 881 |
848 EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs()); | 882 EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs()); |
849 | 883 |
850 // Only first packet (queued for 20ms) should be removed, leave the second | 884 // Only first packet (queued for 20ms) should be removed, leave the second |
851 // packet (queued for 10ms) alone in the queue. | 885 // packet (queued for 10ms) alone in the queue. |
852 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number, | 886 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number, |
853 first_capture_time, false)) | 887 first_capture_time, false)) |
(...skipping 11 matching lines...) Expand all Loading... |
865 for (int i = 0; i < 3; ++i) { | 899 for (int i = 0; i < 3; ++i) { |
866 clock_.AdvanceTimeMilliseconds(30); // Max delta. | 900 clock_.AdvanceTimeMilliseconds(30); // Max delta. |
867 send_bucket_->Process(); | 901 send_bucket_->Process(); |
868 } | 902 } |
869 | 903 |
870 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); | 904 EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); |
871 } | 905 } |
872 | 906 |
873 } // namespace test | 907 } // namespace test |
874 } // namespace webrtc | 908 } // namespace webrtc |
OLD | NEW |