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