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

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

Issue 2269923003: Don't include RTP headers in send-side BWE. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Tests passing. Created 4 years, 3 months 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
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtp_sender.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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
11 #include <list> 11 #include <list>
12 #include <memory> 12 #include <memory>
13 #include <vector> 13 #include <vector>
14 14
15 #include "testing/gmock/include/gmock/gmock.h" 15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h" 16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "webrtc/base/buffer.h" 17 #include "webrtc/base/buffer.h"
18 #include "webrtc/base/rate_limiter.h" 18 #include "webrtc/base/rate_limiter.h"
19 #include "webrtc/call/mock/mock_rtc_event_log.h" 19 #include "webrtc/call/mock/mock_rtc_event_log.h"
20 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" 20 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
21 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" 21 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
22 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" 22 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
23 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h" 24 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
24 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
25 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
26 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" 27 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
27 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" 28 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
28 #include "webrtc/system_wrappers/include/stl_util.h" 29 #include "webrtc/system_wrappers/include/stl_util.h"
29 #include "webrtc/test/mock_transport.h" 30 #include "webrtc/test/mock_transport.h"
30 #include "webrtc/typedefs.h" 31 #include "webrtc/typedefs.h"
31 32
32 namespace webrtc { 33 namespace webrtc {
(...skipping 10 matching lines...) Expand all
43 const int kMaxPacketLength = 1500; 44 const int kMaxPacketLength = 1500;
44 const uint32_t kAbsoluteSendTime = 0x00aabbcc; 45 const uint32_t kAbsoluteSendTime = 0x00aabbcc;
45 const uint8_t kAudioLevel = 0x5a; 46 const uint8_t kAudioLevel = 0x5a;
46 const uint16_t kTransportSequenceNumber = 0xaabbu; 47 const uint16_t kTransportSequenceNumber = 0xaabbu;
47 const uint8_t kAudioLevelExtensionId = 9; 48 const uint8_t kAudioLevelExtensionId = 9;
48 const int kAudioPayload = 103; 49 const int kAudioPayload = 103;
49 const uint64_t kStartTime = 123456789; 50 const uint64_t kStartTime = 123456789;
50 const size_t kMaxPaddingSize = 224u; 51 const size_t kMaxPaddingSize = 224u;
51 const int kVideoRotationExtensionId = 5; 52 const int kVideoRotationExtensionId = 5;
52 const VideoRotation kRotation = kVideoRotation_270; 53 const VideoRotation kRotation = kVideoRotation_270;
54 const size_t kGenericHeaderLength = 1;
55 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
53 56
54 using testing::_; 57 using testing::_;
55 58
56 const uint8_t* GetPayloadData(const RTPHeader& rtp_header, 59 const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
57 const uint8_t* packet) { 60 const uint8_t* packet) {
58 return packet + rtp_header.headerLength; 61 return packet + rtp_header.headerLength;
59 } 62 }
60 63
61 size_t GetPayloadDataLength(const RTPHeader& rtp_header, 64 size_t GetPayloadDataLength(const RTPHeader& rtp_header,
62 const size_t packet_length) { 65 const size_t packet_length) {
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
121 : public TransportSequenceNumberAllocator { 124 : public TransportSequenceNumberAllocator {
122 public: 125 public:
123 MOCK_METHOD0(AllocateSequenceNumber, uint16_t()); 126 MOCK_METHOD0(AllocateSequenceNumber, uint16_t());
124 }; 127 };
125 128
126 class MockSendPacketObserver : public SendPacketObserver { 129 class MockSendPacketObserver : public SendPacketObserver {
127 public: 130 public:
128 MOCK_METHOD3(OnSendPacket, void(uint16_t, int64_t, uint32_t)); 131 MOCK_METHOD3(OnSendPacket, void(uint16_t, int64_t, uint32_t));
129 }; 132 };
130 133
134 class MockTransportFeedbackObserver : public TransportFeedbackObserver {
135 public:
136 MOCK_METHOD3(AddPacket, void(uint16_t, size_t, int));
137 MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
138 };
139
131 class RtpSenderTest : public ::testing::Test { 140 class RtpSenderTest : public ::testing::Test {
132 protected: 141 protected:
133 RtpSenderTest() 142 RtpSenderTest()
134 : fake_clock_(kStartTime), 143 : fake_clock_(kStartTime),
135 mock_rtc_event_log_(), 144 mock_rtc_event_log_(),
136 mock_paced_sender_(), 145 mock_paced_sender_(),
137 retransmission_rate_limiter_(&fake_clock_, 1000), 146 retransmission_rate_limiter_(&fake_clock_, 1000),
138 rtp_sender_(), 147 rtp_sender_(),
139 payload_(kPayload), 148 payload_(kPayload),
140 transport_(), 149 transport_(),
(...skipping 10 matching lines...) Expand all
151 rtp_sender_->SetSequenceNumber(kSeqNum); 160 rtp_sender_->SetSequenceNumber(kSeqNum);
152 rtp_sender_->SetSendPayloadType(kPayload); 161 rtp_sender_->SetSendPayloadType(kPayload);
153 rtp_sender_->SetTimestampOffset(0); 162 rtp_sender_->SetTimestampOffset(0);
154 } 163 }
155 164
156 SimulatedClock fake_clock_; 165 SimulatedClock fake_clock_;
157 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_; 166 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_;
158 MockRtpPacketSender mock_paced_sender_; 167 MockRtpPacketSender mock_paced_sender_;
159 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_; 168 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_;
160 testing::StrictMock<MockSendPacketObserver> send_packet_observer_; 169 testing::StrictMock<MockSendPacketObserver> send_packet_observer_;
170 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_;
161 RateLimiter retransmission_rate_limiter_; 171 RateLimiter retransmission_rate_limiter_;
162 std::unique_ptr<RTPSender> rtp_sender_; 172 std::unique_ptr<RTPSender> rtp_sender_;
163 int payload_; 173 int payload_;
164 LoopbackTransportTest transport_; 174 LoopbackTransportTest transport_;
165 const bool kMarkerBit; 175 const bool kMarkerBit;
166 uint8_t packet_[kMaxPacketLength]; 176 uint8_t packet_[kMaxPacketLength];
167 177
168 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) { 178 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
169 VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0); 179 VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0);
170 } 180 }
(...skipping 20 matching lines...) Expand all
191 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); 201 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
192 ASSERT_GE(rtp_length, 0); 202 ASSERT_GE(rtp_length, 0);
193 203
194 // Packet should be stored in a send bucket. 204 // Packet should be stored in a send bucket.
195 EXPECT_TRUE(rtp_sender_->SendToNetwork( 205 EXPECT_TRUE(rtp_sender_->SendToNetwork(
196 packet_, payload_length, rtp_length, capture_time_ms, 206 packet_, payload_length, rtp_length, capture_time_ms,
197 kAllowRetransmission, RtpPacketSender::kNormalPriority)); 207 kAllowRetransmission, RtpPacketSender::kNormalPriority));
198 } 208 }
199 209
200 void SendGenericPayload() { 210 void SendGenericPayload() {
201 const uint8_t kPayload[] = {47, 11, 32, 93, 89};
202 const uint32_t kTimestamp = 1234; 211 const uint32_t kTimestamp = 1234;
203 const uint8_t kPayloadType = 127; 212 const uint8_t kPayloadType = 127;
204 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); 213 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
205 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; 214 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
206 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, 215 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
207 0, 1500)); 216 0, 1500));
208 217
209 EXPECT_TRUE(rtp_sender_->SendOutgoingData( 218 EXPECT_TRUE(rtp_sender_->SendOutgoingData(
210 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayload, 219 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData,
211 sizeof(kPayload), nullptr, nullptr, nullptr)); 220 sizeof(kPayloadData), nullptr, nullptr, nullptr));
212 } 221 }
213 }; 222 };
214 223
215 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our 224 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
216 // default code path. 225 // default code path.
217 class RtpSenderTestWithoutPacer : public RtpSenderTest { 226 class RtpSenderTestWithoutPacer : public RtpSenderTest {
218 public: 227 public:
219 void SetUp() override { SetUpRtpSender(false); } 228 void SetUp() override { SetUpRtpSender(false); }
220 }; 229 };
221 230
(...skipping 264 matching lines...) Expand 10 before | Expand all | Expand 10 after
486 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr); 495 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
487 496
488 ASSERT_TRUE(valid_rtp_header2); 497 ASSERT_TRUE(valid_rtp_header2);
489 VerifyRTPHeaderCommon(rtp_header2); 498 VerifyRTPHeaderCommon(rtp_header2);
490 EXPECT_EQ(length, rtp_header2.headerLength); 499 EXPECT_EQ(length, rtp_header2.headerLength);
491 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime); 500 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime);
492 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); 501 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
493 } 502 }
494 503
495 TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) { 504 TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
505 rtp_sender_.reset(new RTPSender(
506 false, &fake_clock_, &transport_, nullptr,
507 &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
508 &mock_rtc_event_log_, &send_packet_observer_,
509 &retransmission_rate_limiter_));
496 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 510 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
497 kRtpExtensionTransportSequenceNumber, 511 kRtpExtensionTransportSequenceNumber,
498 kTransportSequenceNumberExtensionId)); 512 kTransportSequenceNumberExtensionId));
499 513
500 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) 514 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
501 .WillOnce(testing::Return(kTransportSequenceNumber)); 515 .WillOnce(testing::Return(kTransportSequenceNumber));
502 EXPECT_CALL(send_packet_observer_, 516 EXPECT_CALL(send_packet_observer_,
503 OnSendPacket(kTransportSequenceNumber, _, _)) 517 OnSendPacket(kTransportSequenceNumber, _, _))
504 .Times(1); 518 .Times(1);
519 EXPECT_CALL(feedback_observer_,
520 AddPacket(kTransportSequenceNumber,
521 sizeof(kPayloadData) + kGenericHeaderLength,
522 PacketInfo::kNotAProbe))
523 .Times(1);
505 524
506 SendGenericPayload(); 525 SendGenericPayload();
507 526
508 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, 527 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
509 transport_.last_sent_packet_len_); 528 transport_.last_sent_packet_len_);
510 webrtc::RTPHeader rtp_header; 529 webrtc::RTPHeader rtp_header;
511 RtpHeaderExtensionMap map; 530 RtpHeaderExtensionMap map;
512 map.Register(kRtpExtensionTransportSequenceNumber, 531 map.Register(kRtpExtensionTransportSequenceNumber,
513 kTransportSequenceNumberExtensionId); 532 kTransportSequenceNumberExtensionId);
514 EXPECT_TRUE(rtp_parser.Parse(&rtp_header, &map)); 533 EXPECT_TRUE(rtp_parser.Parse(&rtp_header, &map));
(...skipping 213 matching lines...) Expand 10 before | Expand all | Expand 10 after
728 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel); 747 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel);
729 EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber); 748 EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber);
730 749
731 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset); 750 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
732 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); 751 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
733 EXPECT_FALSE(rtp_header2.extension.voiceActivity); 752 EXPECT_FALSE(rtp_header2.extension.voiceActivity);
734 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); 753 EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
735 EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber); 754 EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber);
736 } 755 }
737 756
757 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
758 rtp_sender_.reset(new RTPSender(
759 false, &fake_clock_, &transport_, &mock_paced_sender_,
760 &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
761 &mock_rtc_event_log_, &send_packet_observer_,
762 &retransmission_rate_limiter_));
763 rtp_sender_->SetStorePacketsStatus(true, 10);
764 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
765 kRtpExtensionTransportSequenceNumber,
766 kTransportSequenceNumberExtensionId));
767
768 uint16_t seq_num = 0;
769 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
770 .Times(1).WillRepeatedly(testing::SaveArg<2>(&seq_num));
771 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
772 .WillOnce(testing::Return(kTransportSequenceNumber));
773 EXPECT_CALL(send_packet_observer_,
774 OnSendPacket(kTransportSequenceNumber, _, _))
775 .Times(1);
776 const int kProbeClusterId = 1;
777 EXPECT_CALL(
778 feedback_observer_,
779 AddPacket(kTransportSequenceNumber,
780 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId))
781 .Times(1);
782
783 SendGenericPayload();
784 rtp_sender_->TimeToSendPacket(seq_num, fake_clock_.TimeInMilliseconds(),
785 false, kProbeClusterId);
786
787 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
788 transport_.last_sent_packet_len_);
789 webrtc::RTPHeader rtp_header;
790 RtpHeaderExtensionMap map;
791 map.Register(kRtpExtensionTransportSequenceNumber,
792 kTransportSequenceNumberExtensionId);
793 EXPECT_TRUE(rtp_parser.Parse(&rtp_header, &map));
794 EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
795 EXPECT_EQ(kTransportSequenceNumber,
796 rtp_header.extension.transportSequenceNumber);
797 EXPECT_EQ(transport_.last_packet_id_,
798 rtp_header.extension.transportSequenceNumber);
799 }
800
738 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { 801 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
739 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, 802 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
740 _, kSeqNum, _, _, _)); 803 _, kSeqNum, _, _, _));
741 EXPECT_CALL(mock_rtc_event_log_, 804 EXPECT_CALL(mock_rtc_event_log_,
742 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); 805 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
743 806
744 rtp_sender_->SetStorePacketsStatus(true, 10); 807 rtp_sender_->SetStorePacketsStatus(true, 10);
745 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 808 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
746 kRtpExtensionTransmissionTimeOffset, 809 kRtpExtensionTransmissionTimeOffset,
747 kTransmissionTimeOffsetExtensionId)); 810 kTransmissionTimeOffsetExtensionId));
(...skipping 875 matching lines...) Expand 10 before | Expand all | Expand 10 after
1623 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), 1686 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
1624 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); 1687 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
1625 1688
1626 // Verify that this packet does have CVO byte. 1689 // Verify that this packet does have CVO byte.
1627 VerifyCVOPacket( 1690 VerifyCVOPacket(
1628 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), 1691 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
1629 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, 1692 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
1630 hdr.rotation); 1693 hdr.rotation);
1631 } 1694 }
1632 } // namespace webrtc 1695 } // namespace webrtc
OLDNEW
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtp_sender.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698