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