1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /*
12 * This file includes unit tests for the RTPSender.
13 */
14
15 #include <list>
16 #include <vector>
17
18 #include "testing/gmock/include/gmock/gmock.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20 #include "webrtc/base/buffer.h"
21 #include "webrtc/base/scoped_ptr.h"
22 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
23 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
24 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
25 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
26 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
27 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
28 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
29 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
30 #include "webrtc/system_wrappers/include/stl_util.h"
31 #include "webrtc/test/mock_transport.h"
32 #include "webrtc/typedefs.h"
33
34 namespace webrtc {
35
36 namespace {
37 const int kTransmissionTimeOffsetExtensionId = 1;
38 const int kAbsoluteSendTimeExtensionId = 14;
39 const int kTransportSequenceNumberExtensionId = 13;
40 const int kPayload = 100;
41 const int kRtxPayload = 98;
42 const uint32_t kTimestamp = 10;
43 const uint16_t kSeqNum = 33;
44 const int kTimeOffset = 22222;
45 const int kMaxPacketLength = 1500;
46 const uint32_t kAbsoluteSendTime = 0x00aabbcc;
47 const uint8_t kAudioLevel = 0x5a;
48 const uint16_t kTransportSequenceNumber = 0xaabbu;
49 const uint8_t kAudioLevelExtensionId = 9;
50 const int kAudioPayload = 103;
51 const uint64_t kStartTime = 123456789;
52 const size_t kMaxPaddingSize = 224u;
53 const int kVideoRotationExtensionId = 5;
54 const VideoRotation kRotation = kVideoRotation_270;
55
56 using testing::_;
57
GetPayloadData(const RTPHeader & rtp_header,const uint8_t * packet)58 const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
59 const uint8_t* packet) {
60 return packet + rtp_header.headerLength;
61 }
62
GetPayloadDataLength(const RTPHeader & rtp_header,const size_t packet_length)63 size_t GetPayloadDataLength(const RTPHeader& rtp_header,
64 const size_t packet_length) {
65 return packet_length - rtp_header.headerLength - rtp_header.paddingLength;
66 }
67
ConvertMsToAbsSendTime(int64_t time_ms)68 uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
69 return (((time_ms << 18) + 500) / 1000) & 0x00ffffff;
70 }
71
72 class LoopbackTransportTest : public webrtc::Transport {
73 public:
LoopbackTransportTest()74 LoopbackTransportTest()
75 : packets_sent_(0),
76 last_sent_packet_len_(0),
77 total_bytes_sent_(0),
78 last_sent_packet_(nullptr) {}
79
~LoopbackTransportTest()80 ~LoopbackTransportTest() {
81 STLDeleteContainerPointers(sent_packets_.begin(), sent_packets_.end());
82 }
SendRtp(const uint8_t * data,size_t len,const PacketOptions & options)83 bool SendRtp(const uint8_t* data,
84 size_t len,
85 const PacketOptions& options) override {
86 packets_sent_++;
87 rtc::Buffer* buffer =
88 new rtc::Buffer(reinterpret_cast<const uint8_t*>(data), len);
89 last_sent_packet_ = buffer->data();
90 last_sent_packet_len_ = len;
91 total_bytes_sent_ += len;
92 sent_packets_.push_back(buffer);
93 return true;
94 }
SendRtcp(const uint8_t * data,size_t len)95 bool SendRtcp(const uint8_t* data, size_t len) override { return false; }
96 int packets_sent_;
97 size_t last_sent_packet_len_;
98 size_t total_bytes_sent_;
99 uint8_t* last_sent_packet_;
100 std::vector<rtc::Buffer*> sent_packets_;
101 };
102
103 } // namespace
104
105 class MockRtpPacketSender : public RtpPacketSender {
106 public:
MockRtpPacketSender()107 MockRtpPacketSender() {}
~MockRtpPacketSender()108 virtual ~MockRtpPacketSender() {}
109
110 MOCK_METHOD6(InsertPacket,
111 void(Priority priority,
112 uint32_t ssrc,
113 uint16_t sequence_number,
114 int64_t capture_time_ms,
115 size_t bytes,
116 bool retransmission));
117 };
118
119 class RtpSenderTest : public ::testing::Test {
120 protected:
RtpSenderTest()121 RtpSenderTest()
122 : fake_clock_(kStartTime),
123 mock_paced_sender_(),
124 rtp_sender_(),
125 payload_(kPayload),
126 transport_(),
127 kMarkerBit(true) {
128 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
129 .WillRepeatedly(testing::Return());
130 }
131
SetUp()132 void SetUp() override { SetUpRtpSender(true); }
133
SetUpRtpSender(bool pacer)134 void SetUpRtpSender(bool pacer) {
135 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
136 pacer ? &mock_paced_sender_ : nullptr,
137 nullptr, nullptr, nullptr, nullptr,
138 nullptr));
139 rtp_sender_->SetSequenceNumber(kSeqNum);
140 }
141
142 SimulatedClock fake_clock_;
143 MockRtpPacketSender mock_paced_sender_;
144 rtc::scoped_ptr<RTPSender> rtp_sender_;
145 int payload_;
146 LoopbackTransportTest transport_;
147 const bool kMarkerBit;
148 uint8_t packet_[kMaxPacketLength];
149
VerifyRTPHeaderCommon(const RTPHeader & rtp_header)150 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
151 VerifyRTPHeaderCommon(rtp_header, kMarkerBit);
152 }
153
VerifyRTPHeaderCommon(const RTPHeader & rtp_header,bool marker_bit)154 void VerifyRTPHeaderCommon(const RTPHeader& rtp_header, bool marker_bit) {
155 EXPECT_EQ(marker_bit, rtp_header.markerBit);
156 EXPECT_EQ(payload_, rtp_header.payloadType);
157 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
158 EXPECT_EQ(kTimestamp, rtp_header.timestamp);
159 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
160 EXPECT_EQ(0, rtp_header.numCSRCs);
161 EXPECT_EQ(0U, rtp_header.paddingLength);
162 }
163
SendPacket(int64_t capture_time_ms,int payload_length)164 void SendPacket(int64_t capture_time_ms, int payload_length) {
165 uint32_t timestamp = capture_time_ms * 90;
166 int32_t rtp_length = rtp_sender_->BuildRTPheader(
167 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
168 ASSERT_GE(rtp_length, 0);
169
170 // Packet should be stored in a send bucket.
171 EXPECT_EQ(0, rtp_sender_->SendToNetwork(
172 packet_, payload_length, rtp_length, capture_time_ms,
173 kAllowRetransmission, RtpPacketSender::kNormalPriority));
174 }
175 };
176
177 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
178 // default code path.
179 class RtpSenderTestWithoutPacer : public RtpSenderTest {
180 public:
SetUp()181 void SetUp() override { SetUpRtpSender(false); }
182 };
183
184 class RtpSenderVideoTest : public RtpSenderTest {
185 protected:
SetUp()186 void SetUp() override {
187 // TODO(pbos): Set up to use pacer.
188 SetUpRtpSender(false);
189 rtp_sender_video_.reset(
190 new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
191 }
192 rtc::scoped_ptr<RTPSenderVideo> rtp_sender_video_;
193
VerifyCVOPacket(uint8_t * data,size_t len,bool expect_cvo,RtpHeaderExtensionMap * map,uint16_t seq_num,VideoRotation rotation)194 void VerifyCVOPacket(uint8_t* data,
195 size_t len,
196 bool expect_cvo,
197 RtpHeaderExtensionMap* map,
198 uint16_t seq_num,
199 VideoRotation rotation) {
200 webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len);
201
202 webrtc::RTPHeader rtp_header;
203 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
204 packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0));
205 if (expect_cvo) {
206 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
207 length);
208 } else {
209 ASSERT_EQ(kRtpHeaderSize, length);
210 }
211 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map));
212 ASSERT_FALSE(rtp_parser.RTCP());
213 EXPECT_EQ(payload_, rtp_header.payloadType);
214 EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
215 EXPECT_EQ(kTimestamp, rtp_header.timestamp);
216 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
217 EXPECT_EQ(0, rtp_header.numCSRCs);
218 EXPECT_EQ(0U, rtp_header.paddingLength);
219 EXPECT_EQ(ConvertVideoRotationToCVOByte(rotation),
220 rtp_header.extension.videoRotation);
221 }
222 };
223
TEST_F(RtpSenderTestWithoutPacer,RegisterRtpTransmissionTimeOffsetHeaderExtension)224 TEST_F(RtpSenderTestWithoutPacer,
225 RegisterRtpTransmissionTimeOffsetHeaderExtension) {
226 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
227 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
228 kRtpExtensionTransmissionTimeOffset,
229 kTransmissionTimeOffsetExtensionId));
230 EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
231 rtp_sender_->RtpHeaderExtensionTotalLength());
232 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
233 kRtpExtensionTransmissionTimeOffset));
234 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
235 }
236
TEST_F(RtpSenderTestWithoutPacer,RegisterRtpAbsoluteSendTimeHeaderExtension)237 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAbsoluteSendTimeHeaderExtension) {
238 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
239 EXPECT_EQ(
240 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
241 kAbsoluteSendTimeExtensionId));
242 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
243 kAbsoluteSendTimeLength),
244 rtp_sender_->RtpHeaderExtensionTotalLength());
245 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
246 kRtpExtensionAbsoluteSendTime));
247 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
248 }
249
TEST_F(RtpSenderTestWithoutPacer,RegisterRtpAudioLevelHeaderExtension)250 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAudioLevelHeaderExtension) {
251 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
252 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
253 kAudioLevelExtensionId));
254 EXPECT_EQ(
255 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kAudioLevelLength),
256 rtp_sender_->RtpHeaderExtensionTotalLength());
257 EXPECT_EQ(0,
258 rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionAudioLevel));
259 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
260 }
261
TEST_F(RtpSenderTestWithoutPacer,RegisterRtpHeaderExtensions)262 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpHeaderExtensions) {
263 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
264 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
265 kRtpExtensionTransmissionTimeOffset,
266 kTransmissionTimeOffsetExtensionId));
267 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
268 kTransmissionTimeOffsetLength),
269 rtp_sender_->RtpHeaderExtensionTotalLength());
270 EXPECT_EQ(
271 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
272 kAbsoluteSendTimeExtensionId));
273 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
274 kTransmissionTimeOffsetLength +
275 kAbsoluteSendTimeLength),
276 rtp_sender_->RtpHeaderExtensionTotalLength());
277 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
278 kAudioLevelExtensionId));
279 EXPECT_EQ(RtpUtility::Word32Align(
280 kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength +
281 kAbsoluteSendTimeLength + kAudioLevelLength),
282 rtp_sender_->RtpHeaderExtensionTotalLength());
283 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
284 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
285 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
286 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
287 kTransmissionTimeOffsetLength +
288 kAbsoluteSendTimeLength +
289 kAudioLevelLength + kVideoRotationLength),
290 rtp_sender_->RtpHeaderExtensionTotalLength());
291
292 // Deregister starts.
293 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
294 kRtpExtensionTransmissionTimeOffset));
295 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
296 kAbsoluteSendTimeLength +
297 kAudioLevelLength + kVideoRotationLength),
298 rtp_sender_->RtpHeaderExtensionTotalLength());
299 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
300 kRtpExtensionAbsoluteSendTime));
301 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
302 kAudioLevelLength + kVideoRotationLength),
303 rtp_sender_->RtpHeaderExtensionTotalLength());
304 EXPECT_EQ(0,
305 rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionAudioLevel));
306 EXPECT_EQ(
307 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
308 rtp_sender_->RtpHeaderExtensionTotalLength());
309 EXPECT_EQ(
310 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
311 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
312 }
313
TEST_F(RtpSenderTestWithoutPacer,RegisterRtpVideoRotationHeaderExtension)314 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {
315 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
316 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
317 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
318 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
319
320 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
321 EXPECT_EQ(
322 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
323 rtp_sender_->RtpHeaderExtensionTotalLength());
324 EXPECT_EQ(
325 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
326 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
327 }
328
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacket)329 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
330 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
331 packet_, kPayload, kMarkerBit, kTimestamp, 0));
332 ASSERT_EQ(kRtpHeaderSize, length);
333
334 // Verify
335 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
336 webrtc::RTPHeader rtp_header;
337
338 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);
339
340 ASSERT_TRUE(valid_rtp_header);
341 ASSERT_FALSE(rtp_parser.RTCP());
342 VerifyRTPHeaderCommon(rtp_header);
343 EXPECT_EQ(length, rtp_header.headerLength);
344 EXPECT_FALSE(rtp_header.extension.hasTransmissionTimeOffset);
345 EXPECT_FALSE(rtp_header.extension.hasAbsoluteSendTime);
346 EXPECT_FALSE(rtp_header.extension.hasAudioLevel);
347 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
348 EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime);
349 EXPECT_FALSE(rtp_header.extension.voiceActivity);
350 EXPECT_EQ(0u, rtp_header.extension.audioLevel);
351 EXPECT_EQ(0u, rtp_header.extension.videoRotation);
352 }
353
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithTransmissionOffsetExtension)354 TEST_F(RtpSenderTestWithoutPacer,
355 BuildRTPPacketWithTransmissionOffsetExtension) {
356 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
357 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
358 kRtpExtensionTransmissionTimeOffset,
359 kTransmissionTimeOffsetExtensionId));
360
361 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
362 packet_, kPayload, kMarkerBit, kTimestamp, 0));
363 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
364 length);
365
366 // Verify
367 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
368 webrtc::RTPHeader rtp_header;
369
370 RtpHeaderExtensionMap map;
371 map.Register(kRtpExtensionTransmissionTimeOffset,
372 kTransmissionTimeOffsetExtensionId);
373 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
374
375 ASSERT_TRUE(valid_rtp_header);
376 ASSERT_FALSE(rtp_parser.RTCP());
377 VerifyRTPHeaderCommon(rtp_header);
378 EXPECT_EQ(length, rtp_header.headerLength);
379 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
380 EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
381
382 // Parse without map extension
383 webrtc::RTPHeader rtp_header2;
384 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
385
386 ASSERT_TRUE(valid_rtp_header2);
387 VerifyRTPHeaderCommon(rtp_header2);
388 EXPECT_EQ(length, rtp_header2.headerLength);
389 EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset);
390 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
391 }
392
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithNegativeTransmissionOffsetExtension)393 TEST_F(RtpSenderTestWithoutPacer,
394 BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
395 const int kNegTimeOffset = -500;
396 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
397 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
398 kRtpExtensionTransmissionTimeOffset,
399 kTransmissionTimeOffsetExtensionId));
400
401 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
402 packet_, kPayload, kMarkerBit, kTimestamp, 0));
403 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
404 length);
405
406 // Verify
407 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
408 webrtc::RTPHeader rtp_header;
409
410 RtpHeaderExtensionMap map;
411 map.Register(kRtpExtensionTransmissionTimeOffset,
412 kTransmissionTimeOffsetExtensionId);
413 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
414
415 ASSERT_TRUE(valid_rtp_header);
416 ASSERT_FALSE(rtp_parser.RTCP());
417 VerifyRTPHeaderCommon(rtp_header);
418 EXPECT_EQ(length, rtp_header.headerLength);
419 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
420 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
421 }
422
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithAbsoluteSendTimeExtension)423 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
424 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
425 EXPECT_EQ(
426 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
427 kAbsoluteSendTimeExtensionId));
428
429 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
430 packet_, kPayload, kMarkerBit, kTimestamp, 0));
431 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
432 length);
433
434 // Verify
435 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
436 webrtc::RTPHeader rtp_header;
437
438 RtpHeaderExtensionMap map;
439 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
440 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
441
442 ASSERT_TRUE(valid_rtp_header);
443 ASSERT_FALSE(rtp_parser.RTCP());
444 VerifyRTPHeaderCommon(rtp_header);
445 EXPECT_EQ(length, rtp_header.headerLength);
446 EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
447 EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
448
449 // Parse without map extension
450 webrtc::RTPHeader rtp_header2;
451 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
452
453 ASSERT_TRUE(valid_rtp_header2);
454 VerifyRTPHeaderCommon(rtp_header2);
455 EXPECT_EQ(length, rtp_header2.headerLength);
456 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime);
457 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
458 }
459
460 // Test CVO header extension is only set when marker bit is true.
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithVideoRotation_MarkerBit)461 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
462 rtp_sender_->SetVideoRotation(kRotation);
463 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
464 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
465 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
466
467 RtpHeaderExtensionMap map;
468 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
469
470 size_t length = static_cast<size_t>(
471 rtp_sender_->BuildRTPheader(packet_, kPayload, true, kTimestamp, 0));
472 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
473 length);
474
475 // Verify
476 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
477 webrtc::RTPHeader rtp_header;
478
479 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
480 ASSERT_FALSE(rtp_parser.RTCP());
481 VerifyRTPHeaderCommon(rtp_header);
482 EXPECT_EQ(length, rtp_header.headerLength);
483 EXPECT_TRUE(rtp_header.extension.hasVideoRotation);
484 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation),
485 rtp_header.extension.videoRotation);
486 }
487
488 // Test CVO header extension is not set when marker bit is false.
TEST_F(RtpSenderTestWithoutPacer,DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit)489 TEST_F(RtpSenderTestWithoutPacer,
490 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
491 rtp_sender_->SetVideoRotation(kRotation);
492 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
493 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
494 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
495
496 RtpHeaderExtensionMap map;
497 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
498
499 size_t length = static_cast<size_t>(
500 rtp_sender_->BuildRTPheader(packet_, kPayload, false, kTimestamp, 0));
501 ASSERT_EQ(kRtpHeaderSize, length);
502
503 // Verify
504 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
505 webrtc::RTPHeader rtp_header;
506
507 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
508 ASSERT_FALSE(rtp_parser.RTCP());
509 VerifyRTPHeaderCommon(rtp_header, false);
510 EXPECT_EQ(length, rtp_header.headerLength);
511 EXPECT_FALSE(rtp_header.extension.hasVideoRotation);
512 }
513
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithAudioLevelExtension)514 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
515 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
516 kAudioLevelExtensionId));
517
518 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
519 packet_, kPayload, kMarkerBit, kTimestamp, 0));
520 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
521 length);
522
523 // Verify
524 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
525 webrtc::RTPHeader rtp_header;
526
527 // Updating audio level is done in RTPSenderAudio, so simulate it here.
528 rtp_parser.Parse(&rtp_header);
529 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
530
531 RtpHeaderExtensionMap map;
532 map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
533 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
534
535 ASSERT_TRUE(valid_rtp_header);
536 ASSERT_FALSE(rtp_parser.RTCP());
537 VerifyRTPHeaderCommon(rtp_header);
538 EXPECT_EQ(length, rtp_header.headerLength);
539 EXPECT_TRUE(rtp_header.extension.hasAudioLevel);
540 EXPECT_TRUE(rtp_header.extension.voiceActivity);
541 EXPECT_EQ(kAudioLevel, rtp_header.extension.audioLevel);
542
543 // Parse without map extension
544 webrtc::RTPHeader rtp_header2;
545 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
546
547 ASSERT_TRUE(valid_rtp_header2);
548 VerifyRTPHeaderCommon(rtp_header2);
549 EXPECT_EQ(length, rtp_header2.headerLength);
550 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel);
551 EXPECT_FALSE(rtp_header2.extension.voiceActivity);
552 EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
553 }
554
TEST_F(RtpSenderTestWithoutPacer,BuildRTPPacketWithHeaderExtensions)555 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
556 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
557 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
558 EXPECT_EQ(0,
559 rtp_sender_->SetTransportSequenceNumber(kTransportSequenceNumber));
560 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
561 kRtpExtensionTransmissionTimeOffset,
562 kTransmissionTimeOffsetExtensionId));
563 EXPECT_EQ(
564 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
565 kAbsoluteSendTimeExtensionId));
566 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
567 kAudioLevelExtensionId));
568 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
569 kRtpExtensionTransportSequenceNumber,
570 kTransportSequenceNumberExtensionId));
571
572 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
573 packet_, kPayload, kMarkerBit, kTimestamp, 0));
574 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
575 length);
576
577 // Verify
578 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
579 webrtc::RTPHeader rtp_header;
580
581 // Updating audio level is done in RTPSenderAudio, so simulate it here.
582 rtp_parser.Parse(&rtp_header);
583 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
584
585 RtpHeaderExtensionMap map;
586 map.Register(kRtpExtensionTransmissionTimeOffset,
587 kTransmissionTimeOffsetExtensionId);
588 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
589 map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
590 map.Register(kRtpExtensionTransportSequenceNumber,
591 kTransportSequenceNumberExtensionId);
592 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
593
594 ASSERT_TRUE(valid_rtp_header);
595 ASSERT_FALSE(rtp_parser.RTCP());
596 VerifyRTPHeaderCommon(rtp_header);
597 EXPECT_EQ(length, rtp_header.headerLength);
598 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
599 EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
600 EXPECT_TRUE(rtp_header.extension.hasAudioLevel);
601 EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
602 EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
603 EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
604 EXPECT_TRUE(rtp_header.extension.voiceActivity);
605 EXPECT_EQ(kAudioLevel, rtp_header.extension.audioLevel);
606 EXPECT_EQ(kTransportSequenceNumber,
607 rtp_header.extension.transportSequenceNumber);
608
609 // Parse without map extension
610 webrtc::RTPHeader rtp_header2;
611 const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
612
613 ASSERT_TRUE(valid_rtp_header2);
614 VerifyRTPHeaderCommon(rtp_header2);
615 EXPECT_EQ(length, rtp_header2.headerLength);
616 EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset);
617 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime);
618 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel);
619 EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber);
620
621 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
622 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
623 EXPECT_FALSE(rtp_header2.extension.voiceActivity);
624 EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
625 EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber);
626 }
627
TEST_F(RtpSenderTest,TrafficSmoothingWithExtensions)628 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
629 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
630 _, kSeqNum, _, _, _))
631 .WillRepeatedly(testing::Return());
632
633 rtp_sender_->SetStorePacketsStatus(true, 10);
634 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
635 kRtpExtensionTransmissionTimeOffset,
636 kTransmissionTimeOffsetExtensionId));
637 EXPECT_EQ(
638 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
639 kAbsoluteSendTimeExtensionId));
640 rtp_sender_->SetTargetBitrate(300000);
641 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
642 int rtp_length_int = rtp_sender_->BuildRTPheader(
643 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
644 ASSERT_NE(-1, rtp_length_int);
645 size_t rtp_length = static_cast<size_t>(rtp_length_int);
646
647 // Packet should be stored in a send bucket.
648 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
649 capture_time_ms, kAllowRetransmission,
650 RtpPacketSender::kNormalPriority));
651
652 EXPECT_EQ(0, transport_.packets_sent_);
653
654 const int kStoredTimeInMs = 100;
655 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
656
657 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
658
659 // Process send bucket. Packet should now be sent.
660 EXPECT_EQ(1, transport_.packets_sent_);
661 EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
662 // Parse sent packet.
663 webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
664 rtp_length);
665 webrtc::RTPHeader rtp_header;
666 RtpHeaderExtensionMap map;
667 map.Register(kRtpExtensionTransmissionTimeOffset,
668 kTransmissionTimeOffsetExtensionId);
669 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
670 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
671 ASSERT_TRUE(valid_rtp_header);
672
673 // Verify transmission time offset.
674 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
675 uint64_t expected_send_time =
676 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
677 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
678 }
679
TEST_F(RtpSenderTest,TrafficSmoothingRetransmits)680 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
681 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
682 _, kSeqNum, _, _, _))
683 .WillRepeatedly(testing::Return());
684
685 rtp_sender_->SetStorePacketsStatus(true, 10);
686 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
687 kRtpExtensionTransmissionTimeOffset,
688 kTransmissionTimeOffsetExtensionId));
689 EXPECT_EQ(
690 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
691 kAbsoluteSendTimeExtensionId));
692 rtp_sender_->SetTargetBitrate(300000);
693 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
694 int rtp_length_int = rtp_sender_->BuildRTPheader(
695 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
696 ASSERT_NE(-1, rtp_length_int);
697 size_t rtp_length = static_cast<size_t>(rtp_length_int);
698
699 // Packet should be stored in a send bucket.
700 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
701 capture_time_ms, kAllowRetransmission,
702 RtpPacketSender::kNormalPriority));
703
704 EXPECT_EQ(0, transport_.packets_sent_);
705
706 EXPECT_CALL(mock_paced_sender_,
707 InsertPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
708 .WillRepeatedly(testing::Return());
709
710 const int kStoredTimeInMs = 100;
711 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
712
713 EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));
714 EXPECT_EQ(0, transport_.packets_sent_);
715
716 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
717
718 // Process send bucket. Packet should now be sent.
719 EXPECT_EQ(1, transport_.packets_sent_);
720 EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
721
722 // Parse sent packet.
723 webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
724 rtp_length);
725 webrtc::RTPHeader rtp_header;
726 RtpHeaderExtensionMap map;
727 map.Register(kRtpExtensionTransmissionTimeOffset,
728 kTransmissionTimeOffsetExtensionId);
729 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
730 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
731 ASSERT_TRUE(valid_rtp_header);
732
733 // Verify transmission time offset.
734 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
735 uint64_t expected_send_time =
736 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
737 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
738 }
739
740 // This test sends 1 regular video packet, then 4 padding packets, and then
741 // 1 more regular packet.
TEST_F(RtpSenderTest,SendPadding)742 TEST_F(RtpSenderTest, SendPadding) {
743 // Make all (non-padding) packets go to send queue.
744 EXPECT_CALL(mock_paced_sender_,
745 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
746 .WillRepeatedly(testing::Return());
747
748 uint16_t seq_num = kSeqNum;
749 uint32_t timestamp = kTimestamp;
750 rtp_sender_->SetStorePacketsStatus(true, 10);
751 size_t rtp_header_len = kRtpHeaderSize;
752 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
753 kRtpExtensionTransmissionTimeOffset,
754 kTransmissionTimeOffsetExtensionId));
755 rtp_header_len += 4; // 4 bytes extension.
756 EXPECT_EQ(
757 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
758 kAbsoluteSendTimeExtensionId));
759 rtp_header_len += 4; // 4 bytes extension.
760 rtp_header_len += 4; // 4 extra bytes common to all extension headers.
761
762 // Create and set up parser.
763 rtc::scoped_ptr<webrtc::RtpHeaderParser> rtp_parser(
764 webrtc::RtpHeaderParser::Create());
765 ASSERT_TRUE(rtp_parser.get() != nullptr);
766 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
767 kTransmissionTimeOffsetExtensionId);
768 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
769 kAbsoluteSendTimeExtensionId);
770 webrtc::RTPHeader rtp_header;
771
772 rtp_sender_->SetTargetBitrate(300000);
773 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
774 int rtp_length_int = rtp_sender_->BuildRTPheader(
775 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
776 const uint32_t media_packet_timestamp = timestamp;
777 ASSERT_NE(-1, rtp_length_int);
778 size_t rtp_length = static_cast<size_t>(rtp_length_int);
779
780 // Packet should be stored in a send bucket.
781 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
782 capture_time_ms, kAllowRetransmission,
783 RtpPacketSender::kNormalPriority));
784
785 int total_packets_sent = 0;
786 EXPECT_EQ(total_packets_sent, transport_.packets_sent_);
787
788 const int kStoredTimeInMs = 100;
789 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
790 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
791 // Packet should now be sent. This test doesn't verify the regular video
792 // packet, since it is tested in another test.
793 EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
794 timestamp += 90 * kStoredTimeInMs;
795
796 // Send padding 4 times, waiting 50 ms between each.
797 for (int i = 0; i < 4; ++i) {
798 const int kPaddingPeriodMs = 50;
799 const size_t kPaddingBytes = 100;
800 const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc.
801 // Padding will be forced to full packets.
802 EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(kPaddingBytes));
803
804 // Process send bucket. Padding should now be sent.
805 EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
806 EXPECT_EQ(kMaxPaddingLength + rtp_header_len,
807 transport_.last_sent_packet_len_);
808 // Parse sent packet.
809 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
810 transport_.last_sent_packet_len_,
811 &rtp_header));
812 EXPECT_EQ(kMaxPaddingLength, rtp_header.paddingLength);
813
814 // Verify sequence number and timestamp. The timestamp should be the same
815 // as the last media packet.
816 EXPECT_EQ(seq_num++, rtp_header.sequenceNumber);
817 EXPECT_EQ(media_packet_timestamp, rtp_header.timestamp);
818 // Verify transmission time offset.
819 int offset = timestamp - media_packet_timestamp;
820 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset);
821 uint64_t expected_send_time =
822 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
823 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
824 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
825 timestamp += 90 * kPaddingPeriodMs;
826 }
827
828 // Send a regular video packet again.
829 capture_time_ms = fake_clock_.TimeInMilliseconds();
830 rtp_length_int = rtp_sender_->BuildRTPheader(packet_, kPayload, kMarkerBit,
831 timestamp, capture_time_ms);
832 ASSERT_NE(-1, rtp_length_int);
833 rtp_length = static_cast<size_t>(rtp_length_int);
834
835 // Packet should be stored in a send bucket.
836 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
837 capture_time_ms, kAllowRetransmission,
838 RtpPacketSender::kNormalPriority));
839
840 rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false);
841 // Process send bucket.
842 EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
843 EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
844 // Parse sent packet.
845 ASSERT_TRUE(
846 rtp_parser->Parse(transport_.last_sent_packet_, rtp_length, &rtp_header));
847
848 // Verify sequence number and timestamp.
849 EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
850 EXPECT_EQ(timestamp, rtp_header.timestamp);
851 // Verify transmission time offset. This packet is sent without delay.
852 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
853 uint64_t expected_send_time =
854 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
855 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
856 }
857
TEST_F(RtpSenderTest,SendRedundantPayloads)858 TEST_F(RtpSenderTest, SendRedundantPayloads) {
859 MockTransport transport;
860 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport, nullptr,
861 &mock_paced_sender_, nullptr, nullptr,
862 nullptr, nullptr, nullptr));
863 rtp_sender_->SetSequenceNumber(kSeqNum);
864 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
865 // Make all packets go through the pacer.
866 EXPECT_CALL(mock_paced_sender_,
867 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
868 .WillRepeatedly(testing::Return());
869
870 uint16_t seq_num = kSeqNum;
871 rtp_sender_->SetStorePacketsStatus(true, 10);
872 int32_t rtp_header_len = kRtpHeaderSize;
873 EXPECT_EQ(
874 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
875 kAbsoluteSendTimeExtensionId));
876 rtp_header_len += 4; // 4 bytes extension.
877 rtp_header_len += 4; // 4 extra bytes common to all extension headers.
878
879 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
880 rtp_sender_->SetRtxSsrc(1234);
881
882 // Create and set up parser.
883 rtc::scoped_ptr<webrtc::RtpHeaderParser> rtp_parser(
884 webrtc::RtpHeaderParser::Create());
885 ASSERT_TRUE(rtp_parser.get() != nullptr);
886 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
887 kTransmissionTimeOffsetExtensionId);
888 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
889 kAbsoluteSendTimeExtensionId);
890 rtp_sender_->SetTargetBitrate(300000);
891 const size_t kNumPayloadSizes = 10;
892 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
893 750, 800, 850, 900, 950};
894 // Send 10 packets of increasing size.
895 for (size_t i = 0; i < kNumPayloadSizes; ++i) {
896 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
897 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true));
898 SendPacket(capture_time_ms, kPayloadSizes[i]);
899 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
900 fake_clock_.AdvanceTimeMilliseconds(33);
901 }
902 // The amount of padding to send it too small to send a payload packet.
903 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
904 .WillOnce(testing::Return(true));
905 EXPECT_EQ(kMaxPaddingSize, rtp_sender_->TimeToSendPadding(49));
906
907 EXPECT_CALL(transport,
908 SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
909 .WillOnce(testing::Return(true));
910 EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
911
912 EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
913 rtp_header_len + kRtxHeaderSize,
914 _))
915 .WillOnce(testing::Return(true));
916 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
917 .WillOnce(testing::Return(true));
918 EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
919 rtp_sender_->TimeToSendPadding(999));
920 }
921
TEST_F(RtpSenderTestWithoutPacer,SendGenericVideo)922 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
923 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
924 const uint8_t payload_type = 127;
925 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
926 0, 1500));
927 uint8_t payload[] = {47, 11, 32, 93, 89};
928
929 // Send keyframe
930 ASSERT_EQ(
931 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321,
932 payload, sizeof(payload), nullptr));
933
934 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
935 transport_.last_sent_packet_len_);
936 webrtc::RTPHeader rtp_header;
937 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
938
939 const uint8_t* payload_data =
940 GetPayloadData(rtp_header, transport_.last_sent_packet_);
941 uint8_t generic_header = *payload_data++;
942
943 ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
944 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
945
946 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
947 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
948
949 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
950
951 // Send delta frame
952 payload[0] = 13;
953 payload[1] = 42;
954 payload[4] = 13;
955
956 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type,
957 1234, 4321, payload,
958 sizeof(payload), nullptr));
959
960 RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
961 transport_.last_sent_packet_len_);
962 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
963
964 payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
965 generic_header = *payload_data++;
966
967 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
968 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
969
970 ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
971 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
972
973 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
974 }
975
TEST_F(RtpSenderTest,FrameCountCallbacks)976 TEST_F(RtpSenderTest, FrameCountCallbacks) {
977 class TestCallback : public FrameCountObserver {
978 public:
979 TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
980 virtual ~TestCallback() {}
981
982 void FrameCountUpdated(const FrameCounts& frame_counts,
983 uint32_t ssrc) override {
984 ++num_calls_;
985 ssrc_ = ssrc;
986 frame_counts_ = frame_counts;
987 }
988
989 uint32_t num_calls_;
990 uint32_t ssrc_;
991 FrameCounts frame_counts_;
992 } callback;
993
994 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
995 &mock_paced_sender_, nullptr, nullptr,
996 nullptr, &callback, nullptr));
997
998 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
999 const uint8_t payload_type = 127;
1000 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1001 0, 1500));
1002 uint8_t payload[] = {47, 11, 32, 93, 89};
1003 rtp_sender_->SetStorePacketsStatus(true, 1);
1004 uint32_t ssrc = rtp_sender_->SSRC();
1005
1006 ASSERT_EQ(
1007 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321,
1008 payload, sizeof(payload), nullptr));
1009
1010 EXPECT_EQ(1U, callback.num_calls_);
1011 EXPECT_EQ(ssrc, callback.ssrc_);
1012 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1013 EXPECT_EQ(0, callback.frame_counts_.delta_frames);
1014
1015 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type,
1016 1234, 4321, payload,
1017 sizeof(payload), nullptr));
1018
1019 EXPECT_EQ(2U, callback.num_calls_);
1020 EXPECT_EQ(ssrc, callback.ssrc_);
1021 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1022 EXPECT_EQ(1, callback.frame_counts_.delta_frames);
1023
1024 rtp_sender_.reset();
1025 }
1026
TEST_F(RtpSenderTest,BitrateCallbacks)1027 TEST_F(RtpSenderTest, BitrateCallbacks) {
1028 class TestCallback : public BitrateStatisticsObserver {
1029 public:
1030 TestCallback() : BitrateStatisticsObserver(), num_calls_(0), ssrc_(0) {}
1031 virtual ~TestCallback() {}
1032
1033 void Notify(const BitrateStatistics& total_stats,
1034 const BitrateStatistics& retransmit_stats,
1035 uint32_t ssrc) override {
1036 ++num_calls_;
1037 ssrc_ = ssrc;
1038 total_stats_ = total_stats;
1039 retransmit_stats_ = retransmit_stats;
1040 }
1041
1042 uint32_t num_calls_;
1043 uint32_t ssrc_;
1044 BitrateStatistics total_stats_;
1045 BitrateStatistics retransmit_stats_;
1046 } callback;
1047 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
1048 nullptr, nullptr, nullptr, &callback, nullptr,
1049 nullptr));
1050
1051 // Simulate kNumPackets sent with kPacketInterval ms intervals.
1052 const uint32_t kNumPackets = 15;
1053 const uint32_t kPacketInterval = 20;
1054 // Overhead = 12 bytes RTP header + 1 byte generic header.
1055 const uint32_t kPacketOverhead = 13;
1056
1057 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1058 const uint8_t payload_type = 127;
1059 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1060 0, 1500));
1061 uint8_t payload[] = {47, 11, 32, 93, 89};
1062 rtp_sender_->SetStorePacketsStatus(true, 1);
1063 uint32_t ssrc = rtp_sender_->SSRC();
1064
1065 // Initial process call so we get a new time window.
1066 rtp_sender_->ProcessBitrate();
1067 uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds();
1068
1069 // Send a few frames.
1070 for (uint32_t i = 0; i < kNumPackets; ++i) {
1071 ASSERT_EQ(0,
1072 rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
1073 4321, payload, sizeof(payload), 0));
1074 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
1075 }
1076
1077 rtp_sender_->ProcessBitrate();
1078
1079 const uint32_t expected_packet_rate = 1000 / kPacketInterval;
1080
1081 // We get one call for every stats updated, thus two calls since both the
1082 // stream stats and the retransmit stats are updated once.
1083 EXPECT_EQ(2u, callback.num_calls_);
1084 EXPECT_EQ(ssrc, callback.ssrc_);
1085 EXPECT_EQ(start_time + (kNumPackets * kPacketInterval),
1086 callback.total_stats_.timestamp_ms);
1087 EXPECT_EQ(expected_packet_rate, callback.total_stats_.packet_rate);
1088 EXPECT_EQ((kPacketOverhead + sizeof(payload)) * 8 * expected_packet_rate,
1089 callback.total_stats_.bitrate_bps);
1090
1091 rtp_sender_.reset();
1092 }
1093
1094 class RtpSenderAudioTest : public RtpSenderTest {
1095 protected:
RtpSenderAudioTest()1096 RtpSenderAudioTest() {}
1097
SetUp()1098 void SetUp() override {
1099 payload_ = kAudioPayload;
1100 rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr,
1101 nullptr, nullptr, nullptr, nullptr, nullptr,
1102 nullptr));
1103 rtp_sender_->SetSequenceNumber(kSeqNum);
1104 }
1105 };
1106
TEST_F(RtpSenderTestWithoutPacer,StreamDataCountersCallbacks)1107 TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
1108 class TestCallback : public StreamDataCountersCallback {
1109 public:
1110 TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {}
1111 virtual ~TestCallback() {}
1112
1113 void DataCountersUpdated(const StreamDataCounters& counters,
1114 uint32_t ssrc) override {
1115 ssrc_ = ssrc;
1116 counters_ = counters;
1117 }
1118
1119 uint32_t ssrc_;
1120 StreamDataCounters counters_;
1121
1122 void MatchPacketCounter(const RtpPacketCounter& expected,
1123 const RtpPacketCounter& actual) {
1124 EXPECT_EQ(expected.payload_bytes, actual.payload_bytes);
1125 EXPECT_EQ(expected.header_bytes, actual.header_bytes);
1126 EXPECT_EQ(expected.padding_bytes, actual.padding_bytes);
1127 EXPECT_EQ(expected.packets, actual.packets);
1128 }
1129
1130 void Matches(uint32_t ssrc, const StreamDataCounters& counters) {
1131 EXPECT_EQ(ssrc, ssrc_);
1132 MatchPacketCounter(counters.transmitted, counters_.transmitted);
1133 MatchPacketCounter(counters.retransmitted, counters_.retransmitted);
1134 EXPECT_EQ(counters.fec.packets, counters_.fec.packets);
1135 }
1136 } callback;
1137
1138 const uint8_t kRedPayloadType = 96;
1139 const uint8_t kUlpfecPayloadType = 97;
1140 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1141 const uint8_t payload_type = 127;
1142 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1143 0, 1500));
1144 uint8_t payload[] = {47, 11, 32, 93, 89};
1145 rtp_sender_->SetStorePacketsStatus(true, 1);
1146 uint32_t ssrc = rtp_sender_->SSRC();
1147
1148 rtp_sender_->RegisterRtpStatisticsCallback(&callback);
1149
1150 // Send a frame.
1151 ASSERT_EQ(
1152 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321,
1153 payload, sizeof(payload), nullptr));
1154 StreamDataCounters expected;
1155 expected.transmitted.payload_bytes = 6;
1156 expected.transmitted.header_bytes = 12;
1157 expected.transmitted.padding_bytes = 0;
1158 expected.transmitted.packets = 1;
1159 expected.retransmitted.payload_bytes = 0;
1160 expected.retransmitted.header_bytes = 0;
1161 expected.retransmitted.padding_bytes = 0;
1162 expected.retransmitted.packets = 0;
1163 expected.fec.packets = 0;
1164 callback.Matches(ssrc, expected);
1165
1166 // Retransmit a frame.
1167 uint16_t seqno = rtp_sender_->SequenceNumber() - 1;
1168 rtp_sender_->ReSendPacket(seqno, 0);
1169 expected.transmitted.payload_bytes = 12;
1170 expected.transmitted.header_bytes = 24;
1171 expected.transmitted.packets = 2;
1172 expected.retransmitted.payload_bytes = 6;
1173 expected.retransmitted.header_bytes = 12;
1174 expected.retransmitted.padding_bytes = 0;
1175 expected.retransmitted.packets = 1;
1176 callback.Matches(ssrc, expected);
1177
1178 // Send padding.
1179 rtp_sender_->TimeToSendPadding(kMaxPaddingSize);
1180 expected.transmitted.payload_bytes = 12;
1181 expected.transmitted.header_bytes = 36;
1182 expected.transmitted.padding_bytes = kMaxPaddingSize;
1183 expected.transmitted.packets = 3;
1184 callback.Matches(ssrc, expected);
1185
1186 // Send FEC.
1187 rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType);
1188 FecProtectionParams fec_params;
1189 fec_params.fec_mask_type = kFecMaskRandom;
1190 fec_params.fec_rate = 1;
1191 fec_params.max_fec_frames = 1;
1192 fec_params.use_uep_protection = false;
1193 rtp_sender_->SetFecParameters(&fec_params, &fec_params);
1194 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type,
1195 1234, 4321, payload,
1196 sizeof(payload), nullptr));
1197 expected.transmitted.payload_bytes = 40;
1198 expected.transmitted.header_bytes = 60;
1199 expected.transmitted.packets = 5;
1200 expected.fec.packets = 1;
1201 callback.Matches(ssrc, expected);
1202
1203 rtp_sender_->RegisterRtpStatisticsCallback(nullptr);
1204 }
1205
TEST_F(RtpSenderAudioTest,SendAudio)1206 TEST_F(RtpSenderAudioTest, SendAudio) {
1207 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1208 const uint8_t payload_type = 127;
1209 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1210 0, 1500));
1211 uint8_t payload[] = {47, 11, 32, 93, 89};
1212
1213 ASSERT_EQ(
1214 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321,
1215 payload, sizeof(payload), nullptr));
1216
1217 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
1218 transport_.last_sent_packet_len_);
1219 webrtc::RTPHeader rtp_header;
1220 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1221
1222 const uint8_t* payload_data =
1223 GetPayloadData(rtp_header, transport_.last_sent_packet_);
1224
1225 ASSERT_EQ(sizeof(payload),
1226 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
1227
1228 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
1229 }
1230
TEST_F(RtpSenderAudioTest,SendAudioWithAudioLevelExtension)1231 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
1232 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
1233 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
1234 kAudioLevelExtensionId));
1235
1236 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1237 const uint8_t payload_type = 127;
1238 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1239 0, 1500));
1240 uint8_t payload[] = {47, 11, 32, 93, 89};
1241
1242 ASSERT_EQ(
1243 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321,
1244 payload, sizeof(payload), nullptr));
1245
1246 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
1247 transport_.last_sent_packet_len_);
1248 webrtc::RTPHeader rtp_header;
1249 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1250
1251 const uint8_t* payload_data =
1252 GetPayloadData(rtp_header, transport_.last_sent_packet_);
1253
1254 ASSERT_EQ(sizeof(payload),
1255 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
1256
1257 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
1258
1259 uint8_t extension[] = {
1260 0xbe, 0xde, 0x00, 0x01,
1261 (kAudioLevelExtensionId << 4) + 0, // ID + length.
1262 kAudioLevel, // Data.
1263 0x00, 0x00 // Padding.
1264 };
1265
1266 EXPECT_EQ(0, memcmp(extension, payload_data - sizeof(extension),
1267 sizeof(extension)));
1268 }
1269
1270 // As RFC4733, named telephone events are carried as part of the audio stream
1271 // and must use the same sequence number and timestamp base as the regular
1272 // audio channel.
1273 // This test checks the marker bit for the first packet and the consequent
1274 // packets of the same telephone event. Since it is specifically for DTMF
1275 // events, ignoring audio packets and sending kEmptyFrame instead of those.
TEST_F(RtpSenderAudioTest,CheckMarkerBitForTelephoneEvents)1276 TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
1277 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "telephone-event";
1278 uint8_t payload_type = 126;
1279 ASSERT_EQ(0,
1280 rtp_sender_->RegisterPayload(payload_name, payload_type, 0, 0, 0));
1281 // For Telephone events, payload is not added to the registered payload list,
1282 // it will register only the payload used for audio stream.
1283 // Registering the payload again for audio stream with different payload name.
1284 const char kPayloadName[] = "payload_name";
1285 ASSERT_EQ(
1286 0, rtp_sender_->RegisterPayload(kPayloadName, payload_type, 8000, 1, 0));
1287 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
1288 // DTMF event key=9, duration=500 and attenuationdB=10
1289 rtp_sender_->SendTelephoneEvent(9, 500, 10);
1290 // During start, it takes the starting timestamp as last sent timestamp.
1291 // The duration is calculated as the difference of current and last sent
1292 // timestamp. So for first call it will skip since the duration is zero.
1293 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1294 capture_time_ms, 0, nullptr, 0,
1295 nullptr));
1296 // DTMF Sample Length is (Frequency/1000) * Duration.
1297 // So in this case, it is (8000/1000) * 500 = 4000.
1298 // Sending it as two packets.
1299 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1300 capture_time_ms + 2000, 0, nullptr,
1301 0, nullptr));
1302 rtc::scoped_ptr<webrtc::RtpHeaderParser> rtp_parser(
1303 webrtc::RtpHeaderParser::Create());
1304 ASSERT_TRUE(rtp_parser.get() != nullptr);
1305 webrtc::RTPHeader rtp_header;
1306 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
1307 transport_.last_sent_packet_len_, &rtp_header));
1308 // Marker Bit should be set to 1 for first packet.
1309 EXPECT_TRUE(rtp_header.markerBit);
1310
1311 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1312 capture_time_ms + 4000, 0, nullptr,
1313 0, nullptr));
1314 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
1315 transport_.last_sent_packet_len_, &rtp_header));
1316 // Marker Bit should be set to 0 for rest of the packets.
1317 EXPECT_FALSE(rtp_header.markerBit);
1318 }
1319
TEST_F(RtpSenderTestWithoutPacer,BytesReportedCorrectly)1320 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
1321 const char* kPayloadName = "GENERIC";
1322 const uint8_t kPayloadType = 127;
1323 rtp_sender_->SetSSRC(1234);
1324 rtp_sender_->SetRtxSsrc(4321);
1325 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
1326 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
1327
1328 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000,
1329 0, 1500));
1330 uint8_t payload[] = {47, 11, 32, 93, 89};
1331
1332 ASSERT_EQ(
1333 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, kPayloadType, 1234, 4321,
1334 payload, sizeof(payload), 0));
1335
1336 // Will send 2 full-size padding packets.
1337 rtp_sender_->TimeToSendPadding(1);
1338 rtp_sender_->TimeToSendPadding(1);
1339
1340 StreamDataCounters rtp_stats;
1341 StreamDataCounters rtx_stats;
1342 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
1343
1344 // Payload + 1-byte generic header.
1345 EXPECT_GT(rtp_stats.first_packet_time_ms, -1);
1346 EXPECT_EQ(rtp_stats.transmitted.payload_bytes, sizeof(payload) + 1);
1347 EXPECT_EQ(rtp_stats.transmitted.header_bytes, 12u);
1348 EXPECT_EQ(rtp_stats.transmitted.padding_bytes, 0u);
1349 EXPECT_EQ(rtx_stats.transmitted.payload_bytes, 0u);
1350 EXPECT_EQ(rtx_stats.transmitted.header_bytes, 24u);
1351 EXPECT_EQ(rtx_stats.transmitted.padding_bytes, 2 * kMaxPaddingSize);
1352
1353 EXPECT_EQ(rtp_stats.transmitted.TotalBytes(),
1354 rtp_stats.transmitted.payload_bytes +
1355 rtp_stats.transmitted.header_bytes +
1356 rtp_stats.transmitted.padding_bytes);
1357 EXPECT_EQ(rtx_stats.transmitted.TotalBytes(),
1358 rtx_stats.transmitted.payload_bytes +
1359 rtx_stats.transmitted.header_bytes +
1360 rtx_stats.transmitted.padding_bytes);
1361
1362 EXPECT_EQ(
1363 transport_.total_bytes_sent_,
1364 rtp_stats.transmitted.TotalBytes() + rtx_stats.transmitted.TotalBytes());
1365 }
1366
TEST_F(RtpSenderTestWithoutPacer,RespectsNackBitrateLimit)1367 TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
1368 const int32_t kPacketSize = 1400;
1369 const int32_t kNumPackets = 30;
1370
1371 rtp_sender_->SetStorePacketsStatus(true, kNumPackets);
1372 // Set bitrate (in kbps) to fit kNumPackets á kPacketSize bytes in one second.
1373 rtp_sender_->SetTargetBitrate(kNumPackets * kPacketSize * 8);
1374 const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber();
1375 std::list<uint16_t> sequence_numbers;
1376 for (int32_t i = 0; i < kNumPackets; ++i) {
1377 sequence_numbers.push_back(kStartSequenceNumber + i);
1378 fake_clock_.AdvanceTimeMilliseconds(1);
1379 SendPacket(fake_clock_.TimeInMilliseconds(), kPacketSize);
1380 }
1381 EXPECT_EQ(kNumPackets, transport_.packets_sent_);
1382
1383 fake_clock_.AdvanceTimeMilliseconds(1000 - kNumPackets);
1384
1385 // Resending should work - brings the bandwidth up to the limit.
1386 // NACK bitrate is capped to the same bitrate as the encoder, since the max
1387 // protection overhead is 50% (see MediaOptimization::SetTargetRates).
1388 rtp_sender_->OnReceivedNACK(sequence_numbers, 0);
1389 EXPECT_EQ(kNumPackets * 2, transport_.packets_sent_);
1390
1391 // Resending should not work, bandwidth exceeded.
1392 rtp_sender_->OnReceivedNACK(sequence_numbers, 0);
1393 EXPECT_EQ(kNumPackets * 2, transport_.packets_sent_);
1394 }
1395
1396 // Verify that all packets of a frame have CVO byte set.
TEST_F(RtpSenderVideoTest,SendVideoWithCVO)1397 TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {
1398 RTPVideoHeader hdr = {0};
1399 hdr.rotation = kVideoRotation_90;
1400
1401 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
1402 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
1403 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
1404
1405 EXPECT_EQ(
1406 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
1407 rtp_sender_->RtpHeaderExtensionTotalLength());
1408
1409 rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
1410 kTimestamp, 0, packet_, sizeof(packet_), nullptr,
1411 &hdr);
1412
1413 RtpHeaderExtensionMap map;
1414 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
1415
1416 // Verify that this packet does have CVO byte.
1417 VerifyCVOPacket(
1418 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
1419 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
1420
1421 // Verify that this packet does have CVO byte.
1422 VerifyCVOPacket(
1423 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
1424 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
1425 hdr.rotation);
1426 }
1427 } // namespace webrtc
1428