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