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