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