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