blob: f738a31a8596016eab744c6f2acb6838f3960bad [file] [log] [blame]
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001/*
phoglund@webrtc.org78088c22012-02-07 14:56:45 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00003 *
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
kwiberg84be5112016-04-27 01:19:58 -070011#include <memory>
danilchapb8b6fbb2015-12-10 05:05:27 -080012#include <vector>
13
Karl Wiberg918f50c2018-07-05 11:40:33 +020014#include "absl/memory/memory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020015#include "api/video/video_timing.h"
Elad Alon4a87e1c2017-10-03 16:11:34 +020016#include "logging/rtc_event_log/events/rtc_event.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020017#include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
18#include "modules/rtp_rtcp/include/rtp_cvo.h"
19#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
20#include "modules/rtp_rtcp/include/rtp_header_parser.h"
21#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
22#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
23#include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
24#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
25#include "modules/rtp_rtcp/source/rtp_packet_received.h"
26#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
27#include "modules/rtp_rtcp/source/rtp_sender.h"
28#include "modules/rtp_rtcp/source/rtp_sender_video.h"
29#include "modules/rtp_rtcp/source/rtp_utility.h"
30#include "rtc_base/arraysize.h"
31#include "rtc_base/buffer.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020032#include "rtc_base/rate_limiter.h"
33#include "test/field_trial.h"
34#include "test/gmock.h"
35#include "test/gtest.h"
36#include "test/mock_transport.h"
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000037
38namespace webrtc {
39
andrew@webrtc.org8a442592011-12-16 21:24:30 +000040namespace {
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +000041const int kTransmissionTimeOffsetExtensionId = 1;
42const int kAbsoluteSendTimeExtensionId = 14;
sprang@webrtc.org30933902015-03-17 14:33:12 +000043const int kTransportSequenceNumberExtensionId = 13;
ilnik04f4d122017-06-19 07:18:55 -070044const int kVideoTimingExtensionId = 12;
Steve Anton296a0ce2018-03-22 15:17:27 -070045const int kMidExtensionId = 11;
andrew@webrtc.org8a442592011-12-16 21:24:30 +000046const int kPayload = 100;
Shao Changbine62202f2015-04-21 20:24:50 +080047const int kRtxPayload = 98;
andrew@webrtc.org8a442592011-12-16 21:24:30 +000048const uint32_t kTimestamp = 10;
49const uint16_t kSeqNum = 33;
brandtr9dfff292016-11-14 05:14:50 -080050const uint32_t kSsrc = 725242;
andrew@webrtc.org8a442592011-12-16 21:24:30 +000051const int kMaxPacketLength = 1500;
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +000052const uint8_t kAudioLevel = 0x5a;
sprang@webrtc.org30933902015-03-17 14:33:12 +000053const uint16_t kTransportSequenceNumber = 0xaabbu;
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +000054const uint8_t kAudioLevelExtensionId = 9;
55const int kAudioPayload = 103;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +000056const uint64_t kStartTime = 123456789;
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +000057const size_t kMaxPaddingSize = 224u;
guoweis@webrtc.org45362892015-03-04 22:55:15 +000058const int kVideoRotationExtensionId = 5;
Stefan Holmera246cfb2016-08-23 17:51:42 +020059const size_t kGenericHeaderLength = 1;
60const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
spranga8ae6f22017-09-04 07:23:56 -070061const int64_t kDefaultExpectedRetransmissionTimeMs = 125;
andrew@webrtc.org8a442592011-12-16 21:24:30 +000062
Danil Chapovalov5e57b172016-09-02 19:15:59 +020063using ::testing::_;
64using ::testing::ElementsAreArray;
sprang168794c2017-07-06 04:38:06 -070065using ::testing::Invoke;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +000066
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +000067uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
Stefan Holmer0a87ffc2015-10-21 13:41:48 +020068 return (((time_ms << 18) + 500) / 1000) & 0x00ffffff;
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +000069}
70
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +000071class LoopbackTransportTest : public webrtc::Transport {
72 public:
Petter Strandmark26bc6692018-05-29 08:43:35 +020073 LoopbackTransportTest() : total_bytes_sent_(0) {
danilchap12ba1862016-10-26 02:41:55 -070074 receivers_extensions_.Register(kRtpExtensionTransmissionTimeOffset,
75 kTransmissionTimeOffsetExtensionId);
76 receivers_extensions_.Register(kRtpExtensionAbsoluteSendTime,
77 kAbsoluteSendTimeExtensionId);
78 receivers_extensions_.Register(kRtpExtensionTransportSequenceNumber,
79 kTransportSequenceNumberExtensionId);
80 receivers_extensions_.Register(kRtpExtensionVideoRotation,
81 kVideoRotationExtensionId);
82 receivers_extensions_.Register(kRtpExtensionAudioLevel,
83 kAudioLevelExtensionId);
ilnik04f4d122017-06-19 07:18:55 -070084 receivers_extensions_.Register(kRtpExtensionVideoTiming,
85 kVideoTimingExtensionId);
Steve Anton296a0ce2018-03-22 15:17:27 -070086 receivers_extensions_.Register(kRtpExtensionMid, kMidExtensionId);
guoweis@webrtc.org45362892015-03-04 22:55:15 +000087 }
danilchap12ba1862016-10-26 02:41:55 -070088
stefan1d8a5062015-10-02 03:39:33 -070089 bool SendRtp(const uint8_t* data,
90 size_t len,
91 const PacketOptions& options) override {
Petter Strandmark26bc6692018-05-29 08:43:35 +020092 last_options_ = options;
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +000093 total_bytes_sent_ += len;
danilchap12ba1862016-10-26 02:41:55 -070094 sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_));
95 EXPECT_TRUE(sent_packets_.back().Parse(data, len));
pbos2d566682015-09-28 09:59:31 -070096 return true;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +000097 }
danilchap162abd32015-12-10 02:39:40 -080098 bool SendRtcp(const uint8_t* data, size_t len) override { return false; }
danilchap12ba1862016-10-26 02:41:55 -070099 const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
100 int packets_sent() { return sent_packets_.size(); }
101
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000102 size_t total_bytes_sent_;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200103 PacketOptions last_options_;
danilchap12ba1862016-10-26 02:41:55 -0700104 std::vector<RtpPacketReceived> sent_packets_;
105
106 private:
107 RtpHeaderExtensionMap receivers_extensions_;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000108};
109
Elad Alon4a87e1c2017-10-03 16:11:34 +0200110MATCHER_P(SameRtcEventTypeAs, value, "") {
111 return value == arg->GetType();
112}
113
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000114} // namespace
115
sprangebbf8a82015-09-21 15:11:14 -0700116class MockRtpPacketSender : public RtpPacketSender {
117 public:
118 MockRtpPacketSender() {}
119 virtual ~MockRtpPacketSender() {}
120
Peter Boströme23e7372015-10-08 11:44:14 +0200121 MOCK_METHOD6(InsertPacket,
122 void(Priority priority,
sprangebbf8a82015-09-21 15:11:14 -0700123 uint32_t ssrc,
124 uint16_t sequence_number,
125 int64_t capture_time_ms,
126 size_t bytes,
127 bool retransmission));
128};
129
Stefan Holmerf5dca482016-01-27 12:58:51 +0100130class MockTransportSequenceNumberAllocator
131 : public TransportSequenceNumberAllocator {
132 public:
133 MOCK_METHOD0(AllocateSequenceNumber, uint16_t());
134};
135
asapersson35151f32016-05-02 23:44:01 -0700136class MockSendPacketObserver : public SendPacketObserver {
137 public:
138 MOCK_METHOD3(OnSendPacket, void(uint16_t, int64_t, uint32_t));
139};
140
Stefan Holmera246cfb2016-08-23 17:51:42 +0200141class MockTransportFeedbackObserver : public TransportFeedbackObserver {
142 public:
elad.alond12a8e12017-03-23 11:04:48 -0700143 MOCK_METHOD4(AddPacket,
144 void(uint32_t, uint16_t, size_t, const PacedPacketInfo&));
Stefan Holmera246cfb2016-08-23 17:51:42 +0200145 MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
elad.alonf9490002017-03-06 05:32:21 -0800146 MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>());
Stefan Holmera246cfb2016-08-23 17:51:42 +0200147};
148
minyue3a407ee2017-04-03 01:10:33 -0700149class MockOverheadObserver : public OverheadObserver {
150 public:
151 MOCK_METHOD1(OnOverheadChanged, void(size_t overhead_bytes_per_packet));
152};
153
154class RtpSenderTest : public ::testing::TestWithParam<bool> {
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000155 protected:
156 RtpSenderTest()
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000157 : fake_clock_(kStartTime),
terelius429c3452016-01-21 05:42:04 -0800158 mock_rtc_event_log_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000159 mock_paced_sender_(),
sprangcd349d92016-07-13 09:11:28 -0700160 retransmission_rate_limiter_(&fake_clock_, 1000),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000161 rtp_sender_(),
162 payload_(kPayload),
163 transport_(),
minyue3a407ee2017-04-03 01:10:33 -0700164 kMarkerBit(true),
165 field_trials_(GetParam() ? "WebRTC-SendSideBwe-WithOverhead/Enabled/"
166 : "") {}
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +0000167
Erik Språng7b52f102018-02-07 14:37:37 +0100168 void SetUp() override { SetUpRtpSender(true, false); }
Peter Boströme23e7372015-10-08 11:44:14 +0200169
Erik Språng7b52f102018-02-07 14:37:37 +0100170 void SetUpRtpSender(bool pacer, bool populate_network2) {
asapersson35151f32016-05-02 23:44:01 -0700171 rtp_sender_.reset(new RTPSender(
172 false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
brandtrdbdb3f12016-11-10 05:04:48 -0800173 nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
sprangcd349d92016-07-13 09:11:28 -0700174 &mock_rtc_event_log_, &send_packet_observer_,
Erik Språng7b52f102018-02-07 14:37:37 +0100175 &retransmission_rate_limiter_, nullptr, populate_network2));
brandtr9dfff292016-11-14 05:14:50 -0800176 rtp_sender_->SetSequenceNumber(kSeqNum);
danilchap71fead22016-08-18 02:01:49 -0700177 rtp_sender_->SetTimestampOffset(0);
brandtr9dfff292016-11-14 05:14:50 -0800178 rtp_sender_->SetSSRC(kSsrc);
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +0000179 }
180
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +0000181 SimulatedClock fake_clock_;
stefana23fc622016-07-28 07:56:38 -0700182 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_;
sprangebbf8a82015-09-21 15:11:14 -0700183 MockRtpPacketSender mock_paced_sender_;
stefana23fc622016-07-28 07:56:38 -0700184 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_;
185 testing::StrictMock<MockSendPacketObserver> send_packet_observer_;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200186 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_;
sprangcd349d92016-07-13 09:11:28 -0700187 RateLimiter retransmission_rate_limiter_;
kwiberg84be5112016-04-27 01:19:58 -0700188 std::unique_ptr<RTPSender> rtp_sender_;
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +0000189 int payload_;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000190 LoopbackTransportTest transport_;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000191 const bool kMarkerBit;
minyue3a407ee2017-04-03 01:10:33 -0700192 test::ScopedFieldTrials field_trials_;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000193
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +0000194 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
danilchapd9e62f52016-01-14 14:55:19 -0800195 VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000196 }
197
198 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header, bool marker_bit) {
danilchapd9e62f52016-01-14 14:55:19 -0800199 VerifyRTPHeaderCommon(rtp_header, marker_bit, 0);
200 }
201
202 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header,
203 bool marker_bit,
204 uint8_t number_of_csrcs) {
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000205 EXPECT_EQ(marker_bit, rtp_header.markerBit);
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +0000206 EXPECT_EQ(payload_, rtp_header.payloadType);
207 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
208 EXPECT_EQ(kTimestamp, rtp_header.timestamp);
209 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
danilchapd9e62f52016-01-14 14:55:19 -0800210 EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000211 EXPECT_EQ(0U, rtp_header.paddingLength);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000212 }
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000213
danilchapb6f1fb52016-10-19 06:11:39 -0700214 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(int payload_type,
215 bool marker_bit,
216 uint32_t timestamp,
217 int64_t capture_time_ms) {
218 auto packet = rtp_sender_->AllocatePacket();
219 packet->SetPayloadType(payload_type);
220 packet->SetMarker(marker_bit);
221 packet->SetTimestamp(timestamp);
222 packet->set_capture_time_ms(capture_time_ms);
223 EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
224 return packet;
225 }
226
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000227 void SendPacket(int64_t capture_time_ms, int payload_length) {
228 uint32_t timestamp = capture_time_ms * 90;
danilchapb6f1fb52016-10-19 06:11:39 -0700229 auto packet =
230 BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
231 packet->AllocatePayload(payload_length);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000232
233 // Packet should be stored in a send bucket.
danilchapb6f1fb52016-10-19 06:11:39 -0700234 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
235 kAllowRetransmission,
236 RtpPacketSender::kNormalPriority));
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000237 }
asapersson35151f32016-05-02 23:44:01 -0700238
239 void SendGenericPayload() {
asapersson35151f32016-05-02 23:44:01 -0700240 const uint32_t kTimestamp = 1234;
241 const uint8_t kPayloadType = 127;
242 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
243 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
244 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
245 0, 1500));
246
Sami Kalliomäki426a80c2018-08-08 11:37:59 +0200247 RTPVideoHeader video_header;
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700248 EXPECT_TRUE(rtp_sender_->SendOutgoingData(
Stefan Holmera246cfb2016-08-23 17:51:42 +0200249 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData,
Sami Kalliomäki426a80c2018-08-08 11:37:59 +0200250 sizeof(kPayloadData), nullptr, &video_header, nullptr,
spranga8ae6f22017-09-04 07:23:56 -0700251 kDefaultExpectedRetransmissionTimeMs));
asapersson35151f32016-05-02 23:44:01 -0700252 }
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000253};
254
Peter Boströme23e7372015-10-08 11:44:14 +0200255// TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
256// default code path.
257class RtpSenderTestWithoutPacer : public RtpSenderTest {
258 public:
Erik Språng7b52f102018-02-07 14:37:37 +0100259 void SetUp() override { SetUpRtpSender(false, false); }
Peter Boströme23e7372015-10-08 11:44:14 +0200260};
261
spranga8ae6f22017-09-04 07:23:56 -0700262class TestRtpSenderVideo : public RTPSenderVideo {
263 public:
264 TestRtpSenderVideo(Clock* clock,
265 RTPSender* rtp_sender,
266 FlexfecSender* flexfec_sender)
267 : RTPSenderVideo(clock, rtp_sender, flexfec_sender) {}
268 ~TestRtpSenderVideo() override {}
269
270 StorageType GetStorageType(const RTPVideoHeader& header,
271 int32_t retransmission_settings,
272 int64_t expected_retransmission_time_ms) {
273 return RTPSenderVideo::GetStorageType(GetTemporalId(header),
274 retransmission_settings,
275 expected_retransmission_time_ms);
276 }
277};
278
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000279class RtpSenderVideoTest : public RtpSenderTest {
280 protected:
danilchap162abd32015-12-10 02:39:40 -0800281 void SetUp() override {
Peter Boströme23e7372015-10-08 11:44:14 +0200282 // TODO(pbos): Set up to use pacer.
Erik Språng7b52f102018-02-07 14:37:37 +0100283 SetUpRtpSender(false, false);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000284 rtp_sender_video_.reset(
spranga8ae6f22017-09-04 07:23:56 -0700285 new TestRtpSenderVideo(&fake_clock_, rtp_sender_.get(), nullptr));
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000286 }
spranga8ae6f22017-09-04 07:23:56 -0700287 std::unique_ptr<TestRtpSenderVideo> rtp_sender_video_;
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000288};
289
minyue3a407ee2017-04-03 01:10:33 -0700290TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200291 // Configure rtp_sender with csrc.
292 std::vector<uint32_t> csrcs;
293 csrcs.push_back(0x23456789);
294 rtp_sender_->SetCsrcs(csrcs);
295
296 auto packet = rtp_sender_->AllocatePacket();
297
298 ASSERT_TRUE(packet);
299 EXPECT_EQ(rtp_sender_->SSRC(), packet->Ssrc());
300 EXPECT_EQ(csrcs, packet->Csrcs());
301}
302
minyue3a407ee2017-04-03 01:10:33 -0700303TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200304 // Configure rtp_sender with extensions.
305 ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
306 kRtpExtensionTransmissionTimeOffset,
307 kTransmissionTimeOffsetExtensionId));
308 ASSERT_EQ(
309 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
310 kAbsoluteSendTimeExtensionId));
311 ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
312 kAudioLevelExtensionId));
313 ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
314 kRtpExtensionTransportSequenceNumber,
315 kTransportSequenceNumberExtensionId));
316 ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
317 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
318
319 auto packet = rtp_sender_->AllocatePacket();
320
321 ASSERT_TRUE(packet);
322 // Preallocate BWE extensions RtpSender set itself.
323 EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
324 EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
325 EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
326 // Do not allocate media specific extensions.
327 EXPECT_FALSE(packet->HasExtension<AudioLevel>());
328 EXPECT_FALSE(packet->HasExtension<VideoOrientation>());
329}
330
minyue3a407ee2017-04-03 01:10:33 -0700331TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200332 auto packet = rtp_sender_->AllocatePacket();
333 ASSERT_TRUE(packet);
334 const uint16_t sequence_number = rtp_sender_->SequenceNumber();
335
336 EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
337
338 EXPECT_EQ(sequence_number, packet->SequenceNumber());
339 EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber());
340}
341
minyue3a407ee2017-04-03 01:10:33 -0700342TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200343 auto packet = rtp_sender_->AllocatePacket();
344 ASSERT_TRUE(packet);
345
346 rtp_sender_->SetSendingMediaStatus(false);
347 EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get()));
348}
349
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100350TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPaddingOnVideo) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200351 constexpr size_t kPaddingSize = 100;
352 auto packet = rtp_sender_->AllocatePacket();
353 ASSERT_TRUE(packet);
354
philipel8aadd502017-02-23 02:56:13 -0800355 ASSERT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200356 packet->SetMarker(false);
357 ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100358 // Packet without marker bit doesn't allow padding on video stream.
philipel8aadd502017-02-23 02:56:13 -0800359 EXPECT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200360
361 packet->SetMarker(true);
362 ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
363 // Packet with marker bit allows send padding.
philipel8aadd502017-02-23 02:56:13 -0800364 EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200365}
366
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100367TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
368 MockTransport transport;
369 const bool kEnableAudio = true;
370 rtp_sender_.reset(new RTPSender(
371 kEnableAudio, &fake_clock_, &transport, &mock_paced_sender_, nullptr,
372 nullptr, nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
373 nullptr, &retransmission_rate_limiter_, nullptr, false));
374 rtp_sender_->SetTimestampOffset(0);
375 rtp_sender_->SetSSRC(kSsrc);
376
377 std::unique_ptr<RtpPacketToSend> audio_packet = rtp_sender_->AllocatePacket();
378 // Padding on audio stream allowed regardless of marker in the last packet.
379 audio_packet->SetMarker(false);
380 audio_packet->SetPayloadType(kPayload);
381 rtp_sender_->AssignSequenceNumber(audio_packet.get());
382
383 const size_t kPaddingSize = 59;
384 EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
385 .WillOnce(testing::Return(true));
386 EXPECT_EQ(kPaddingSize,
387 rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
388
389 // Requested padding size is too small, will send a larger one.
390 const size_t kMinPaddingSize = 50;
391 EXPECT_CALL(transport, SendRtp(_, kMinPaddingSize + kRtpHeaderSize, _))
392 .WillOnce(testing::Return(true));
Yves Gerey665174f2018-06-19 15:03:05 +0200393 EXPECT_EQ(kMinPaddingSize, rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5,
394 PacedPacketInfo()));
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100395}
396
minyue3a407ee2017-04-03 01:10:33 -0700397TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200398 constexpr size_t kPaddingSize = 100;
399 auto packet = rtp_sender_->AllocatePacket();
400 ASSERT_TRUE(packet);
401 packet->SetMarker(true);
402 packet->SetTimestamp(kTimestamp);
403
404 ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
philipel8aadd502017-02-23 02:56:13 -0800405 ASSERT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200406
407 ASSERT_EQ(1u, transport_.sent_packets_.size());
danilchap12ba1862016-10-26 02:41:55 -0700408 // Verify padding packet timestamp.
409 EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp());
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200410}
411
minyue3a407ee2017-04-03 01:10:33 -0700412TEST_P(RtpSenderTestWithoutPacer,
413 TransportFeedbackObserverGetsCorrectByteCount) {
414 constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
415 testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
416 rtp_sender_.reset(new RTPSender(
417 false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
418 &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
Erik Språng7b52f102018-02-07 14:37:37 +0100419 nullptr, &retransmission_rate_limiter_, &mock_overhead_observer, false));
minyue3a407ee2017-04-03 01:10:33 -0700420 rtp_sender_->SetSSRC(kSsrc);
421 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
422 kRtpExtensionTransportSequenceNumber,
423 kTransportSequenceNumberExtensionId));
424 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
425 .WillOnce(testing::Return(kTransportSequenceNumber));
426
427 const size_t expected_bytes =
428 GetParam() ? sizeof(kPayloadData) + kGenericHeaderLength +
429 kRtpOverheadBytesPerPacket
430 : sizeof(kPayloadData) + kGenericHeaderLength;
431
432 EXPECT_CALL(feedback_observer_,
433 AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
434 expected_bytes, PacedPacketInfo()))
435 .Times(1);
436 EXPECT_CALL(mock_overhead_observer,
437 OnOverheadChanged(kRtpOverheadBytesPerPacket))
438 .Times(1);
439 SendGenericPayload();
440}
441
442TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
Stefan Holmera246cfb2016-08-23 17:51:42 +0200443 rtp_sender_.reset(new RTPSender(
brandtrdbdb3f12016-11-10 05:04:48 -0800444 false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
445 &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
Erik Språng7b52f102018-02-07 14:37:37 +0100446 &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false));
nisse7d59f6b2017-02-21 03:40:24 -0800447 rtp_sender_->SetSSRC(kSsrc);
Stefan Holmerf5dca482016-01-27 12:58:51 +0100448 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
449 kRtpExtensionTransportSequenceNumber,
450 kTransportSequenceNumberExtensionId));
451
Stefan Holmerf5dca482016-01-27 12:58:51 +0100452 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
453 .WillOnce(testing::Return(kTransportSequenceNumber));
asapersson35151f32016-05-02 23:44:01 -0700454 EXPECT_CALL(send_packet_observer_,
455 OnSendPacket(kTransportSequenceNumber, _, _))
456 .Times(1);
minyue3a407ee2017-04-03 01:10:33 -0700457
458 EXPECT_CALL(feedback_observer_,
459 AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
460 PacedPacketInfo()))
Stefan Holmera246cfb2016-08-23 17:51:42 +0200461 .Times(1);
asapersson35151f32016-05-02 23:44:01 -0700462
463 SendGenericPayload();
Stefan Holmerf5dca482016-01-27 12:58:51 +0100464
danilchap12ba1862016-10-26 02:41:55 -0700465 const auto& packet = transport_.last_sent_packet();
466 uint16_t transport_seq_no;
467 ASSERT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
468 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
Petter Strandmark26bc6692018-05-29 08:43:35 +0200469 EXPECT_EQ(transport_.last_options_.packet_id, transport_seq_no);
470}
471
472TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
473 rtp_sender_.reset(new RTPSender(
474 false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
475 &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
476 &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false));
477 rtp_sender_->SetSSRC(kSsrc);
478
479 SendGenericPayload();
480
481 EXPECT_FALSE(transport_.last_options_.is_retransmit);
Stefan Holmerf5dca482016-01-27 12:58:51 +0100482}
483
minyue3a407ee2017-04-03 01:10:33 -0700484TEST_P(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) {
stefana23fc622016-07-28 07:56:38 -0700485 SendGenericPayload();
486}
asapersson35151f32016-05-02 23:44:01 -0700487
minyue3a407ee2017-04-03 01:10:33 -0700488TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
stefana23fc622016-07-28 07:56:38 -0700489 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
490 kRtpExtensionTransportSequenceNumber,
491 kTransportSequenceNumberExtensionId));
asapersson35151f32016-05-02 23:44:01 -0700492 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
493 .WillOnce(testing::Return(kTransportSequenceNumber));
494 EXPECT_CALL(send_packet_observer_,
495 OnSendPacket(kTransportSequenceNumber, _, _))
496 .Times(1);
497
498 SendGenericPayload();
499}
500
minyue3a407ee2017-04-03 01:10:33 -0700501TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
michaelt4da30442016-11-17 01:38:43 -0800502 rtp_sender_.reset(new RTPSender(
503 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
504 &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
505 &mock_rtc_event_log_, &send_packet_observer_,
Erik Språng7b52f102018-02-07 14:37:37 +0100506 &retransmission_rate_limiter_, nullptr, false));
brandtr9dfff292016-11-14 05:14:50 -0800507 rtp_sender_->SetSequenceNumber(kSeqNum);
508 rtp_sender_->SetSSRC(kSsrc);
Stefan Holmera246cfb2016-08-23 17:51:42 +0200509 rtp_sender_->SetStorePacketsStatus(true, 10);
510 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
511 kRtpExtensionTransportSequenceNumber,
512 kTransportSequenceNumberExtensionId));
513
brandtr9dfff292016-11-14 05:14:50 -0800514 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _));
Stefan Holmera246cfb2016-08-23 17:51:42 +0200515 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
516 .WillOnce(testing::Return(kTransportSequenceNumber));
517 EXPECT_CALL(send_packet_observer_,
518 OnSendPacket(kTransportSequenceNumber, _, _))
519 .Times(1);
minyue3a407ee2017-04-03 01:10:33 -0700520 EXPECT_CALL(feedback_observer_,
521 AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
522 PacedPacketInfo()))
Stefan Holmera246cfb2016-08-23 17:51:42 +0200523 .Times(1);
524
525 SendGenericPayload();
philipel8aadd502017-02-23 02:56:13 -0800526 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
527 fake_clock_.TimeInMilliseconds(), false,
528 PacedPacketInfo());
Stefan Holmera246cfb2016-08-23 17:51:42 +0200529
danilchap12ba1862016-10-26 02:41:55 -0700530 const auto& packet = transport_.last_sent_packet();
531 uint16_t transport_seq_no;
532 EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
533 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
Petter Strandmark26bc6692018-05-29 08:43:35 +0200534 EXPECT_EQ(transport_.last_options_.packet_id, transport_seq_no);
Stefan Holmera246cfb2016-08-23 17:51:42 +0200535}
536
Erik Språng7b52f102018-02-07 14:37:37 +0100537TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
ilnik04f4d122017-06-19 07:18:55 -0700538 rtp_sender_->SetStorePacketsStatus(true, 10);
539 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
540 kRtpExtensionVideoTiming, kVideoTimingExtensionId));
541 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
542 auto packet = rtp_sender_->AllocatePacket();
543 packet->SetPayloadType(kPayload);
544 packet->SetMarker(true);
545 packet->SetTimestamp(kTimestamp);
546 packet->set_capture_time_ms(capture_time_ms);
ilnik2edc6842017-07-06 03:06:50 -0700547 const VideoSendTiming kVideoTiming = {0u, 0u, 0u, 0u, 0u, 0u, true};
ilnik04f4d122017-06-19 07:18:55 -0700548 packet->SetExtension<VideoTimingExtension>(kVideoTiming);
549 EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
550 size_t packet_size = packet->size();
ilnik04f4d122017-06-19 07:18:55 -0700551
552 const int kStoredTimeInMs = 100;
Erik Språng7b52f102018-02-07 14:37:37 +0100553 {
554 EXPECT_CALL(
555 mock_paced_sender_,
556 InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _));
557 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
558 kAllowRetransmission,
559 RtpPacketSender::kNormalPriority));
560 }
ilnik04f4d122017-06-19 07:18:55 -0700561 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
Erik Språng7b52f102018-02-07 14:37:37 +0100562 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
563 PacedPacketInfo());
ilnik04f4d122017-06-19 07:18:55 -0700564 EXPECT_EQ(1, transport_.packets_sent());
565 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
566
danilchapce251812017-09-11 12:24:41 -0700567 VideoSendTiming video_timing;
568 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>(
569 &video_timing));
570 EXPECT_EQ(kStoredTimeInMs, video_timing.pacer_exit_delta_ms);
Erik Språng7b52f102018-02-07 14:37:37 +0100571}
ilnik04f4d122017-06-19 07:18:55 -0700572
Erik Språng7b52f102018-02-07 14:37:37 +0100573TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtension) {
574 SetUpRtpSender(true, true);
575 rtp_sender_->SetStorePacketsStatus(true, 10);
576 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
577 kRtpExtensionVideoTiming, kVideoTimingExtensionId));
578 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
579 auto packet = rtp_sender_->AllocatePacket();
580 packet->SetPayloadType(kPayload);
581 packet->SetMarker(true);
582 packet->SetTimestamp(kTimestamp);
583 packet->set_capture_time_ms(capture_time_ms);
584 const uint16_t kPacerExitMs = 1234u;
585 const VideoSendTiming kVideoTiming = {0u, 0u, 0u, kPacerExitMs, 0u, 0u, true};
586 packet->SetExtension<VideoTimingExtension>(kVideoTiming);
587 EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
588 size_t packet_size = packet->size();
589
590 const int kStoredTimeInMs = 100;
591 {
592 EXPECT_CALL(
593 mock_paced_sender_,
594 InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _));
595 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
596 kAllowRetransmission,
597 RtpPacketSender::kNormalPriority));
598 }
ilnik04f4d122017-06-19 07:18:55 -0700599 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
600 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
601 PacedPacketInfo());
Erik Språng7b52f102018-02-07 14:37:37 +0100602 EXPECT_EQ(1, transport_.packets_sent());
ilnik04f4d122017-06-19 07:18:55 -0700603 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
604
Erik Språng7b52f102018-02-07 14:37:37 +0100605 VideoSendTiming video_timing;
danilchapce251812017-09-11 12:24:41 -0700606 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>(
607 &video_timing));
Erik Språng7b52f102018-02-07 14:37:37 +0100608 EXPECT_EQ(kStoredTimeInMs, video_timing.network2_timestamp_delta_ms);
609 EXPECT_EQ(kPacerExitMs, video_timing.pacer_exit_delta_ms);
ilnik04f4d122017-06-19 07:18:55 -0700610}
611
minyue3a407ee2017-04-03 01:10:33 -0700612TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
Peter Boströme23e7372015-10-08 11:44:14 +0200613 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
brandtr9dfff292016-11-14 05:14:50 -0800614 kSsrc, kSeqNum, _, _, _));
Elad Alon4a87e1c2017-10-03 16:11:34 +0200615 EXPECT_CALL(mock_rtc_event_log_,
616 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)));
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000617
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000618 rtp_sender_->SetStorePacketsStatus(true, 10);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000619 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
danilchap162abd32015-12-10 02:39:40 -0800620 kRtpExtensionTransmissionTimeOffset,
621 kTransmissionTimeOffsetExtensionId));
622 EXPECT_EQ(
623 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
624 kAbsoluteSendTimeExtensionId));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000625 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
danilchapb6f1fb52016-10-19 06:11:39 -0700626 auto packet =
627 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
628 size_t packet_size = packet->size();
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000629
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000630 // Packet should be stored in a send bucket.
danilchapb6f1fb52016-10-19 06:11:39 -0700631 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
632 kAllowRetransmission,
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700633 RtpPacketSender::kNormalPriority));
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000634
danilchap12ba1862016-10-26 02:41:55 -0700635 EXPECT_EQ(0, transport_.packets_sent());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000636
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000637 const int kStoredTimeInMs = 100;
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +0000638 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000639
brandtr9dfff292016-11-14 05:14:50 -0800640 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
philipel8aadd502017-02-23 02:56:13 -0800641 PacedPacketInfo());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000642
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000643 // Process send bucket. Packet should now be sent.
danilchap12ba1862016-10-26 02:41:55 -0700644 EXPECT_EQ(1, transport_.packets_sent());
645 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
646
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +0000647 webrtc::RTPHeader rtp_header;
danilchap12ba1862016-10-26 02:41:55 -0700648 transport_.last_sent_packet().GetHeader(&rtp_header);
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000649
650 // Verify transmission time offset.
651 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000652 uint64_t expected_send_time =
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000653 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000654 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000655}
656
minyue3a407ee2017-04-03 01:10:33 -0700657TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
Peter Boströme23e7372015-10-08 11:44:14 +0200658 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
brandtr9dfff292016-11-14 05:14:50 -0800659 kSsrc, kSeqNum, _, _, _));
Elad Alon4a87e1c2017-10-03 16:11:34 +0200660 EXPECT_CALL(mock_rtc_event_log_,
661 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)));
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000662
663 rtp_sender_->SetStorePacketsStatus(true, 10);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000664 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
danilchap162abd32015-12-10 02:39:40 -0800665 kRtpExtensionTransmissionTimeOffset,
666 kTransmissionTimeOffsetExtensionId));
667 EXPECT_EQ(
668 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
669 kAbsoluteSendTimeExtensionId));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000670 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
danilchapb6f1fb52016-10-19 06:11:39 -0700671 auto packet =
672 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
673 size_t packet_size = packet->size();
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000674
675 // Packet should be stored in a send bucket.
danilchapb6f1fb52016-10-19 06:11:39 -0700676 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
677 kAllowRetransmission,
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700678 RtpPacketSender::kNormalPriority));
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000679
danilchap12ba1862016-10-26 02:41:55 -0700680 EXPECT_EQ(0, transport_.packets_sent());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000681
terelius5d332ac2016-01-14 14:37:39 -0800682 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
brandtr9dfff292016-11-14 05:14:50 -0800683 kSsrc, kSeqNum, _, _, _));
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000684
685 const int kStoredTimeInMs = 100;
686 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
687
danilchapb6f1fb52016-10-19 06:11:39 -0700688 EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum));
danilchap12ba1862016-10-26 02:41:55 -0700689 EXPECT_EQ(0, transport_.packets_sent());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000690
brandtr9dfff292016-11-14 05:14:50 -0800691 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
philipel8aadd502017-02-23 02:56:13 -0800692 PacedPacketInfo());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000693
694 // Process send bucket. Packet should now be sent.
danilchap12ba1862016-10-26 02:41:55 -0700695 EXPECT_EQ(1, transport_.packets_sent());
696 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000697
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +0000698 webrtc::RTPHeader rtp_header;
danilchap12ba1862016-10-26 02:41:55 -0700699 transport_.last_sent_packet().GetHeader(&rtp_header);
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000700
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000701 // Verify transmission time offset.
702 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000703 uint64_t expected_send_time =
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000704 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
705 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
706}
707
708// This test sends 1 regular video packet, then 4 padding packets, and then
709// 1 more regular packet.
minyue3a407ee2017-04-03 01:10:33 -0700710TEST_P(RtpSenderTest, SendPadding) {
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000711 // Make all (non-padding) packets go to send queue.
terelius5d332ac2016-01-14 14:37:39 -0800712 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
brandtr9dfff292016-11-14 05:14:50 -0800713 kSsrc, kSeqNum, _, _, _));
Elad Alon4a87e1c2017-10-03 16:11:34 +0200714 EXPECT_CALL(mock_rtc_event_log_,
715 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
716 .Times(1 + 4 + 1);
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000717
718 uint16_t seq_num = kSeqNum;
719 uint32_t timestamp = kTimestamp;
720 rtp_sender_->SetStorePacketsStatus(true, 10);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000721 size_t rtp_header_len = kRtpHeaderSize;
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000722 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
danilchap162abd32015-12-10 02:39:40 -0800723 kRtpExtensionTransmissionTimeOffset,
724 kTransmissionTimeOffsetExtensionId));
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000725 rtp_header_len += 4; // 4 bytes extension.
danilchap162abd32015-12-10 02:39:40 -0800726 EXPECT_EQ(
727 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
728 kAbsoluteSendTimeExtensionId));
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000729 rtp_header_len += 4; // 4 bytes extension.
730 rtp_header_len += 4; // 4 extra bytes common to all extension headers.
731
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000732 webrtc::RTPHeader rtp_header;
733
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000734 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
danilchapb6f1fb52016-10-19 06:11:39 -0700735 auto packet =
736 BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200737 const uint32_t media_packet_timestamp = timestamp;
danilchapb6f1fb52016-10-19 06:11:39 -0700738 size_t packet_size = packet->size();
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000739
740 // Packet should be stored in a send bucket.
danilchapb6f1fb52016-10-19 06:11:39 -0700741 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
742 kAllowRetransmission,
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700743 RtpPacketSender::kNormalPriority));
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000744
745 int total_packets_sent = 0;
danilchap12ba1862016-10-26 02:41:55 -0700746 EXPECT_EQ(total_packets_sent, transport_.packets_sent());
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000747
748 const int kStoredTimeInMs = 100;
749 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
brandtr9dfff292016-11-14 05:14:50 -0800750 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
philipel8aadd502017-02-23 02:56:13 -0800751 PacedPacketInfo());
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000752 // Packet should now be sent. This test doesn't verify the regular video
753 // packet, since it is tested in another test.
danilchap12ba1862016-10-26 02:41:55 -0700754 EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000755 timestamp += 90 * kStoredTimeInMs;
756
757 // Send padding 4 times, waiting 50 ms between each.
758 for (int i = 0; i < 4; ++i) {
759 const int kPaddingPeriodMs = 50;
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000760 const size_t kPaddingBytes = 100;
761 const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc.
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000762 // Padding will be forced to full packets.
philipelc7bf32a2017-02-17 03:59:43 -0800763 EXPECT_EQ(kMaxPaddingLength,
philipel8aadd502017-02-23 02:56:13 -0800764 rtp_sender_->TimeToSendPadding(kPaddingBytes, PacedPacketInfo()));
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000765
766 // Process send bucket. Padding should now be sent.
danilchap12ba1862016-10-26 02:41:55 -0700767 EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000768 EXPECT_EQ(kMaxPaddingLength + rtp_header_len,
danilchap12ba1862016-10-26 02:41:55 -0700769 transport_.last_sent_packet().size());
770
771 transport_.last_sent_packet().GetHeader(&rtp_header);
pbosbd2522a2015-07-01 05:35:53 -0700772 EXPECT_EQ(kMaxPaddingLength, rtp_header.paddingLength);
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000773
Stefan Holmer586b19b2015-09-18 11:14:31 +0200774 // Verify sequence number and timestamp. The timestamp should be the same
775 // as the last media packet.
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000776 EXPECT_EQ(seq_num++, rtp_header.sequenceNumber);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200777 EXPECT_EQ(media_packet_timestamp, rtp_header.timestamp);
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000778 // Verify transmission time offset.
Stefan Holmer586b19b2015-09-18 11:14:31 +0200779 int offset = timestamp - media_packet_timestamp;
780 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset);
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000781 uint64_t expected_send_time =
782 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
783 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
784 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
785 timestamp += 90 * kPaddingPeriodMs;
786 }
787
788 // Send a regular video packet again.
789 capture_time_ms = fake_clock_.TimeInMilliseconds();
danilchapb6f1fb52016-10-19 06:11:39 -0700790 packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
791 packet_size = packet->size();
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000792
brandtr9dfff292016-11-14 05:14:50 -0800793 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
794 kSsrc, seq_num, _, _, _));
terelius5d332ac2016-01-14 14:37:39 -0800795
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000796 // Packet should be stored in a send bucket.
danilchapb6f1fb52016-10-19 06:11:39 -0700797 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
798 kAllowRetransmission,
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700799 RtpPacketSender::kNormalPriority));
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000800
brandtr9dfff292016-11-14 05:14:50 -0800801 rtp_sender_->TimeToSendPacket(kSsrc, seq_num, capture_time_ms, false,
philipel8aadd502017-02-23 02:56:13 -0800802 PacedPacketInfo());
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000803 // Process send bucket.
danilchap12ba1862016-10-26 02:41:55 -0700804 EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
805 EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
806 transport_.last_sent_packet().GetHeader(&rtp_header);
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +0000807
808 // Verify sequence number and timestamp.
809 EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
810 EXPECT_EQ(timestamp, rtp_header.timestamp);
811 // Verify transmission time offset. This packet is sent without delay.
812 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
813 uint64_t expected_send_time =
814 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000815 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000816}
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000817
minyue3a407ee2017-04-03 01:10:33 -0700818TEST_P(RtpSenderTest, OnSendPacketUpdated) {
stefana23fc622016-07-28 07:56:38 -0700819 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
820 kRtpExtensionTransportSequenceNumber,
821 kTransportSequenceNumberExtensionId));
asapersson35151f32016-05-02 23:44:01 -0700822 rtp_sender_->SetStorePacketsStatus(true, 10);
823
824 EXPECT_CALL(send_packet_observer_,
825 OnSendPacket(kTransportSequenceNumber, _, _))
826 .Times(1);
827 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
828 .WillOnce(testing::Return(kTransportSequenceNumber));
brandtr9dfff292016-11-14 05:14:50 -0800829 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
830 .Times(1);
asapersson35151f32016-05-02 23:44:01 -0700831
832 SendGenericPayload(); // Packet passed to pacer.
833 const bool kIsRetransmit = false;
brandtr9dfff292016-11-14 05:14:50 -0800834 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
835 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
philipel8aadd502017-02-23 02:56:13 -0800836 PacedPacketInfo());
danilchap12ba1862016-10-26 02:41:55 -0700837 EXPECT_EQ(1, transport_.packets_sent());
asapersson35151f32016-05-02 23:44:01 -0700838}
839
minyue3a407ee2017-04-03 01:10:33 -0700840TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
stefana23fc622016-07-28 07:56:38 -0700841 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
842 kRtpExtensionTransportSequenceNumber,
843 kTransportSequenceNumberExtensionId));
asapersson35151f32016-05-02 23:44:01 -0700844 rtp_sender_->SetStorePacketsStatus(true, 10);
845
846 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
847 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
848 .WillOnce(testing::Return(kTransportSequenceNumber));
brandtr9dfff292016-11-14 05:14:50 -0800849 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
850 .Times(1);
asapersson35151f32016-05-02 23:44:01 -0700851
852 SendGenericPayload(); // Packet passed to pacer.
853 const bool kIsRetransmit = true;
brandtr9dfff292016-11-14 05:14:50 -0800854 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
855 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
philipel8aadd502017-02-23 02:56:13 -0800856 PacedPacketInfo());
danilchap12ba1862016-10-26 02:41:55 -0700857 EXPECT_EQ(1, transport_.packets_sent());
Petter Strandmark26bc6692018-05-29 08:43:35 +0200858 EXPECT_TRUE(transport_.last_options_.is_retransmit);
asapersson35151f32016-05-02 23:44:01 -0700859}
860
minyue3a407ee2017-04-03 01:10:33 -0700861TEST_P(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
asapersson35151f32016-05-02 23:44:01 -0700862 rtp_sender_.reset(new RTPSender(
brandtrdbdb3f12016-11-10 05:04:48 -0800863 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
asapersson35151f32016-05-02 23:44:01 -0700864 nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
michaelt4da30442016-11-17 01:38:43 -0800865 nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_,
Erik Språng7b52f102018-02-07 14:37:37 +0100866 nullptr, false));
brandtr9dfff292016-11-14 05:14:50 -0800867 rtp_sender_->SetSequenceNumber(kSeqNum);
868 rtp_sender_->SetSSRC(kSsrc);
stefana23fc622016-07-28 07:56:38 -0700869 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
870 kRtpExtensionTransportSequenceNumber,
871 kTransportSequenceNumberExtensionId));
asapersson35151f32016-05-02 23:44:01 -0700872 rtp_sender_->SetSequenceNumber(kSeqNum);
873 rtp_sender_->SetStorePacketsStatus(true, 10);
874
875 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
brandtr9dfff292016-11-14 05:14:50 -0800876 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _))
877 .Times(1);
asapersson35151f32016-05-02 23:44:01 -0700878
879 SendGenericPayload(); // Packet passed to pacer.
880 const bool kIsRetransmit = false;
brandtr9dfff292016-11-14 05:14:50 -0800881 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
882 fake_clock_.TimeInMilliseconds(), kIsRetransmit,
philipel8aadd502017-02-23 02:56:13 -0800883 PacedPacketInfo());
danilchap12ba1862016-10-26 02:41:55 -0700884 EXPECT_EQ(1, transport_.packets_sent());
asapersson35151f32016-05-02 23:44:01 -0700885}
886
minyue3a407ee2017-04-03 01:10:33 -0700887TEST_P(RtpSenderTest, SendRedundantPayloads) {
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000888 MockTransport transport;
terelius429c3452016-01-21 05:42:04 -0800889 rtp_sender_.reset(new RTPSender(
asapersson35151f32016-05-02 23:44:01 -0700890 false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
brandtrdbdb3f12016-11-10 05:04:48 -0800891 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
Erik Språng7b52f102018-02-07 14:37:37 +0100892 &retransmission_rate_limiter_, nullptr, false));
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000893 rtp_sender_->SetSequenceNumber(kSeqNum);
brandtr9dfff292016-11-14 05:14:50 -0800894 rtp_sender_->SetSSRC(kSsrc);
Shao Changbine62202f2015-04-21 20:24:50 +0800895 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000896
897 uint16_t seq_num = kSeqNum;
898 rtp_sender_->SetStorePacketsStatus(true, 10);
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +0000899 int32_t rtp_header_len = kRtpHeaderSize;
danilchap162abd32015-12-10 02:39:40 -0800900 EXPECT_EQ(
901 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
902 kAbsoluteSendTimeExtensionId));
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000903 rtp_header_len += 4; // 4 bytes extension.
904 rtp_header_len += 4; // 4 extra bytes common to all extension headers.
905
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000906 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000907 rtp_sender_->SetRtxSsrc(1234);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000908
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000909 const size_t kNumPayloadSizes = 10;
danilchap162abd32015-12-10 02:39:40 -0800910 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
911 750, 800, 850, 900, 950};
terelius5d332ac2016-01-14 14:37:39 -0800912 // Expect all packets go through the pacer.
913 EXPECT_CALL(mock_paced_sender_,
brandtr9dfff292016-11-14 05:14:50 -0800914 InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _))
terelius5d332ac2016-01-14 14:37:39 -0800915 .Times(kNumPayloadSizes);
Elad Alon4a87e1c2017-10-03 16:11:34 +0200916 EXPECT_CALL(mock_rtc_event_log_,
917 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
terelius429c3452016-01-21 05:42:04 -0800918 .Times(kNumPayloadSizes);
919
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000920 // Send 10 packets of increasing size.
921 for (size_t i = 0; i < kNumPayloadSizes; ++i) {
922 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
stefan1d8a5062015-10-02 03:39:33 -0700923 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true));
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000924 SendPacket(capture_time_ms, kPayloadSizes[i]);
brandtr9dfff292016-11-14 05:14:50 -0800925 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
philipel8aadd502017-02-23 02:56:13 -0800926 PacedPacketInfo());
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000927 fake_clock_.AdvanceTimeMilliseconds(33);
928 }
terelius429c3452016-01-21 05:42:04 -0800929
Elad Alon4a87e1c2017-10-03 16:11:34 +0200930 EXPECT_CALL(mock_rtc_event_log_,
931 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
terelius429c3452016-01-21 05:42:04 -0800932 .Times(::testing::AtLeast(4));
933
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000934 // The amount of padding to send it too small to send a payload packet.
stefan1d8a5062015-10-02 03:39:33 -0700935 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
pbos2d566682015-09-28 09:59:31 -0700936 .WillOnce(testing::Return(true));
philipela1ed0b32016-06-01 06:31:17 -0700937 EXPECT_EQ(kMaxPaddingSize,
philipel8aadd502017-02-23 02:56:13 -0800938 rtp_sender_->TimeToSendPadding(49, PacedPacketInfo()));
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000939
Petter Strandmark26bc6692018-05-29 08:43:35 +0200940 PacketOptions options;
Peter Boströmac547a62015-09-17 23:03:57 +0200941 EXPECT_CALL(transport,
stefan1d8a5062015-10-02 03:39:33 -0700942 SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
Yves Gerey665174f2018-06-19 15:03:05 +0200943 .WillOnce(
944 testing::DoAll(testing::SaveArg<2>(&options), testing::Return(true)));
philipela1ed0b32016-06-01 06:31:17 -0700945 EXPECT_EQ(kPayloadSizes[0],
philipel8aadd502017-02-23 02:56:13 -0800946 rtp_sender_->TimeToSendPadding(500, PacedPacketInfo()));
Petter Strandmark26bc6692018-05-29 08:43:35 +0200947 EXPECT_TRUE(options.is_retransmit);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000948
Yves Gerey665174f2018-06-19 15:03:05 +0200949 EXPECT_CALL(transport, SendRtp(_,
950 kPayloadSizes[kNumPayloadSizes - 1] +
951 rtp_header_len + kRtxHeaderSize,
stefan1d8a5062015-10-02 03:39:33 -0700952 _))
pbos2d566682015-09-28 09:59:31 -0700953 .WillOnce(testing::Return(true));
Petter Strandmark26bc6692018-05-29 08:43:35 +0200954
955 options.is_retransmit = false;
stefan1d8a5062015-10-02 03:39:33 -0700956 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
Yves Gerey665174f2018-06-19 15:03:05 +0200957 .WillOnce(
958 testing::DoAll(testing::SaveArg<2>(&options), testing::Return(true)));
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000959 EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
philipel8aadd502017-02-23 02:56:13 -0800960 rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
Petter Strandmark26bc6692018-05-29 08:43:35 +0200961 EXPECT_FALSE(options.is_retransmit);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000962}
963
minyue3a407ee2017-04-03 01:10:33 -0700964TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) {
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000965 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
966 const uint8_t payload_type = 127;
967 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
968 0, 1500));
969 uint8_t payload[] = {47, 11, 32, 93, 89};
970
971 // Send keyframe
Sami Kalliomäki426a80c2018-08-08 11:37:59 +0200972 RTPVideoHeader video_header;
spranga8ae6f22017-09-04 07:23:56 -0700973 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
974 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +0200975 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000976
danilchap96c15872016-11-21 01:35:29 -0800977 auto sent_payload = transport_.last_sent_packet().payload();
978 uint8_t generic_header = sent_payload[0];
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000979 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
980 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
danilchap96c15872016-11-21 01:35:29 -0800981 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload));
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000982
983 // Send delta frame
984 payload[0] = 13;
985 payload[1] = 42;
986 payload[4] = 13;
987
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700988 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
989 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +0200990 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000991
danilchap96c15872016-11-21 01:35:29 -0800992 sent_payload = transport_.last_sent_packet().payload();
993 generic_header = sent_payload[0];
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000994 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
995 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
danilchap96c15872016-11-21 01:35:29 -0800996 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload));
pbos@webrtc.org8911ce42013-03-18 16:39:03 +0000997}
998
minyue3a407ee2017-04-03 01:10:33 -0700999TEST_P(RtpSenderTest, SendFlexfecPackets) {
brandtrdbdb3f12016-11-10 05:04:48 -08001000 constexpr int kMediaPayloadType = 127;
1001 constexpr int kFlexfecPayloadType = 118;
1002 constexpr uint32_t kMediaSsrc = 1234;
1003 constexpr uint32_t kFlexfecSsrc = 5678;
Steve Antonf0482ea2018-04-09 13:33:52 -07001004 const char kNoMid[] = "";
brandtrdbdb3f12016-11-10 05:04:48 -08001005 const std::vector<RtpExtension> kNoRtpExtensions;
erikvarga27883732017-05-17 05:08:38 -07001006 const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
brandtrdbdb3f12016-11-10 05:04:48 -08001007 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
Steve Antonf0482ea2018-04-09 13:33:52 -07001008 kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
brandtr48d21a22017-05-30 02:32:12 -07001009 nullptr /* rtp_state */, &fake_clock_);
brandtrdbdb3f12016-11-10 05:04:48 -08001010
1011 // Reset |rtp_sender_| to use FlexFEC.
michaelt4da30442016-11-17 01:38:43 -08001012 rtp_sender_.reset(new RTPSender(
1013 false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
1014 &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
1015 &mock_rtc_event_log_, &send_packet_observer_,
Erik Språng7b52f102018-02-07 14:37:37 +01001016 &retransmission_rate_limiter_, nullptr, false));
brandtrdbdb3f12016-11-10 05:04:48 -08001017 rtp_sender_->SetSSRC(kMediaSsrc);
1018 rtp_sender_->SetSequenceNumber(kSeqNum);
brandtrdbdb3f12016-11-10 05:04:48 -08001019 rtp_sender_->SetStorePacketsStatus(true, 10);
1020
1021 // Parameters selected to generate a single FEC packet per media packet.
1022 FecProtectionParams params;
1023 params.fec_rate = 15;
1024 params.max_fec_frames = 1;
1025 params.fec_mask_type = kFecMaskRandom;
1026 rtp_sender_->SetFecParameters(params, params);
1027
brandtr9dfff292016-11-14 05:14:50 -08001028 EXPECT_CALL(mock_paced_sender_,
1029 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, kSeqNum,
1030 _, _, false));
1031 uint16_t flexfec_seq_num;
brandtrdbdb3f12016-11-10 05:04:48 -08001032 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
brandtr9dfff292016-11-14 05:14:50 -08001033 kFlexfecSsrc, _, _, _, false))
1034 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num));
brandtrdbdb3f12016-11-10 05:04:48 -08001035 SendGenericPayload();
Elad Alon4a87e1c2017-10-03 16:11:34 +02001036 EXPECT_CALL(mock_rtc_event_log_,
1037 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
1038 .Times(2);
philipel8aadd502017-02-23 02:56:13 -08001039 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum,
1040 fake_clock_.TimeInMilliseconds(),
1041 false, PacedPacketInfo()));
brandtr9dfff292016-11-14 05:14:50 -08001042 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num,
1043 fake_clock_.TimeInMilliseconds(),
philipel8aadd502017-02-23 02:56:13 -08001044 false, PacedPacketInfo()));
brandtr9dfff292016-11-14 05:14:50 -08001045 ASSERT_EQ(2, transport_.packets_sent());
brandtrdbdb3f12016-11-10 05:04:48 -08001046 const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
1047 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
brandtr9dfff292016-11-14 05:14:50 -08001048 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber());
brandtrdbdb3f12016-11-10 05:04:48 -08001049 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
brandtr9dfff292016-11-14 05:14:50 -08001050 const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
1051 EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
1052 EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
1053 EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
brandtrdbdb3f12016-11-10 05:04:48 -08001054}
1055
ilnik10894992017-06-21 08:23:19 -07001056// TODO(ilnik): because of webrtc:7859. Once FEC moved below pacer, this test
1057// should be removed.
1058TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) {
1059 constexpr int kMediaPayloadType = 127;
1060 constexpr int kFlexfecPayloadType = 118;
1061 constexpr uint32_t kMediaSsrc = 1234;
1062 constexpr uint32_t kFlexfecSsrc = 5678;
Steve Antonf0482ea2018-04-09 13:33:52 -07001063 const char kNoMid[] = "";
ilnik10894992017-06-21 08:23:19 -07001064 const std::vector<RtpExtension> kNoRtpExtensions;
1065 const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
ilnike4350192017-06-29 02:27:44 -07001066
ilnik10894992017-06-21 08:23:19 -07001067 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
Steve Antonf0482ea2018-04-09 13:33:52 -07001068 kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
ilnik10894992017-06-21 08:23:19 -07001069 nullptr /* rtp_state */, &fake_clock_);
1070
1071 // Reset |rtp_sender_| to use FlexFEC.
1072 rtp_sender_.reset(new RTPSender(
1073 false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
1074 &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
1075 &mock_rtc_event_log_, &send_packet_observer_,
Erik Språng7b52f102018-02-07 14:37:37 +01001076 &retransmission_rate_limiter_, nullptr, false));
ilnik10894992017-06-21 08:23:19 -07001077 rtp_sender_->SetSSRC(kMediaSsrc);
1078 rtp_sender_->SetSequenceNumber(kSeqNum);
ilnik10894992017-06-21 08:23:19 -07001079 rtp_sender_->SetStorePacketsStatus(true, 10);
1080
ilnike4350192017-06-29 02:27:44 -07001081 // Need extension to be registered for timing frames to be sent.
1082 ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1083 kRtpExtensionVideoTiming, kVideoTimingExtensionId));
1084
ilnik10894992017-06-21 08:23:19 -07001085 // Parameters selected to generate a single FEC packet per media packet.
1086 FecProtectionParams params;
1087 params.fec_rate = 15;
1088 params.max_fec_frames = 1;
1089 params.fec_mask_type = kFecMaskRandom;
1090 rtp_sender_->SetFecParameters(params, params);
1091
1092 EXPECT_CALL(mock_paced_sender_,
1093 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, kSeqNum,
1094 _, _, false));
1095 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
1096 kFlexfecSsrc, _, _, _, false))
1097 .Times(0); // Not called because packet should not be protected.
1098
1099 const uint32_t kTimestamp = 1234;
1100 const uint8_t kPayloadType = 127;
1101 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
1102 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1103 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
1104 0, 1500));
1105 RTPVideoHeader video_header;
Ilya Nikolaevskiyb6c462d2018-06-05 15:21:32 +02001106 video_header.video_timing.flags = VideoSendTiming::kTriggeredByTimer;
ilnik10894992017-06-21 08:23:19 -07001107 EXPECT_TRUE(rtp_sender_->SendOutgoingData(
1108 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData,
spranga8ae6f22017-09-04 07:23:56 -07001109 sizeof(kPayloadData), nullptr, &video_header, nullptr,
1110 kDefaultExpectedRetransmissionTimeMs));
ilnik10894992017-06-21 08:23:19 -07001111
Elad Alon4a87e1c2017-10-03 16:11:34 +02001112 EXPECT_CALL(mock_rtc_event_log_,
1113 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
1114 .Times(1);
ilnik10894992017-06-21 08:23:19 -07001115 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum,
1116 fake_clock_.TimeInMilliseconds(),
1117 false, PacedPacketInfo()));
1118 ASSERT_EQ(1, transport_.packets_sent());
1119 const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
1120 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
1121 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber());
1122 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
1123
1124 // Now try to send not a timing frame.
1125 uint16_t flexfec_seq_num;
1126 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
1127 kFlexfecSsrc, _, _, _, false))
1128 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num));
1129 EXPECT_CALL(mock_paced_sender_,
1130 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc,
1131 kSeqNum + 1, _, _, false));
Ilya Nikolaevskiyb6c462d2018-06-05 15:21:32 +02001132 video_header.video_timing.flags = VideoSendTiming::kInvalid;
ilnik10894992017-06-21 08:23:19 -07001133 EXPECT_TRUE(rtp_sender_->SendOutgoingData(
1134 kVideoFrameKey, kPayloadType, kTimestamp + 1, kCaptureTimeMs + 1,
spranga8ae6f22017-09-04 07:23:56 -07001135 kPayloadData, sizeof(kPayloadData), nullptr, &video_header, nullptr,
1136 kDefaultExpectedRetransmissionTimeMs));
ilnik10894992017-06-21 08:23:19 -07001137
Elad Alon4a87e1c2017-10-03 16:11:34 +02001138 EXPECT_CALL(mock_rtc_event_log_,
1139 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
1140 .Times(2);
ilnik10894992017-06-21 08:23:19 -07001141 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum + 1,
1142 fake_clock_.TimeInMilliseconds(),
1143 false, PacedPacketInfo()));
1144 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num,
1145 fake_clock_.TimeInMilliseconds(),
1146 false, PacedPacketInfo()));
1147 ASSERT_EQ(3, transport_.packets_sent());
1148 const RtpPacketReceived& media_packet2 = transport_.sent_packets_[1];
1149 EXPECT_EQ(kMediaPayloadType, media_packet2.PayloadType());
1150 EXPECT_EQ(kSeqNum + 1, media_packet2.SequenceNumber());
1151 EXPECT_EQ(kMediaSsrc, media_packet2.Ssrc());
1152 const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[2];
1153 EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
1154 EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
1155 EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
1156}
1157
minyue3a407ee2017-04-03 01:10:33 -07001158TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
brandtrdbdb3f12016-11-10 05:04:48 -08001159 constexpr int kMediaPayloadType = 127;
1160 constexpr int kFlexfecPayloadType = 118;
1161 constexpr uint32_t kMediaSsrc = 1234;
1162 constexpr uint32_t kFlexfecSsrc = 5678;
Steve Antonf0482ea2018-04-09 13:33:52 -07001163 const char kNoMid[] = "";
brandtrdbdb3f12016-11-10 05:04:48 -08001164 const std::vector<RtpExtension> kNoRtpExtensions;
erikvarga27883732017-05-17 05:08:38 -07001165 const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
brandtrdbdb3f12016-11-10 05:04:48 -08001166 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
Steve Antonf0482ea2018-04-09 13:33:52 -07001167 kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
brandtr48d21a22017-05-30 02:32:12 -07001168 nullptr /* rtp_state */, &fake_clock_);
brandtrdbdb3f12016-11-10 05:04:48 -08001169
1170 // Reset |rtp_sender_| to use FlexFEC.
Erik Språng7b52f102018-02-07 14:37:37 +01001171 rtp_sender_.reset(
1172 new RTPSender(false, &fake_clock_, &transport_, nullptr, &flexfec_sender,
1173 &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
1174 &mock_rtc_event_log_, &send_packet_observer_,
1175 &retransmission_rate_limiter_, nullptr, false));
brandtrdbdb3f12016-11-10 05:04:48 -08001176 rtp_sender_->SetSSRC(kMediaSsrc);
1177 rtp_sender_->SetSequenceNumber(kSeqNum);
brandtrdbdb3f12016-11-10 05:04:48 -08001178
1179 // Parameters selected to generate a single FEC packet per media packet.
1180 FecProtectionParams params;
1181 params.fec_rate = 15;
1182 params.max_fec_frames = 1;
1183 params.fec_mask_type = kFecMaskRandom;
1184 rtp_sender_->SetFecParameters(params, params);
1185
Elad Alon4a87e1c2017-10-03 16:11:34 +02001186 EXPECT_CALL(mock_rtc_event_log_,
1187 LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
1188 .Times(2);
brandtrdbdb3f12016-11-10 05:04:48 -08001189 SendGenericPayload();
1190 ASSERT_EQ(2, transport_.packets_sent());
1191 const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
1192 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
1193 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
1194 const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
1195 EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
1196 EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
1197}
1198
Steve Anton296a0ce2018-03-22 15:17:27 -07001199// Test that the MID header extension is included on sent packets when
1200// configured.
1201TEST_P(RtpSenderTestWithoutPacer, MidIncludedOnSentPackets) {
1202 const char kMid[] = "mid";
1203
1204 // Register MID header extension and set the MID for the RTPSender.
1205 rtp_sender_->SetSendingMediaStatus(false);
1206 rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId);
1207 rtp_sender_->SetMid(kMid);
1208 rtp_sender_->SetSendingMediaStatus(true);
1209
1210 // Send a couple packets.
1211 SendGenericPayload();
1212 SendGenericPayload();
1213
1214 // Expect both packets to have the MID set.
1215 ASSERT_EQ(2u, transport_.sent_packets_.size());
1216 for (const RtpPacketReceived& packet : transport_.sent_packets_) {
1217 std::string mid;
1218 ASSERT_TRUE(packet.GetExtension<RtpMid>(&mid));
1219 EXPECT_EQ(kMid, mid);
1220 }
1221}
1222
minyue3a407ee2017-04-03 01:10:33 -07001223TEST_P(RtpSenderTest, FecOverheadRate) {
brandtr81eab612017-01-24 04:06:09 -08001224 constexpr int kFlexfecPayloadType = 118;
1225 constexpr uint32_t kMediaSsrc = 1234;
1226 constexpr uint32_t kFlexfecSsrc = 5678;
Steve Antonf0482ea2018-04-09 13:33:52 -07001227 const char kNoMid[] = "";
brandtr81eab612017-01-24 04:06:09 -08001228 const std::vector<RtpExtension> kNoRtpExtensions;
erikvarga27883732017-05-17 05:08:38 -07001229 const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
brandtr81eab612017-01-24 04:06:09 -08001230 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
Steve Antonf0482ea2018-04-09 13:33:52 -07001231 kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
brandtr48d21a22017-05-30 02:32:12 -07001232 nullptr /* rtp_state */, &fake_clock_);
brandtr81eab612017-01-24 04:06:09 -08001233
1234 // Reset |rtp_sender_| to use FlexFEC.
1235 rtp_sender_.reset(new RTPSender(
1236 false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
1237 &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
1238 &mock_rtc_event_log_, &send_packet_observer_,
Erik Språng7b52f102018-02-07 14:37:37 +01001239 &retransmission_rate_limiter_, nullptr, false));
brandtr81eab612017-01-24 04:06:09 -08001240 rtp_sender_->SetSSRC(kMediaSsrc);
1241 rtp_sender_->SetSequenceNumber(kSeqNum);
brandtr81eab612017-01-24 04:06:09 -08001242
1243 // Parameters selected to generate a single FEC packet per media packet.
1244 FecProtectionParams params;
1245 params.fec_rate = 15;
1246 params.max_fec_frames = 1;
1247 params.fec_mask_type = kFecMaskRandom;
1248 rtp_sender_->SetFecParameters(params, params);
1249
1250 constexpr size_t kNumMediaPackets = 10;
1251 constexpr size_t kNumFecPackets = kNumMediaPackets;
1252 constexpr int64_t kTimeBetweenPacketsMs = 10;
1253 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, false))
1254 .Times(kNumMediaPackets + kNumFecPackets);
1255 for (size_t i = 0; i < kNumMediaPackets; ++i) {
1256 SendGenericPayload();
1257 fake_clock_.AdvanceTimeMilliseconds(kTimeBetweenPacketsMs);
1258 }
1259 constexpr size_t kRtpHeaderLength = 12;
1260 constexpr size_t kFlexfecHeaderLength = 20;
1261 constexpr size_t kGenericCodecHeaderLength = 1;
1262 constexpr size_t kPayloadLength = sizeof(kPayloadData);
1263 constexpr size_t kPacketLength = kRtpHeaderLength + kFlexfecHeaderLength +
1264 kGenericCodecHeaderLength + kPayloadLength;
1265 EXPECT_NEAR(kNumFecPackets * kPacketLength * 8 /
1266 (kNumFecPackets * kTimeBetweenPacketsMs / 1000.0f),
1267 rtp_sender_->FecOverheadRate(), 500);
1268}
1269
minyue3a407ee2017-04-03 01:10:33 -07001270TEST_P(RtpSenderTest, FrameCountCallbacks) {
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001271 class TestCallback : public FrameCountObserver {
1272 public:
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +00001273 TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
Danil Chapovalovdd7e2842018-03-09 15:37:03 +00001274 ~TestCallback() override = default;
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001275
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001276 void FrameCountUpdated(const FrameCounts& frame_counts,
1277 uint32_t ssrc) override {
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001278 ++num_calls_;
1279 ssrc_ = ssrc;
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +00001280 frame_counts_ = frame_counts;
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001281 }
1282
1283 uint32_t num_calls_;
1284 uint32_t ssrc_;
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +00001285 FrameCounts frame_counts_;
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001286 } callback;
1287
Erik Språng7b52f102018-02-07 14:37:37 +01001288 rtp_sender_.reset(new RTPSender(
1289 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, nullptr,
1290 nullptr, nullptr, &callback, nullptr, nullptr, nullptr,
1291 &retransmission_rate_limiter_, nullptr, false));
nisse7d59f6b2017-02-21 03:40:24 -08001292 rtp_sender_->SetSSRC(kSsrc);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001293 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1294 const uint8_t payload_type = 127;
1295 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1296 0, 1500));
1297 uint8_t payload[] = {47, 11, 32, 93, 89};
1298 rtp_sender_->SetStorePacketsStatus(true, 1);
1299 uint32_t ssrc = rtp_sender_->SSRC();
1300
terelius5d332ac2016-01-14 14:37:39 -08001301 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
1302 .Times(::testing::AtLeast(2));
1303
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001304 RTPVideoHeader video_header;
spranga8ae6f22017-09-04 07:23:56 -07001305 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
1306 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001307 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001308
1309 EXPECT_EQ(1U, callback.num_calls_);
1310 EXPECT_EQ(ssrc, callback.ssrc_);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +00001311 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1312 EXPECT_EQ(0, callback.frame_counts_.delta_frames);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001313
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001314 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
1315 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001316 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001317
1318 EXPECT_EQ(2U, callback.num_calls_);
1319 EXPECT_EQ(ssrc, callback.ssrc_);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +00001320 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1321 EXPECT_EQ(1, callback.frame_counts_.delta_frames);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001322
andresp@webrtc.org8f151212014-07-10 09:39:23 +00001323 rtp_sender_.reset();
sprang@webrtc.org71f055f2013-12-04 15:09:27 +00001324}
1325
minyue3a407ee2017-04-03 01:10:33 -07001326TEST_P(RtpSenderTest, BitrateCallbacks) {
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001327 class TestCallback : public BitrateStatisticsObserver {
1328 public:
sprangcd349d92016-07-13 09:11:28 -07001329 TestCallback()
1330 : BitrateStatisticsObserver(),
1331 num_calls_(0),
1332 ssrc_(0),
1333 total_bitrate_(0),
1334 retransmit_bitrate_(0) {}
Danil Chapovalovdd7e2842018-03-09 15:37:03 +00001335 ~TestCallback() override = default;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001336
sprangcd349d92016-07-13 09:11:28 -07001337 void Notify(uint32_t total_bitrate,
1338 uint32_t retransmit_bitrate,
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001339 uint32_t ssrc) override {
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001340 ++num_calls_;
1341 ssrc_ = ssrc;
sprangcd349d92016-07-13 09:11:28 -07001342 total_bitrate_ = total_bitrate;
1343 retransmit_bitrate_ = retransmit_bitrate;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001344 }
1345
1346 uint32_t num_calls_;
1347 uint32_t ssrc_;
sprangcd349d92016-07-13 09:11:28 -07001348 uint32_t total_bitrate_;
1349 uint32_t retransmit_bitrate_;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001350 } callback;
Erik Språng7b52f102018-02-07 14:37:37 +01001351 rtp_sender_.reset(
1352 new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
1353 nullptr, &callback, nullptr, nullptr, nullptr, nullptr,
1354 &retransmission_rate_limiter_, nullptr, false));
nisse7d59f6b2017-02-21 03:40:24 -08001355 rtp_sender_->SetSSRC(kSsrc);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001356
sprangcd349d92016-07-13 09:11:28 -07001357 // Simulate kNumPackets sent with kPacketInterval ms intervals, with the
1358 // number of packets selected so that we fill (but don't overflow) the one
1359 // second averaging window.
1360 const uint32_t kWindowSizeMs = 1000;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001361 const uint32_t kPacketInterval = 20;
sprangcd349d92016-07-13 09:11:28 -07001362 const uint32_t kNumPackets =
1363 (kWindowSizeMs - kPacketInterval) / kPacketInterval;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001364 // Overhead = 12 bytes RTP header + 1 byte generic header.
1365 const uint32_t kPacketOverhead = 13;
1366
1367 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1368 const uint8_t payload_type = 127;
danilchap162abd32015-12-10 02:39:40 -08001369 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1370 0, 1500));
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001371 uint8_t payload[] = {47, 11, 32, 93, 89};
1372 rtp_sender_->SetStorePacketsStatus(true, 1);
1373 uint32_t ssrc = rtp_sender_->SSRC();
1374
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001375 // Initial process call so we get a new time window.
1376 rtp_sender_->ProcessBitrate();
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001377
1378 // Send a few frames.
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001379 RTPVideoHeader video_header;
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001380 for (uint32_t i = 0; i < kNumPackets; ++i) {
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001381 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
1382 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001383 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001384 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
1385 }
1386
1387 rtp_sender_->ProcessBitrate();
1388
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001389 // We get one call for every stats updated, thus two calls since both the
1390 // stream stats and the retransmit stats are updated once.
1391 EXPECT_EQ(2u, callback.num_calls_);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001392 EXPECT_EQ(ssrc, callback.ssrc_);
sprangcd349d92016-07-13 09:11:28 -07001393 const uint32_t kTotalPacketSize = kPacketOverhead + sizeof(payload);
1394 // Bitrate measured over delta between last and first timestamp, plus one.
1395 const uint32_t kExpectedWindowMs = kNumPackets * kPacketInterval + 1;
1396 const uint32_t kExpectedBitsAccumulated = kTotalPacketSize * kNumPackets * 8;
1397 const uint32_t kExpectedRateBps =
1398 (kExpectedBitsAccumulated * 1000 + (kExpectedWindowMs / 2)) /
1399 kExpectedWindowMs;
1400 EXPECT_EQ(kExpectedRateBps, callback.total_bitrate_);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001401
andresp@webrtc.orgd11bec42014-07-08 14:32:58 +00001402 rtp_sender_.reset();
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001403}
1404
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001405class RtpSenderAudioTest : public RtpSenderTest {
1406 protected:
1407 RtpSenderAudioTest() {}
pbos@webrtc.org8911ce42013-03-18 16:39:03 +00001408
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001409 void SetUp() override {
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001410 payload_ = kAudioPayload;
Erik Språng7b52f102018-02-07 14:37:37 +01001411 rtp_sender_.reset(
1412 new RTPSender(true, &fake_clock_, &transport_, nullptr, nullptr,
1413 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1414 nullptr, &retransmission_rate_limiter_, nullptr, false));
nisse7d59f6b2017-02-21 03:40:24 -08001415 rtp_sender_->SetSSRC(kSsrc);
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001416 rtp_sender_->SetSequenceNumber(kSeqNum);
1417 }
1418};
1419
minyue3a407ee2017-04-03 01:10:33 -07001420TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001421 class TestCallback : public StreamDataCountersCallback {
1422 public:
danilchap162abd32015-12-10 02:39:40 -08001423 TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {}
Danil Chapovalovdd7e2842018-03-09 15:37:03 +00001424 ~TestCallback() override = default;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001425
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001426 void DataCountersUpdated(const StreamDataCounters& counters,
1427 uint32_t ssrc) override {
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001428 ssrc_ = ssrc;
1429 counters_ = counters;
1430 }
1431
1432 uint32_t ssrc_;
1433 StreamDataCounters counters_;
asapersson@webrtc.org44149392015-02-04 08:34:47 +00001434
1435 void MatchPacketCounter(const RtpPacketCounter& expected,
1436 const RtpPacketCounter& actual) {
1437 EXPECT_EQ(expected.payload_bytes, actual.payload_bytes);
1438 EXPECT_EQ(expected.header_bytes, actual.header_bytes);
1439 EXPECT_EQ(expected.padding_bytes, actual.padding_bytes);
1440 EXPECT_EQ(expected.packets, actual.packets);
1441 }
1442
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001443 void Matches(uint32_t ssrc, const StreamDataCounters& counters) {
1444 EXPECT_EQ(ssrc, ssrc_);
asapersson@webrtc.org44149392015-02-04 08:34:47 +00001445 MatchPacketCounter(counters.transmitted, counters_.transmitted);
1446 MatchPacketCounter(counters.retransmitted, counters_.retransmitted);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001447 EXPECT_EQ(counters.fec.packets, counters_.fec.packets);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001448 }
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001449 } callback;
1450
1451 const uint8_t kRedPayloadType = 96;
1452 const uint8_t kUlpfecPayloadType = 97;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001453 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1454 const uint8_t payload_type = 127;
1455 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1456 0, 1500));
1457 uint8_t payload[] = {47, 11, 32, 93, 89};
1458 rtp_sender_->SetStorePacketsStatus(true, 1);
1459 uint32_t ssrc = rtp_sender_->SSRC();
1460
1461 rtp_sender_->RegisterRtpStatisticsCallback(&callback);
1462
1463 // Send a frame.
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001464 RTPVideoHeader video_header;
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001465 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001466 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001467 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001468 StreamDataCounters expected;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001469 expected.transmitted.payload_bytes = 6;
1470 expected.transmitted.header_bytes = 12;
1471 expected.transmitted.padding_bytes = 0;
1472 expected.transmitted.packets = 1;
1473 expected.retransmitted.payload_bytes = 0;
1474 expected.retransmitted.header_bytes = 0;
1475 expected.retransmitted.padding_bytes = 0;
1476 expected.retransmitted.packets = 0;
1477 expected.fec.packets = 0;
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001478 callback.Matches(ssrc, expected);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001479
1480 // Retransmit a frame.
1481 uint16_t seqno = rtp_sender_->SequenceNumber() - 1;
Erik Språnga12b1d62018-03-14 12:39:24 +01001482 rtp_sender_->ReSendPacket(seqno);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001483 expected.transmitted.payload_bytes = 12;
1484 expected.transmitted.header_bytes = 24;
1485 expected.transmitted.packets = 2;
1486 expected.retransmitted.payload_bytes = 6;
1487 expected.retransmitted.header_bytes = 12;
1488 expected.retransmitted.padding_bytes = 0;
1489 expected.retransmitted.packets = 1;
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001490 callback.Matches(ssrc, expected);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001491
1492 // Send padding.
philipel8aadd502017-02-23 02:56:13 -08001493 rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacedPacketInfo());
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001494 expected.transmitted.payload_bytes = 12;
1495 expected.transmitted.header_bytes = 36;
1496 expected.transmitted.padding_bytes = kMaxPaddingSize;
1497 expected.transmitted.packets = 3;
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001498 callback.Matches(ssrc, expected);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001499
brandtrf1bb4762016-11-07 03:05:06 -08001500 // Send ULPFEC.
1501 rtp_sender_->SetUlpfecConfig(kRedPayloadType, kUlpfecPayloadType);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001502 FecProtectionParams fec_params;
1503 fec_params.fec_mask_type = kFecMaskRandom;
1504 fec_params.fec_rate = 1;
1505 fec_params.max_fec_frames = 1;
brandtr1743a192016-11-07 03:36:05 -08001506 rtp_sender_->SetFecParameters(fec_params, fec_params);
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001507 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001508 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001509 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001510 expected.transmitted.payload_bytes = 40;
1511 expected.transmitted.header_bytes = 60;
1512 expected.transmitted.packets = 5;
1513 expected.fec.packets = 1;
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001514 callback.Matches(ssrc, expected);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001515
sprang867fb522015-08-03 04:38:41 -07001516 rtp_sender_->RegisterRtpStatisticsCallback(nullptr);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001517}
1518
minyue3a407ee2017-04-03 01:10:33 -07001519TEST_P(RtpSenderAudioTest, SendAudio) {
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001520 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1521 const uint8_t payload_type = 127;
1522 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1523 0, 1500));
1524 uint8_t payload[] = {47, 11, 32, 93, 89};
1525
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001526 RTPVideoHeader video_header;
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001527 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001528 kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001529 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001530
danilchap96c15872016-11-21 01:35:29 -08001531 auto sent_payload = transport_.last_sent_packet().payload();
1532 EXPECT_THAT(sent_payload, ElementsAreArray(payload));
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001533}
1534
minyue3a407ee2017-04-03 01:10:33 -07001535TEST_P(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001536 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
danilchap162abd32015-12-10 02:39:40 -08001537 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
1538 kAudioLevelExtensionId));
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001539
1540 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1541 const uint8_t payload_type = 127;
1542 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1543 0, 1500));
1544 uint8_t payload[] = {47, 11, 32, 93, 89};
1545
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001546 RTPVideoHeader video_header;
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001547 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001548 kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001549 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001550
danilchap96c15872016-11-21 01:35:29 -08001551 auto sent_payload = transport_.last_sent_packet().payload();
1552 EXPECT_THAT(sent_payload, ElementsAreArray(payload));
danilchap12ba1862016-10-26 02:41:55 -07001553 // Verify AudioLevel extension.
1554 bool voice_activity;
1555 uint8_t audio_level;
1556 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<AudioLevel>(
1557 &voice_activity, &audio_level));
1558 EXPECT_EQ(kAudioLevel, audio_level);
1559 EXPECT_FALSE(voice_activity);
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001560}
1561
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001562// As RFC4733, named telephone events are carried as part of the audio stream
1563// and must use the same sequence number and timestamp base as the regular
1564// audio channel.
1565// This test checks the marker bit for the first packet and the consequent
1566// packets of the same telephone event. Since it is specifically for DTMF
pbos22993e12015-10-19 02:39:06 -07001567// events, ignoring audio packets and sending kEmptyFrame instead of those.
minyue3a407ee2017-04-03 01:10:33 -07001568TEST_P(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
solenbergffbbcac2016-11-17 05:25:37 -08001569 const char* kDtmfPayloadName = "telephone-event";
1570 const uint32_t kPayloadFrequency = 8000;
1571 const uint8_t kPayloadType = 126;
1572 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kDtmfPayloadName, kPayloadType,
1573 kPayloadFrequency, 0, 0));
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001574 // For Telephone events, payload is not added to the registered payload list,
1575 // it will register only the payload used for audio stream.
1576 // Registering the payload again for audio stream with different payload name.
solenbergffbbcac2016-11-17 05:25:37 -08001577 const char* kPayloadName = "payload_name";
1578 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType,
1579 kPayloadFrequency, 1, 0));
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001580 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
1581 // DTMF event key=9, duration=500 and attenuationdB=10
1582 rtp_sender_->SendTelephoneEvent(9, 500, 10);
1583 // During start, it takes the starting timestamp as last sent timestamp.
1584 // The duration is calculated as the difference of current and last sent
1585 // timestamp. So for first call it will skip since the duration is zero.
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001586 RTPVideoHeader video_header;
spranga8ae6f22017-09-04 07:23:56 -07001587 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
1588 kEmptyFrame, kPayloadType, capture_time_ms, 0, nullptr, 0, nullptr,
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001589 &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001590 // DTMF Sample Length is (Frequency/1000) * Duration.
1591 // So in this case, it is (8000/1000) * 500 = 4000.
1592 // Sending it as two packets.
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001593 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001594 kEmptyFrame, kPayloadType, capture_time_ms + 2000, 0, nullptr, 0, nullptr,
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001595 &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
danilchap12ba1862016-10-26 02:41:55 -07001596
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001597 // Marker Bit should be set to 1 for first packet.
danilchap12ba1862016-10-26 02:41:55 -07001598 EXPECT_TRUE(transport_.last_sent_packet().Marker());
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001599
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001600 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001601 kEmptyFrame, kPayloadType, capture_time_ms + 4000, 0, nullptr, 0, nullptr,
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001602 &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001603 // Marker Bit should be set to 0 for rest of the packets.
danilchap12ba1862016-10-26 02:41:55 -07001604 EXPECT_FALSE(transport_.last_sent_packet().Marker());
stefan@webrtc.org0a214ff2014-09-03 11:46:54 +00001605}
1606
minyue3a407ee2017-04-03 01:10:33 -07001607TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001608 const char* kPayloadName = "GENERIC";
1609 const uint8_t kPayloadType = 127;
1610 rtp_sender_->SetSSRC(1234);
1611 rtp_sender_->SetRtxSsrc(4321);
Shao Changbine62202f2015-04-21 20:24:50 +08001612 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +00001613 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001614
danilchap162abd32015-12-10 02:39:40 -08001615 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000,
1616 0, 1500));
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001617 uint8_t payload[] = {47, 11, 32, 93, 89};
1618
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001619 RTPVideoHeader video_header;
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001620 ASSERT_TRUE(rtp_sender_->SendOutgoingData(
spranga8ae6f22017-09-04 07:23:56 -07001621 kVideoFrameKey, kPayloadType, 1234, 4321, payload, sizeof(payload),
Sami Kalliomäki426a80c2018-08-08 11:37:59 +02001622 nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001623
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001624 // Will send 2 full-size padding packets.
philipel8aadd502017-02-23 02:56:13 -08001625 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo());
1626 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo());
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001627
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001628 StreamDataCounters rtp_stats;
1629 StreamDataCounters rtx_stats;
1630 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001631
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001632 // Payload + 1-byte generic header.
asapersson@webrtc.orgd08d3892014-12-16 12:03:11 +00001633 EXPECT_GT(rtp_stats.first_packet_time_ms, -1);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001634 EXPECT_EQ(rtp_stats.transmitted.payload_bytes, sizeof(payload) + 1);
1635 EXPECT_EQ(rtp_stats.transmitted.header_bytes, 12u);
1636 EXPECT_EQ(rtp_stats.transmitted.padding_bytes, 0u);
1637 EXPECT_EQ(rtx_stats.transmitted.payload_bytes, 0u);
1638 EXPECT_EQ(rtx_stats.transmitted.header_bytes, 24u);
1639 EXPECT_EQ(rtx_stats.transmitted.padding_bytes, 2 * kMaxPaddingSize);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001640
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001641 EXPECT_EQ(rtp_stats.transmitted.TotalBytes(),
danilchap162abd32015-12-10 02:39:40 -08001642 rtp_stats.transmitted.payload_bytes +
1643 rtp_stats.transmitted.header_bytes +
1644 rtp_stats.transmitted.padding_bytes);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001645 EXPECT_EQ(rtx_stats.transmitted.TotalBytes(),
danilchap162abd32015-12-10 02:39:40 -08001646 rtx_stats.transmitted.payload_bytes +
1647 rtx_stats.transmitted.header_bytes +
1648 rtx_stats.transmitted.padding_bytes);
asapersson@webrtc.org97d04892014-12-09 09:47:53 +00001649
danilchap162abd32015-12-10 02:39:40 -08001650 EXPECT_EQ(
1651 transport_.total_bytes_sent_,
1652 rtp_stats.transmitted.TotalBytes() + rtx_stats.transmitted.TotalBytes());
pbos@webrtc.org72491b92014-07-10 16:24:54 +00001653}
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001654
minyue3a407ee2017-04-03 01:10:33 -07001655TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
sprang38778b02015-09-29 09:48:22 -07001656 const int32_t kPacketSize = 1400;
1657 const int32_t kNumPackets = 30;
1658
sprangcd349d92016-07-13 09:11:28 -07001659 retransmission_rate_limiter_.SetMaxRate(kPacketSize * kNumPackets * 8);
1660
sprang38778b02015-09-29 09:48:22 -07001661 rtp_sender_->SetStorePacketsStatus(true, kNumPackets);
sprang38778b02015-09-29 09:48:22 -07001662 const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber();
Danil Chapovalov2800d742016-08-26 18:48:46 +02001663 std::vector<uint16_t> sequence_numbers;
sprang38778b02015-09-29 09:48:22 -07001664 for (int32_t i = 0; i < kNumPackets; ++i) {
1665 sequence_numbers.push_back(kStartSequenceNumber + i);
1666 fake_clock_.AdvanceTimeMilliseconds(1);
1667 SendPacket(fake_clock_.TimeInMilliseconds(), kPacketSize);
1668 }
danilchap12ba1862016-10-26 02:41:55 -07001669 EXPECT_EQ(kNumPackets, transport_.packets_sent());
sprang38778b02015-09-29 09:48:22 -07001670
1671 fake_clock_.AdvanceTimeMilliseconds(1000 - kNumPackets);
1672
1673 // Resending should work - brings the bandwidth up to the limit.
1674 // NACK bitrate is capped to the same bitrate as the encoder, since the max
1675 // protection overhead is 50% (see MediaOptimization::SetTargetRates).
Danil Chapovalov2800d742016-08-26 18:48:46 +02001676 rtp_sender_->OnReceivedNack(sequence_numbers, 0);
danilchap12ba1862016-10-26 02:41:55 -07001677 EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
sprang38778b02015-09-29 09:48:22 -07001678
sprangcd349d92016-07-13 09:11:28 -07001679 // Must be at least 5ms in between retransmission attempts.
1680 fake_clock_.AdvanceTimeMilliseconds(5);
1681
sprang38778b02015-09-29 09:48:22 -07001682 // Resending should not work, bandwidth exceeded.
Danil Chapovalov2800d742016-08-26 18:48:46 +02001683 rtp_sender_->OnReceivedNack(sequence_numbers, 0);
danilchap12ba1862016-10-26 02:41:55 -07001684 EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
sprang38778b02015-09-29 09:48:22 -07001685}
1686
minyue3a407ee2017-04-03 01:10:33 -07001687TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
danilchapb6f1fb52016-10-19 06:11:39 -07001688 uint8_t kFrame[kMaxPacketLength];
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001689 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1690 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001691
philipel1a4746a2018-07-09 15:52:29 +02001692 RTPVideoHeader hdr;
danilchapc1600c52016-10-26 03:33:11 -07001693 hdr.rotation = kVideoRotation_0;
Niels Möller520ca4e2018-06-04 11:14:38 +02001694 rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload,
danilchapb6f1fb52016-10-19 06:11:39 -07001695 kTimestamp, 0, kFrame, sizeof(kFrame), nullptr,
spranga8ae6f22017-09-04 07:23:56 -07001696 &hdr, kDefaultExpectedRetransmissionTimeMs);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001697
danilchapc1600c52016-10-26 03:33:11 -07001698 VideoRotation rotation;
1699 EXPECT_TRUE(
1700 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
1701 EXPECT_EQ(kVideoRotation_0, rotation);
1702}
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001703
ilnik04f4d122017-06-19 07:18:55 -07001704TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
1705 uint8_t kFrame[kMaxPacketLength];
1706 const int64_t kPacketizationTimeMs = 100;
1707 const int64_t kEncodeStartDeltaMs = 10;
1708 const int64_t kEncodeFinishDeltaMs = 50;
1709 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1710 kRtpExtensionVideoTiming, kVideoTimingExtensionId));
1711
1712 const int64_t kCaptureTimestamp = fake_clock_.TimeInMilliseconds();
1713
philipel1a4746a2018-07-09 15:52:29 +02001714 RTPVideoHeader hdr;
Ilya Nikolaevskiyb6c462d2018-06-05 15:21:32 +02001715 hdr.video_timing.flags = VideoSendTiming::kTriggeredByTimer;
ilnik04f4d122017-06-19 07:18:55 -07001716 hdr.video_timing.encode_start_delta_ms = kEncodeStartDeltaMs;
1717 hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs;
1718
1719 fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs);
Niels Möller520ca4e2018-06-04 11:14:38 +02001720 rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload,
ilnik04f4d122017-06-19 07:18:55 -07001721 kTimestamp, kCaptureTimestamp, kFrame,
spranga8ae6f22017-09-04 07:23:56 -07001722 sizeof(kFrame), nullptr, &hdr,
1723 kDefaultExpectedRetransmissionTimeMs);
ilnik2edc6842017-07-06 03:06:50 -07001724 VideoSendTiming timing;
ilnik04f4d122017-06-19 07:18:55 -07001725 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>(
1726 &timing));
1727 EXPECT_EQ(kPacketizationTimeMs, timing.packetization_finish_delta_ms);
1728 EXPECT_EQ(kEncodeStartDeltaMs, timing.encode_start_delta_ms);
1729 EXPECT_EQ(kEncodeFinishDeltaMs, timing.encode_finish_delta_ms);
1730}
1731
minyue3a407ee2017-04-03 01:10:33 -07001732TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
danilchapc1600c52016-10-26 03:33:11 -07001733 uint8_t kFrame[kMaxPacketLength];
1734 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1735 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
1736
philipel1a4746a2018-07-09 15:52:29 +02001737 RTPVideoHeader hdr;
danilchapc1600c52016-10-26 03:33:11 -07001738 hdr.rotation = kVideoRotation_90;
spranga8ae6f22017-09-04 07:23:56 -07001739 EXPECT_TRUE(rtp_sender_video_->SendVideo(
Niels Möller520ca4e2018-06-04 11:14:38 +02001740 kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
spranga8ae6f22017-09-04 07:23:56 -07001741 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
danilchapc1600c52016-10-26 03:33:11 -07001742
1743 hdr.rotation = kVideoRotation_0;
spranga8ae6f22017-09-04 07:23:56 -07001744 EXPECT_TRUE(rtp_sender_video_->SendVideo(
Niels Möller520ca4e2018-06-04 11:14:38 +02001745 kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
spranga8ae6f22017-09-04 07:23:56 -07001746 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
danilchapc1600c52016-10-26 03:33:11 -07001747
1748 VideoRotation rotation;
1749 EXPECT_TRUE(
1750 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
1751 EXPECT_EQ(kVideoRotation_0, rotation);
1752}
1753
minyue3a407ee2017-04-03 01:10:33 -07001754TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
danilchapc1600c52016-10-26 03:33:11 -07001755 uint8_t kFrame[kMaxPacketLength];
1756 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1757 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
1758
philipel1a4746a2018-07-09 15:52:29 +02001759 RTPVideoHeader hdr;
danilchapc1600c52016-10-26 03:33:11 -07001760 hdr.rotation = kVideoRotation_90;
spranga8ae6f22017-09-04 07:23:56 -07001761 EXPECT_TRUE(rtp_sender_video_->SendVideo(
Niels Möller520ca4e2018-06-04 11:14:38 +02001762 kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
spranga8ae6f22017-09-04 07:23:56 -07001763 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
danilchapc1600c52016-10-26 03:33:11 -07001764
spranga8ae6f22017-09-04 07:23:56 -07001765 EXPECT_TRUE(rtp_sender_video_->SendVideo(
Niels Möller520ca4e2018-06-04 11:14:38 +02001766 kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
spranga8ae6f22017-09-04 07:23:56 -07001767 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
danilchapc1600c52016-10-26 03:33:11 -07001768
1769 VideoRotation rotation;
1770 EXPECT_TRUE(
1771 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation));
1772 EXPECT_EQ(kVideoRotation_90, rotation);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001773}
magjed71eb61c2016-09-08 03:24:58 -07001774
1775// Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits
1776// are set in the CVO byte.
minyue3a407ee2017-04-03 01:10:33 -07001777TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
magjed71eb61c2016-09-08 03:24:58 -07001778 // Test extracting rotation when Camera (C) and Flip (F) bits are zero.
1779 EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0));
1780 EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1));
1781 EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2));
1782 EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3));
1783 // Test extracting rotation when Camera (C) and Flip (F) bits are set.
1784 const int flip_bit = 1 << 2;
1785 const int camera_bit = 1 << 3;
1786 EXPECT_EQ(kVideoRotation_0,
1787 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0));
1788 EXPECT_EQ(kVideoRotation_90,
1789 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1));
1790 EXPECT_EQ(kVideoRotation_180,
1791 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2));
1792 EXPECT_EQ(kVideoRotation_270,
1793 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
1794}
1795
spranga8ae6f22017-09-04 07:23:56 -07001796TEST_P(RtpSenderVideoTest, RetransmissionTypesGeneric) {
1797 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001798 header.codec = kVideoCodecGeneric;
spranga8ae6f22017-09-04 07:23:56 -07001799
1800 EXPECT_EQ(kDontRetransmit,
1801 rtp_sender_video_->GetStorageType(
1802 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs));
1803 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1804 header, kRetransmitBaseLayer,
1805 kDefaultExpectedRetransmissionTimeMs));
1806 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1807 header, kRetransmitHigherLayers,
1808 kDefaultExpectedRetransmissionTimeMs));
1809 EXPECT_EQ(kAllowRetransmission,
1810 rtp_sender_video_->GetStorageType(
1811 header, kConditionallyRetransmitHigherLayers,
1812 kDefaultExpectedRetransmissionTimeMs));
1813 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1814 header, kRetransmitAllPackets,
1815 kDefaultExpectedRetransmissionTimeMs));
1816}
1817
1818TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) {
1819 RTPVideoHeader header;
philipel7d745e52018-08-02 14:03:53 +02001820 header.video_type_header.emplace<RTPVideoHeaderH264>().packetization_mode =
1821 H264PacketizationMode::NonInterleaved;
Niels Möller520ca4e2018-06-04 11:14:38 +02001822 header.codec = kVideoCodecH264;
spranga8ae6f22017-09-04 07:23:56 -07001823
1824 EXPECT_EQ(kDontRetransmit,
1825 rtp_sender_video_->GetStorageType(
1826 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs));
1827 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1828 header, kRetransmitBaseLayer,
1829 kDefaultExpectedRetransmissionTimeMs));
1830 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1831 header, kRetransmitHigherLayers,
1832 kDefaultExpectedRetransmissionTimeMs));
1833 EXPECT_EQ(kAllowRetransmission,
1834 rtp_sender_video_->GetStorageType(
1835 header, kConditionallyRetransmitHigherLayers,
1836 kDefaultExpectedRetransmissionTimeMs));
1837 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1838 header, kRetransmitAllPackets,
1839 kDefaultExpectedRetransmissionTimeMs));
1840}
1841
1842TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8BaseLayer) {
1843 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001844 header.codec = kVideoCodecVP8;
Philip Eliassond52a1a62018-09-07 13:03:55 +00001845 auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>();
1846 vp8_header.temporalIdx = 0;
spranga8ae6f22017-09-04 07:23:56 -07001847
1848 EXPECT_EQ(kDontRetransmit,
1849 rtp_sender_video_->GetStorageType(
1850 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs));
1851 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1852 header, kRetransmitBaseLayer,
1853 kDefaultExpectedRetransmissionTimeMs));
1854 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1855 header, kRetransmitHigherLayers,
1856 kDefaultExpectedRetransmissionTimeMs));
1857 EXPECT_EQ(kAllowRetransmission,
1858 rtp_sender_video_->GetStorageType(
1859 header, kRetransmitHigherLayers | kRetransmitBaseLayer,
1860 kDefaultExpectedRetransmissionTimeMs));
1861 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1862 header, kConditionallyRetransmitHigherLayers,
1863 kDefaultExpectedRetransmissionTimeMs));
1864 EXPECT_EQ(
1865 kAllowRetransmission,
1866 rtp_sender_video_->GetStorageType(
1867 header, kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers,
1868 kDefaultExpectedRetransmissionTimeMs));
1869 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1870 header, kRetransmitAllPackets,
1871 kDefaultExpectedRetransmissionTimeMs));
1872}
1873
1874TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8HigherLayers) {
1875 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001876 header.codec = kVideoCodecVP8;
spranga8ae6f22017-09-04 07:23:56 -07001877
Philip Eliassond52a1a62018-09-07 13:03:55 +00001878 auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>();
spranga8ae6f22017-09-04 07:23:56 -07001879 for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) {
Philip Eliassond52a1a62018-09-07 13:03:55 +00001880 vp8_header.temporalIdx = tid;
spranga8ae6f22017-09-04 07:23:56 -07001881
1882 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1883 header, kRetransmitOff,
1884 kDefaultExpectedRetransmissionTimeMs));
1885 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1886 header, kRetransmitBaseLayer,
1887 kDefaultExpectedRetransmissionTimeMs));
1888 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1889 header, kRetransmitHigherLayers,
1890 kDefaultExpectedRetransmissionTimeMs));
1891 EXPECT_EQ(kAllowRetransmission,
1892 rtp_sender_video_->GetStorageType(
1893 header, kRetransmitHigherLayers | kRetransmitBaseLayer,
1894 kDefaultExpectedRetransmissionTimeMs));
1895 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1896 header, kRetransmitAllPackets,
1897 kDefaultExpectedRetransmissionTimeMs));
1898 }
1899}
1900
1901TEST_P(RtpSenderVideoTest, RetransmissionTypesVP9) {
1902 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001903 header.codec = kVideoCodecVP9;
spranga8ae6f22017-09-04 07:23:56 -07001904
philipel29d88462018-08-08 14:26:00 +02001905 auto& vp9_header = header.video_type_header.emplace<RTPVideoHeaderVP9>();
spranga8ae6f22017-09-04 07:23:56 -07001906 for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) {
philipel29d88462018-08-08 14:26:00 +02001907 vp9_header.temporal_idx = tid;
spranga8ae6f22017-09-04 07:23:56 -07001908
1909 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1910 header, kRetransmitOff,
1911 kDefaultExpectedRetransmissionTimeMs));
1912 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
1913 header, kRetransmitBaseLayer,
1914 kDefaultExpectedRetransmissionTimeMs));
1915 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1916 header, kRetransmitHigherLayers,
1917 kDefaultExpectedRetransmissionTimeMs));
1918 EXPECT_EQ(kAllowRetransmission,
1919 rtp_sender_video_->GetStorageType(
1920 header, kRetransmitHigherLayers | kRetransmitBaseLayer,
1921 kDefaultExpectedRetransmissionTimeMs));
1922 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType(
1923 header, kRetransmitAllPackets,
1924 kDefaultExpectedRetransmissionTimeMs));
1925 }
1926}
1927
1928TEST_P(RtpSenderVideoTest, ConditionalRetransmit) {
1929 const int64_t kFrameIntervalMs = 33;
1930 const int64_t kRttMs = (kFrameIntervalMs * 3) / 2;
1931 const uint8_t kSettings =
1932 kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers;
1933
1934 // Insert VP8 frames for all temporal layers, but stop before the final index.
1935 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001936 header.codec = kVideoCodecVP8;
spranga8ae6f22017-09-04 07:23:56 -07001937
1938 // Fill averaging window to prevent rounding errors.
1939 constexpr int kNumRepetitions =
1940 (RTPSenderVideo::kTLRateWindowSizeMs + (kFrameIntervalMs / 2)) /
1941 kFrameIntervalMs;
1942 constexpr int kPattern[] = {0, 2, 1, 2};
Philip Eliassond52a1a62018-09-07 13:03:55 +00001943 auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>();
spranga8ae6f22017-09-04 07:23:56 -07001944 for (size_t i = 0; i < arraysize(kPattern) * kNumRepetitions; ++i) {
Philip Eliassond52a1a62018-09-07 13:03:55 +00001945 vp8_header.temporalIdx = kPattern[i % arraysize(kPattern)];
spranga8ae6f22017-09-04 07:23:56 -07001946 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs);
1947 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1948 }
1949
1950 // Since we're at the start of the pattern, the next expected frame in TL0 is
1951 // right now. We will wait at most one expected retransmission time before
1952 // acknowledging that it did not arrive, which means this frame and the next
1953 // will not be retransmitted.
Philip Eliassond52a1a62018-09-07 13:03:55 +00001954 vp8_header.temporalIdx = 1;
spranga8ae6f22017-09-04 07:23:56 -07001955 EXPECT_EQ(StorageType::kDontRetransmit,
1956 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1957 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1958 EXPECT_EQ(StorageType::kDontRetransmit,
1959 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1960 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1961
1962 // The TL0 frame did not arrive. So allow retransmission.
1963 EXPECT_EQ(StorageType::kAllowRetransmission,
1964 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1965 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1966
1967 // Insert a frame for TL2. We just had frame in TL1, so the next one there is
1968 // in three frames away. TL0 is still too far in the past. So, allow
1969 // retransmission.
Philip Eliassond52a1a62018-09-07 13:03:55 +00001970 vp8_header.temporalIdx = 2;
spranga8ae6f22017-09-04 07:23:56 -07001971 EXPECT_EQ(StorageType::kAllowRetransmission,
1972 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1973 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1974
1975 // Another TL2, next in TL1 is two frames away. Allow again.
1976 EXPECT_EQ(StorageType::kAllowRetransmission,
1977 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1978 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
1979
1980 // Yet another TL2, next in TL1 is now only one frame away, so don't store
1981 // for retransmission.
1982 EXPECT_EQ(StorageType::kDontRetransmit,
1983 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
1984}
1985
1986TEST_P(RtpSenderVideoTest, ConditionalRetransmitLimit) {
1987 const int64_t kFrameIntervalMs = 200;
1988 const int64_t kRttMs = (kFrameIntervalMs * 3) / 2;
1989 const int32_t kSettings =
1990 kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers;
1991
1992 // Insert VP8 frames for all temporal layers, but stop before the final index.
1993 RTPVideoHeader header;
Niels Möller520ca4e2018-06-04 11:14:38 +02001994 header.codec = kVideoCodecVP8;
spranga8ae6f22017-09-04 07:23:56 -07001995
1996 // Fill averaging window to prevent rounding errors.
1997 constexpr int kNumRepetitions =
1998 (RTPSenderVideo::kTLRateWindowSizeMs + (kFrameIntervalMs / 2)) /
1999 kFrameIntervalMs;
2000 constexpr int kPattern[] = {0, 2, 2, 2};
Philip Eliassond52a1a62018-09-07 13:03:55 +00002001 auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>();
spranga8ae6f22017-09-04 07:23:56 -07002002 for (size_t i = 0; i < arraysize(kPattern) * kNumRepetitions; ++i) {
Philip Eliassond52a1a62018-09-07 13:03:55 +00002003 vp8_header.temporalIdx = kPattern[i % arraysize(kPattern)];
spranga8ae6f22017-09-04 07:23:56 -07002004
2005 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs);
2006 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
2007 }
2008
2009 // Since we're at the start of the pattern, the next expected frame will be
2010 // right now in TL0. Put it in TL1 instead. Regular rules would dictate that
2011 // we don't store for retransmission because we expect a frame in a lower
2012 // layer, but that last frame in TL1 was a long time ago in absolute terms,
2013 // so allow retransmission anyway.
Philip Eliassond52a1a62018-09-07 13:03:55 +00002014 vp8_header.temporalIdx = 1;
spranga8ae6f22017-09-04 07:23:56 -07002015 EXPECT_EQ(StorageType::kAllowRetransmission,
2016 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs));
2017}
2018
minyue3a407ee2017-04-03 01:10:33 -07002019TEST_P(RtpSenderTest, OnOverheadChanged) {
michaelt4da30442016-11-17 01:38:43 -08002020 MockOverheadObserver mock_overhead_observer;
Erik Språng7b52f102018-02-07 14:37:37 +01002021 rtp_sender_.reset(new RTPSender(
2022 false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
2023 nullptr, nullptr, nullptr, nullptr, nullptr,
2024 &retransmission_rate_limiter_, &mock_overhead_observer, false));
nisse7d59f6b2017-02-21 03:40:24 -08002025 rtp_sender_->SetSSRC(kSsrc);
michaelt4da30442016-11-17 01:38:43 -08002026
michaelt4da30442016-11-17 01:38:43 -08002027 // RTP overhead is 12B.
nisse284542b2017-01-10 08:58:32 -08002028 EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1);
michaelt4da30442016-11-17 01:38:43 -08002029 SendGenericPayload();
2030
2031 rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
2032 kTransmissionTimeOffsetExtensionId);
2033
2034 // TransmissionTimeOffset extension has a size of 8B.
nisse284542b2017-01-10 08:58:32 -08002035 // 12B + 8B = 20B
2036 EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(20)).Times(1);
michaelt4da30442016-11-17 01:38:43 -08002037 SendGenericPayload();
2038}
2039
minyue3a407ee2017-04-03 01:10:33 -07002040TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
michaelt4da30442016-11-17 01:38:43 -08002041 MockOverheadObserver mock_overhead_observer;
Erik Språng7b52f102018-02-07 14:37:37 +01002042 rtp_sender_.reset(new RTPSender(
2043 false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
2044 nullptr, nullptr, nullptr, nullptr, nullptr,
2045 &retransmission_rate_limiter_, &mock_overhead_observer, false));
nisse7d59f6b2017-02-21 03:40:24 -08002046 rtp_sender_->SetSSRC(kSsrc);
michaelt4da30442016-11-17 01:38:43 -08002047
2048 EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
michaelt4da30442016-11-17 01:38:43 -08002049 SendGenericPayload();
2050 SendGenericPayload();
2051}
2052
sprang168794c2017-07-06 04:38:06 -07002053TEST_P(RtpSenderTest, SendsKeepAlive) {
2054 MockTransport transport;
Erik Språng7b52f102018-02-07 14:37:37 +01002055 rtp_sender_.reset(
2056 new RTPSender(false, &fake_clock_, &transport, nullptr, nullptr, nullptr,
2057 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
2058 nullptr, &retransmission_rate_limiter_, nullptr, false));
sprang168794c2017-07-06 04:38:06 -07002059 rtp_sender_->SetSequenceNumber(kSeqNum);
2060 rtp_sender_->SetTimestampOffset(0);
2061 rtp_sender_->SetSSRC(kSsrc);
2062
2063 const uint8_t kKeepalivePayloadType = 20;
2064 RTC_CHECK_NE(kKeepalivePayloadType, kPayload);
2065
2066 EXPECT_CALL(transport, SendRtp(_, _, _))
2067 .WillOnce(
2068 Invoke([&kKeepalivePayloadType](const uint8_t* packet, size_t len,
2069 const PacketOptions& options) {
2070 webrtc::RTPHeader rtp_header;
2071 RtpUtility::RtpHeaderParser parser(packet, len);
2072 EXPECT_TRUE(parser.Parse(&rtp_header, nullptr));
2073 EXPECT_FALSE(rtp_header.markerBit);
2074 EXPECT_EQ(0U, rtp_header.paddingLength);
2075 EXPECT_EQ(kKeepalivePayloadType, rtp_header.payloadType);
2076 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
2077 EXPECT_EQ(kSsrc, rtp_header.ssrc);
2078 EXPECT_EQ(0u, len - rtp_header.headerLength);
2079 return true;
2080 }));
2081
2082 rtp_sender_->SendKeepAlive(kKeepalivePayloadType);
2083 EXPECT_EQ(kSeqNum + 1, rtp_sender_->SequenceNumber());
2084}
2085
minyue3a407ee2017-04-03 01:10:33 -07002086INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
2087 RtpSenderTest,
2088 ::testing::Bool());
2089INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
2090 RtpSenderTestWithoutPacer,
2091 ::testing::Bool());
2092INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
2093 RtpSenderVideoTest,
2094 ::testing::Bool());
2095INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
2096 RtpSenderAudioTest,
2097 ::testing::Bool());
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00002098} // namespace webrtc