Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(298)

Side by Side Diff: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Issue 2491293002: Make FlexFEC packets paceable through RTPSender. (Closed)
Patch Set: Feedback response 3. Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 24 matching lines...) Expand all
35 namespace webrtc { 35 namespace webrtc {
36 36
37 namespace { 37 namespace {
38 const int kTransmissionTimeOffsetExtensionId = 1; 38 const int kTransmissionTimeOffsetExtensionId = 1;
39 const int kAbsoluteSendTimeExtensionId = 14; 39 const int kAbsoluteSendTimeExtensionId = 14;
40 const int kTransportSequenceNumberExtensionId = 13; 40 const int kTransportSequenceNumberExtensionId = 13;
41 const int kPayload = 100; 41 const int kPayload = 100;
42 const int kRtxPayload = 98; 42 const int kRtxPayload = 98;
43 const uint32_t kTimestamp = 10; 43 const uint32_t kTimestamp = 10;
44 const uint16_t kSeqNum = 33; 44 const uint16_t kSeqNum = 33;
45 const uint32_t kSsrc = 725242;
45 const int kMaxPacketLength = 1500; 46 const int kMaxPacketLength = 1500;
46 const uint8_t kAudioLevel = 0x5a; 47 const uint8_t kAudioLevel = 0x5a;
47 const uint16_t kTransportSequenceNumber = 0xaabbu; 48 const uint16_t kTransportSequenceNumber = 0xaabbu;
48 const uint8_t kAudioLevelExtensionId = 9; 49 const uint8_t kAudioLevelExtensionId = 9;
49 const int kAudioPayload = 103; 50 const int kAudioPayload = 103;
50 const uint64_t kStartTime = 123456789; 51 const uint64_t kStartTime = 123456789;
51 const size_t kMaxPaddingSize = 224u; 52 const size_t kMaxPaddingSize = 224u;
52 const int kVideoRotationExtensionId = 5; 53 const int kVideoRotationExtensionId = 5;
53 const size_t kGenericHeaderLength = 1; 54 const size_t kGenericHeaderLength = 1;
54 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89}; 55 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
143 kMarkerBit(true) {} 144 kMarkerBit(true) {}
144 145
145 void SetUp() override { SetUpRtpSender(true); } 146 void SetUp() override { SetUpRtpSender(true); }
146 147
147 void SetUpRtpSender(bool pacer) { 148 void SetUpRtpSender(bool pacer) {
148 rtp_sender_.reset(new RTPSender( 149 rtp_sender_.reset(new RTPSender(
149 false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr, 150 false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
150 nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr, 151 nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
151 &mock_rtc_event_log_, &send_packet_observer_, 152 &mock_rtc_event_log_, &send_packet_observer_,
152 &retransmission_rate_limiter_)); 153 &retransmission_rate_limiter_));
154 rtp_sender_->SetSendPayloadType(kPayload);
153 rtp_sender_->SetSequenceNumber(kSeqNum); 155 rtp_sender_->SetSequenceNumber(kSeqNum);
154 rtp_sender_->SetSendPayloadType(kPayload);
155 rtp_sender_->SetTimestampOffset(0); 156 rtp_sender_->SetTimestampOffset(0);
157 rtp_sender_->SetSSRC(kSsrc);
156 } 158 }
157 159
158 SimulatedClock fake_clock_; 160 SimulatedClock fake_clock_;
159 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_; 161 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_;
160 MockRtpPacketSender mock_paced_sender_; 162 MockRtpPacketSender mock_paced_sender_;
161 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_; 163 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_;
162 testing::StrictMock<MockSendPacketObserver> send_packet_observer_; 164 testing::StrictMock<MockSendPacketObserver> send_packet_observer_;
163 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_; 165 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_;
164 RateLimiter retransmission_rate_limiter_; 166 RateLimiter retransmission_rate_limiter_;
165 std::unique_ptr<RTPSender> rtp_sender_; 167 std::unique_ptr<RTPSender> rtp_sender_;
(...skipping 317 matching lines...) Expand 10 before | Expand all | Expand 10 after
483 485
484 SendGenericPayload(); 486 SendGenericPayload();
485 } 487 }
486 488
487 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { 489 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
488 rtp_sender_.reset( 490 rtp_sender_.reset(
489 new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_, 491 new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_,
490 nullptr, &seq_num_allocator_, &feedback_observer_, nullptr, 492 nullptr, &seq_num_allocator_, &feedback_observer_, nullptr,
491 nullptr, nullptr, &mock_rtc_event_log_, 493 nullptr, nullptr, &mock_rtc_event_log_,
492 &send_packet_observer_, &retransmission_rate_limiter_)); 494 &send_packet_observer_, &retransmission_rate_limiter_));
495 rtp_sender_->SetSequenceNumber(kSeqNum);
496 rtp_sender_->SetSSRC(kSsrc);
493 rtp_sender_->SetStorePacketsStatus(true, 10); 497 rtp_sender_->SetStorePacketsStatus(true, 10);
494 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 498 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
495 kRtpExtensionTransportSequenceNumber, 499 kRtpExtensionTransportSequenceNumber,
496 kTransportSequenceNumberExtensionId)); 500 kTransportSequenceNumberExtensionId));
497 501
498 uint16_t seq_num = 0; 502 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _));
499 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
500 .Times(1).WillRepeatedly(testing::SaveArg<2>(&seq_num));
501 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) 503 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
502 .WillOnce(testing::Return(kTransportSequenceNumber)); 504 .WillOnce(testing::Return(kTransportSequenceNumber));
503 EXPECT_CALL(send_packet_observer_, 505 EXPECT_CALL(send_packet_observer_,
504 OnSendPacket(kTransportSequenceNumber, _, _)) 506 OnSendPacket(kTransportSequenceNumber, _, _))
505 .Times(1); 507 .Times(1);
506 const int kProbeClusterId = 1; 508 const int kProbeClusterId = 1;
507 EXPECT_CALL( 509 EXPECT_CALL(
508 feedback_observer_, 510 feedback_observer_,
509 AddPacket(kTransportSequenceNumber, 511 AddPacket(kTransportSequenceNumber,
510 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId)) 512 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId))
511 .Times(1); 513 .Times(1);
512 514
513 SendGenericPayload(); 515 SendGenericPayload();
514 rtp_sender_->TimeToSendPacket(seq_num, fake_clock_.TimeInMilliseconds(), 516 rtp_sender_->TimeToSendPacket(
515 false, kProbeClusterId); 517 kSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, kProbeClusterId);
516 518
517 const auto& packet = transport_.last_sent_packet(); 519 const auto& packet = transport_.last_sent_packet();
518 uint16_t transport_seq_no; 520 uint16_t transport_seq_no;
519 EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no)); 521 EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
520 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no); 522 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
521 EXPECT_EQ(transport_.last_packet_id_, transport_seq_no); 523 EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
522 } 524 }
523 525
524 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { 526 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
525 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, 527 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
526 _, kSeqNum, _, _, _)); 528 kSsrc, kSeqNum, _, _, _));
527 EXPECT_CALL(mock_rtc_event_log_, 529 EXPECT_CALL(mock_rtc_event_log_,
528 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); 530 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
529 531
530 rtp_sender_->SetStorePacketsStatus(true, 10); 532 rtp_sender_->SetStorePacketsStatus(true, 10);
531 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 533 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
532 kRtpExtensionTransmissionTimeOffset, 534 kRtpExtensionTransmissionTimeOffset,
533 kTransmissionTimeOffsetExtensionId)); 535 kTransmissionTimeOffsetExtensionId));
534 EXPECT_EQ( 536 EXPECT_EQ(
535 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 537 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
536 kAbsoluteSendTimeExtensionId)); 538 kAbsoluteSendTimeExtensionId));
537 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 539 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
538 auto packet = 540 auto packet =
539 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); 541 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
540 size_t packet_size = packet->size(); 542 size_t packet_size = packet->size();
541 543
542 // Packet should be stored in a send bucket. 544 // Packet should be stored in a send bucket.
543 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), 545 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
544 kAllowRetransmission, 546 kAllowRetransmission,
545 RtpPacketSender::kNormalPriority)); 547 RtpPacketSender::kNormalPriority));
546 548
547 EXPECT_EQ(0, transport_.packets_sent()); 549 EXPECT_EQ(0, transport_.packets_sent());
548 550
549 const int kStoredTimeInMs = 100; 551 const int kStoredTimeInMs = 100;
550 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); 552 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
551 553
552 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, 554 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
553 PacketInfo::kNotAProbe); 555 PacketInfo::kNotAProbe);
554 556
555 // Process send bucket. Packet should now be sent. 557 // Process send bucket. Packet should now be sent.
556 EXPECT_EQ(1, transport_.packets_sent()); 558 EXPECT_EQ(1, transport_.packets_sent());
557 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); 559 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
558 560
559 webrtc::RTPHeader rtp_header; 561 webrtc::RTPHeader rtp_header;
560 transport_.last_sent_packet().GetHeader(&rtp_header); 562 transport_.last_sent_packet().GetHeader(&rtp_header);
561 563
562 // Verify transmission time offset. 564 // Verify transmission time offset.
563 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); 565 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
564 uint64_t expected_send_time = 566 uint64_t expected_send_time =
565 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); 567 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
566 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); 568 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
567 } 569 }
568 570
569 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { 571 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
570 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, 572 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
571 _, kSeqNum, _, _, _)); 573 kSsrc, kSeqNum, _, _, _));
572 EXPECT_CALL(mock_rtc_event_log_, 574 EXPECT_CALL(mock_rtc_event_log_,
573 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); 575 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
574 576
575 rtp_sender_->SetStorePacketsStatus(true, 10); 577 rtp_sender_->SetStorePacketsStatus(true, 10);
576 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 578 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
577 kRtpExtensionTransmissionTimeOffset, 579 kRtpExtensionTransmissionTimeOffset,
578 kTransmissionTimeOffsetExtensionId)); 580 kTransmissionTimeOffsetExtensionId));
579 EXPECT_EQ( 581 EXPECT_EQ(
580 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 582 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
581 kAbsoluteSendTimeExtensionId)); 583 kAbsoluteSendTimeExtensionId));
582 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 584 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
583 auto packet = 585 auto packet =
584 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); 586 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
585 size_t packet_size = packet->size(); 587 size_t packet_size = packet->size();
586 588
587 // Packet should be stored in a send bucket. 589 // Packet should be stored in a send bucket.
588 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), 590 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
589 kAllowRetransmission, 591 kAllowRetransmission,
590 RtpPacketSender::kNormalPriority)); 592 RtpPacketSender::kNormalPriority));
591 593
592 EXPECT_EQ(0, transport_.packets_sent()); 594 EXPECT_EQ(0, transport_.packets_sent());
593 595
594 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, 596 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
595 _, kSeqNum, _, _, _)); 597 kSsrc, kSeqNum, _, _, _));
596 598
597 const int kStoredTimeInMs = 100; 599 const int kStoredTimeInMs = 100;
598 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); 600 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
599 601
600 EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum)); 602 EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum));
601 EXPECT_EQ(0, transport_.packets_sent()); 603 EXPECT_EQ(0, transport_.packets_sent());
602 604
603 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, 605 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
604 PacketInfo::kNotAProbe); 606 PacketInfo::kNotAProbe);
605 607
606 // Process send bucket. Packet should now be sent. 608 // Process send bucket. Packet should now be sent.
607 EXPECT_EQ(1, transport_.packets_sent()); 609 EXPECT_EQ(1, transport_.packets_sent());
608 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); 610 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
609 611
610 webrtc::RTPHeader rtp_header; 612 webrtc::RTPHeader rtp_header;
611 transport_.last_sent_packet().GetHeader(&rtp_header); 613 transport_.last_sent_packet().GetHeader(&rtp_header);
612 614
613 // Verify transmission time offset. 615 // Verify transmission time offset.
614 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); 616 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
615 uint64_t expected_send_time = 617 uint64_t expected_send_time =
616 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); 618 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
617 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); 619 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
618 } 620 }
619 621
620 // This test sends 1 regular video packet, then 4 padding packets, and then 622 // This test sends 1 regular video packet, then 4 padding packets, and then
621 // 1 more regular packet. 623 // 1 more regular packet.
622 TEST_F(RtpSenderTest, SendPadding) { 624 TEST_F(RtpSenderTest, SendPadding) {
623 // Make all (non-padding) packets go to send queue. 625 // Make all (non-padding) packets go to send queue.
624 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, 626 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
625 _, kSeqNum, _, _, _)); 627 kSsrc, kSeqNum, _, _, _));
626 EXPECT_CALL(mock_rtc_event_log_, 628 EXPECT_CALL(mock_rtc_event_log_,
627 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) 629 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
628 .Times(1 + 4 + 1); 630 .Times(1 + 4 + 1);
629 631
630 uint16_t seq_num = kSeqNum; 632 uint16_t seq_num = kSeqNum;
631 uint32_t timestamp = kTimestamp; 633 uint32_t timestamp = kTimestamp;
632 rtp_sender_->SetStorePacketsStatus(true, 10); 634 rtp_sender_->SetStorePacketsStatus(true, 10);
633 size_t rtp_header_len = kRtpHeaderSize; 635 size_t rtp_header_len = kRtpHeaderSize;
634 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 636 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
635 kRtpExtensionTransmissionTimeOffset, 637 kRtpExtensionTransmissionTimeOffset,
(...skipping 16 matching lines...) Expand all
652 // Packet should be stored in a send bucket. 654 // Packet should be stored in a send bucket.
653 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), 655 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
654 kAllowRetransmission, 656 kAllowRetransmission,
655 RtpPacketSender::kNormalPriority)); 657 RtpPacketSender::kNormalPriority));
656 658
657 int total_packets_sent = 0; 659 int total_packets_sent = 0;
658 EXPECT_EQ(total_packets_sent, transport_.packets_sent()); 660 EXPECT_EQ(total_packets_sent, transport_.packets_sent());
659 661
660 const int kStoredTimeInMs = 100; 662 const int kStoredTimeInMs = 100;
661 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); 663 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
662 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, 664 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
663 PacketInfo::kNotAProbe); 665 PacketInfo::kNotAProbe);
664 // Packet should now be sent. This test doesn't verify the regular video 666 // Packet should now be sent. This test doesn't verify the regular video
665 // packet, since it is tested in another test. 667 // packet, since it is tested in another test.
666 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); 668 EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
667 timestamp += 90 * kStoredTimeInMs; 669 timestamp += 90 * kStoredTimeInMs;
668 670
669 // Send padding 4 times, waiting 50 ms between each. 671 // Send padding 4 times, waiting 50 ms between each.
670 for (int i = 0; i < 4; ++i) { 672 for (int i = 0; i < 4; ++i) {
671 const int kPaddingPeriodMs = 50; 673 const int kPaddingPeriodMs = 50;
672 const size_t kPaddingBytes = 100; 674 const size_t kPaddingBytes = 100;
(...skipping 22 matching lines...) Expand all
695 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); 697 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
696 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); 698 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
697 timestamp += 90 * kPaddingPeriodMs; 699 timestamp += 90 * kPaddingPeriodMs;
698 } 700 }
699 701
700 // Send a regular video packet again. 702 // Send a regular video packet again.
701 capture_time_ms = fake_clock_.TimeInMilliseconds(); 703 capture_time_ms = fake_clock_.TimeInMilliseconds();
702 packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); 704 packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
703 packet_size = packet->size(); 705 packet_size = packet->size();
704 706
705 EXPECT_CALL(mock_paced_sender_, 707 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
706 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)); 708 kSsrc, seq_num, _, _, _));
707 709
708 // Packet should be stored in a send bucket. 710 // Packet should be stored in a send bucket.
709 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), 711 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
710 kAllowRetransmission, 712 kAllowRetransmission,
711 RtpPacketSender::kNormalPriority)); 713 RtpPacketSender::kNormalPriority));
712 714
713 rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false, 715 rtp_sender_->TimeToSendPacket(kSsrc, seq_num, capture_time_ms, false,
714 PacketInfo::kNotAProbe); 716 PacketInfo::kNotAProbe);
715 // Process send bucket. 717 // Process send bucket.
716 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); 718 EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
717 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); 719 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
718 transport_.last_sent_packet().GetHeader(&rtp_header); 720 transport_.last_sent_packet().GetHeader(&rtp_header);
719 721
720 // Verify sequence number and timestamp. 722 // Verify sequence number and timestamp.
721 EXPECT_EQ(seq_num, rtp_header.sequenceNumber); 723 EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
722 EXPECT_EQ(timestamp, rtp_header.timestamp); 724 EXPECT_EQ(timestamp, rtp_header.timestamp);
723 // Verify transmission time offset. This packet is sent without delay. 725 // Verify transmission time offset. This packet is sent without delay.
724 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); 726 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
725 uint64_t expected_send_time = 727 uint64_t expected_send_time =
726 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); 728 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
727 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); 729 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
728 } 730 }
729 731
730 TEST_F(RtpSenderTest, OnSendPacketUpdated) { 732 TEST_F(RtpSenderTest, OnSendPacketUpdated) {
731 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 733 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
732 kRtpExtensionTransportSequenceNumber, 734 kRtpExtensionTransportSequenceNumber,
733 kTransportSequenceNumberExtensionId)); 735 kTransportSequenceNumberExtensionId));
734 rtp_sender_->SetStorePacketsStatus(true, 10); 736 rtp_sender_->SetStorePacketsStatus(true, 10);
735 737
736 EXPECT_CALL(send_packet_observer_, 738 EXPECT_CALL(send_packet_observer_,
737 OnSendPacket(kTransportSequenceNumber, _, _)) 739 OnSendPacket(kTransportSequenceNumber, _, _))
738 .Times(1); 740 .Times(1);
739 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) 741 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
740 .WillOnce(testing::Return(kTransportSequenceNumber)); 742 .WillOnce(testing::Return(kTransportSequenceNumber));
741 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); 743 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
744 .Times(1);
742 745
743 SendGenericPayload(); // Packet passed to pacer. 746 SendGenericPayload(); // Packet passed to pacer.
744 const bool kIsRetransmit = false; 747 const bool kIsRetransmit = false;
745 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), 748 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
746 kIsRetransmit, PacketInfo::kNotAProbe); 749 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
750 PacketInfo::kNotAProbe);
747 EXPECT_EQ(1, transport_.packets_sent()); 751 EXPECT_EQ(1, transport_.packets_sent());
748 } 752 }
749 753
750 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { 754 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
751 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 755 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
752 kRtpExtensionTransportSequenceNumber, 756 kRtpExtensionTransportSequenceNumber,
753 kTransportSequenceNumberExtensionId)); 757 kTransportSequenceNumberExtensionId));
754 rtp_sender_->SetStorePacketsStatus(true, 10); 758 rtp_sender_->SetStorePacketsStatus(true, 10);
755 759
756 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); 760 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
757 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) 761 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
758 .WillOnce(testing::Return(kTransportSequenceNumber)); 762 .WillOnce(testing::Return(kTransportSequenceNumber));
759 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); 763 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
764 .Times(1);
760 765
761 SendGenericPayload(); // Packet passed to pacer. 766 SendGenericPayload(); // Packet passed to pacer.
762 const bool kIsRetransmit = true; 767 const bool kIsRetransmit = true;
763 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), 768 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
764 kIsRetransmit, PacketInfo::kNotAProbe); 769 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
770 PacketInfo::kNotAProbe);
765 EXPECT_EQ(1, transport_.packets_sent()); 771 EXPECT_EQ(1, transport_.packets_sent());
766 } 772 }
767 773
768 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) { 774 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
769 rtp_sender_.reset(new RTPSender( 775 rtp_sender_.reset(new RTPSender(
770 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, 776 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
771 nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr, 777 nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
772 nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_)); 778 nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_));
779 rtp_sender_->SetSequenceNumber(kSeqNum);
780 rtp_sender_->SetSSRC(kSsrc);
773 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 781 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
774 kRtpExtensionTransportSequenceNumber, 782 kRtpExtensionTransportSequenceNumber,
775 kTransportSequenceNumberExtensionId)); 783 kTransportSequenceNumberExtensionId));
776 rtp_sender_->SetSequenceNumber(kSeqNum); 784 rtp_sender_->SetSequenceNumber(kSeqNum);
777 rtp_sender_->SetStorePacketsStatus(true, 10); 785 rtp_sender_->SetStorePacketsStatus(true, 10);
778 786
779 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); 787 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
780 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); 788 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
789 .Times(1);
781 790
782 SendGenericPayload(); // Packet passed to pacer. 791 SendGenericPayload(); // Packet passed to pacer.
783 const bool kIsRetransmit = false; 792 const bool kIsRetransmit = false;
784 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), 793 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
785 kIsRetransmit, PacketInfo::kNotAProbe); 794 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
795 PacketInfo::kNotAProbe);
786 EXPECT_EQ(1, transport_.packets_sent()); 796 EXPECT_EQ(1, transport_.packets_sent());
787 } 797 }
788 798
789 TEST_F(RtpSenderTest, SendRedundantPayloads) { 799 TEST_F(RtpSenderTest, SendRedundantPayloads) {
790 MockTransport transport; 800 MockTransport transport;
791 rtp_sender_.reset(new RTPSender( 801 rtp_sender_.reset(new RTPSender(
792 false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr, 802 false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
793 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr, 803 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
794 &retransmission_rate_limiter_)); 804 &retransmission_rate_limiter_));
795
796 rtp_sender_->SetSequenceNumber(kSeqNum); 805 rtp_sender_->SetSequenceNumber(kSeqNum);
806 rtp_sender_->SetSSRC(kSsrc);
797 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); 807 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
798 808
799 uint16_t seq_num = kSeqNum; 809 uint16_t seq_num = kSeqNum;
800 rtp_sender_->SetStorePacketsStatus(true, 10); 810 rtp_sender_->SetStorePacketsStatus(true, 10);
801 int32_t rtp_header_len = kRtpHeaderSize; 811 int32_t rtp_header_len = kRtpHeaderSize;
802 EXPECT_EQ( 812 EXPECT_EQ(
803 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 813 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
804 kAbsoluteSendTimeExtensionId)); 814 kAbsoluteSendTimeExtensionId));
805 rtp_header_len += 4; // 4 bytes extension. 815 rtp_header_len += 4; // 4 bytes extension.
806 rtp_header_len += 4; // 4 extra bytes common to all extension headers. 816 rtp_header_len += 4; // 4 extra bytes common to all extension headers.
807 817
808 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); 818 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
809 rtp_sender_->SetRtxSsrc(1234); 819 rtp_sender_->SetRtxSsrc(1234);
810 820
811 const size_t kNumPayloadSizes = 10; 821 const size_t kNumPayloadSizes = 10;
812 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 822 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
813 750, 800, 850, 900, 950}; 823 750, 800, 850, 900, 950};
814 // Expect all packets go through the pacer. 824 // Expect all packets go through the pacer.
815 EXPECT_CALL(mock_paced_sender_, 825 EXPECT_CALL(mock_paced_sender_,
816 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) 826 InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _))
817 .Times(kNumPayloadSizes); 827 .Times(kNumPayloadSizes);
818 EXPECT_CALL(mock_rtc_event_log_, 828 EXPECT_CALL(mock_rtc_event_log_,
819 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) 829 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
820 .Times(kNumPayloadSizes); 830 .Times(kNumPayloadSizes);
821 831
822 // Send 10 packets of increasing size. 832 // Send 10 packets of increasing size.
823 for (size_t i = 0; i < kNumPayloadSizes; ++i) { 833 for (size_t i = 0; i < kNumPayloadSizes; ++i) {
824 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 834 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
825 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true)); 835 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true));
826 SendPacket(capture_time_ms, kPayloadSizes[i]); 836 SendPacket(capture_time_ms, kPayloadSizes[i]);
827 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, 837 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
828 PacketInfo::kNotAProbe); 838 PacketInfo::kNotAProbe);
829 fake_clock_.AdvanceTimeMilliseconds(33); 839 fake_clock_.AdvanceTimeMilliseconds(33);
830 } 840 }
831 841
832 EXPECT_CALL(mock_rtc_event_log_, 842 EXPECT_CALL(mock_rtc_event_log_,
833 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) 843 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
834 .Times(::testing::AtLeast(4)); 844 .Times(::testing::AtLeast(4));
835 845
836 // The amount of padding to send it too small to send a payload packet. 846 // The amount of padding to send it too small to send a payload packet.
837 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) 847 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after
919 rtp_sender_->SetSendPayloadType(kMediaPayloadType); 929 rtp_sender_->SetSendPayloadType(kMediaPayloadType);
920 rtp_sender_->SetStorePacketsStatus(true, 10); 930 rtp_sender_->SetStorePacketsStatus(true, 10);
921 931
922 // Parameters selected to generate a single FEC packet per media packet. 932 // Parameters selected to generate a single FEC packet per media packet.
923 FecProtectionParams params; 933 FecProtectionParams params;
924 params.fec_rate = 15; 934 params.fec_rate = 15;
925 params.max_fec_frames = 1; 935 params.max_fec_frames = 1;
926 params.fec_mask_type = kFecMaskRandom; 936 params.fec_mask_type = kFecMaskRandom;
927 rtp_sender_->SetFecParameters(params, params); 937 rtp_sender_->SetFecParameters(params, params);
928 938
929 uint16_t media_seq_num; 939 EXPECT_CALL(mock_paced_sender_,
940 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, kSeqNum,
941 _, _, false));
942 uint16_t flexfec_seq_num;
930 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, 943 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
931 kMediaSsrc, _, _, _, false)) 944 kFlexfecSsrc, _, _, _, false))
932 .WillOnce(testing::SaveArg<2>(&media_seq_num)); 945 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num));
933 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
934 kFlexfecSsrc, _, _, _, false));
935 SendGenericPayload(); 946 SendGenericPayload();
936 // TODO(brandtr): Make these tests stricter when the FlexFEC packets are no
937 // longer lost between PacedSender and RTPSender.
938 EXPECT_CALL(mock_rtc_event_log_, 947 EXPECT_CALL(mock_rtc_event_log_,
939 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) 948 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
940 .Times(testing::AtLeast(1)); 949 .Times(2);
941 EXPECT_TRUE(rtp_sender_->TimeToSendPacket( 950 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(
942 media_seq_num, fake_clock_.TimeInMilliseconds(), false, 0)); 951 kMediaSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, 0));
943 EXPECT_LE(1, transport_.packets_sent()); 952 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num,
953 fake_clock_.TimeInMilliseconds(),
954 false, 0));
955 ASSERT_EQ(2, transport_.packets_sent());
944 const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; 956 const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
945 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType()); 957 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
946 EXPECT_EQ(media_seq_num, media_packet.SequenceNumber()); 958 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber());
947 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc()); 959 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
960 const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
961 EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
962 EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
963 EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
948 } 964 }
949 965
950 TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) { 966 TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
951 constexpr int kMediaPayloadType = 127; 967 constexpr int kMediaPayloadType = 127;
952 constexpr int kFlexfecPayloadType = 118; 968 constexpr int kFlexfecPayloadType = 118;
953 constexpr uint32_t kMediaSsrc = 1234; 969 constexpr uint32_t kMediaSsrc = 1234;
954 constexpr uint32_t kFlexfecSsrc = 5678; 970 constexpr uint32_t kFlexfecSsrc = 5678;
955 const std::vector<RtpExtension> kNoRtpExtensions; 971 const std::vector<RtpExtension> kNoRtpExtensions;
956 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, 972 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
957 kNoRtpExtensions, &fake_clock_); 973 kNoRtpExtensions, &fake_clock_);
(...skipping 514 matching lines...) Expand 10 before | Expand all | Expand 10 after
1472 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); 1488 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0));
1473 EXPECT_EQ(kVideoRotation_90, 1489 EXPECT_EQ(kVideoRotation_90,
1474 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); 1490 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1));
1475 EXPECT_EQ(kVideoRotation_180, 1491 EXPECT_EQ(kVideoRotation_180,
1476 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); 1492 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2));
1477 EXPECT_EQ(kVideoRotation_270, 1493 EXPECT_EQ(kVideoRotation_270,
1478 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); 1494 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
1479 } 1495 }
1480 1496
1481 } // namespace webrtc 1497 } // namespace webrtc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698