rtp_sender_unittest.cc revision 61c2a6f241ac9db626aeab755e49897030b289e1 
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
32namespace webrtc {
33
34namespace {
35const int kTransmissionTimeOffsetExtensionId = 1;
36const int kAbsoluteSendTimeExtensionId = 14;
37const int kTransportSequenceNumberExtensionId = 13;
38const int kPayload = 100;
39const uint32_t kTimestamp = 10;
40const uint16_t kSeqNum = 33;
41const int kTimeOffset = 22222;
42const int kMaxPacketLength = 1500;
43const uint32_t kAbsoluteSendTime = 0x00aabbcc;
44const uint8_t kAudioLevel = 0x5a;
45const uint16_t kTransportSequenceNumber = 0xaabbu;
46const uint8_t kAudioLevelExtensionId = 9;
47const int kAudioPayload = 103;
48const uint64_t kStartTime = 123456789;
49const size_t kMaxPaddingSize = 224u;
50const int kVideoRotationExtensionId = 5;
51const VideoRotation kRotation = kVideoRotation_270;
52
53using testing::_;
54
55const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
56                              const uint8_t* packet) {
57  return packet + rtp_header.headerLength;
58}
59
60size_t GetPayloadDataLength(const RTPHeader& rtp_header,
61                            const size_t packet_length) {
62  return packet_length - rtp_header.headerLength - rtp_header.paddingLength;
63}
64
65uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
66  return 0x00fffffful & ((time_ms << 18) / 1000);
67}
68
69class LoopbackTransportTest : public webrtc::Transport {
70 public:
71  LoopbackTransportTest()
72      : packets_sent_(0),
73        last_sent_packet_len_(0),
74        total_bytes_sent_(0),
75        last_sent_packet_(NULL) {}
76
77  ~LoopbackTransportTest() {
78    STLDeleteContainerPointers(sent_packets_.begin(), sent_packets_.end());
79  }
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  }
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
101class RtpSenderTest : public ::testing::Test {
102 protected:
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
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
128  void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
129    VerifyRTPHeaderCommon(rtp_header, kMarkerBit);
130  }
131
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
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
161class RtpSenderVideoTest : public RtpSenderTest {
162 protected:
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
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
200TEST_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
211TEST_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
223TEST_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
235TEST_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
285TEST_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
300TEST_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
324TEST_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
361TEST_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
389TEST_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.
426TEST_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.
454TEST_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
478TEST_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
519TEST_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
588TEST_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
641TEST_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.
704TEST_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
819TEST_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
881TEST_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
935TEST_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
985TEST_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
1057class RtpSenderAudioTest : public RtpSenderTest {
1058 protected:
1059  RtpSenderAudioTest() {}
1060
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
1069TEST_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
1170TEST_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
1195TEST_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.
1239TEST_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
1288TEST_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.
1342TEST_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                               &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]->size(), 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