rtp_sender_unittest.cc revision 71f055fb41336316324942f828e022e2f7d93ec7 
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;
41}  // namespace
42
43using testing::_;
44
45const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
46                              const uint8_t* packet) {
47  return packet + rtp_header.headerLength;
48}
49
50uint16_t GetPayloadDataLength(const RTPHeader& rtp_header,
51                              const uint16_t packet_length) {
52  uint16_t length = packet_length - rtp_header.headerLength -
53      rtp_header.paddingLength;
54  return static_cast<uint16_t>(length);
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),
65      last_sent_packet_len_(0) {
66  }
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    return len;
72  }
73  virtual int SendRTCPPacket(int channel, const void *data, int len) {
74    return -1;
75  }
76  int packets_sent_;
77  int last_sent_packet_len_;
78  uint8_t last_sent_packet_[kMaxPacketLength];
79};
80
81class RtpSenderTest : public ::testing::Test {
82 protected:
83  RtpSenderTest()
84    : fake_clock_(123456789),
85      mock_paced_sender_(),
86      rtp_sender_(),
87      payload_(kPayload),
88      transport_(),
89      kMarkerBit(true) {
90    EXPECT_CALL(mock_paced_sender_,
91        SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true));
92  }
93
94  virtual void SetUp() {
95    rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
96                                    &mock_paced_sender_));
97    rtp_sender_->SetSequenceNumber(kSeqNum);
98  }
99
100  SimulatedClock fake_clock_;
101  MockPacedSender mock_paced_sender_;
102  scoped_ptr<RTPSender> rtp_sender_;
103  int payload_;
104  LoopbackTransportTest transport_;
105  const bool kMarkerBit;
106  uint8_t packet_[kMaxPacketLength];
107
108  void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
109    EXPECT_EQ(kMarkerBit, rtp_header.markerBit);
110    EXPECT_EQ(payload_, rtp_header.payloadType);
111    EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
112    EXPECT_EQ(kTimestamp, rtp_header.timestamp);
113    EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
114    EXPECT_EQ(0, rtp_header.numCSRCs);
115    EXPECT_EQ(0, rtp_header.paddingLength);
116  }
117
118  void SendPacket(int64_t capture_time_ms, int payload_length) {
119    uint32_t timestamp = capture_time_ms * 90;
120    int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
121                                                     kPayload,
122                                                     kMarkerBit,
123                                                     timestamp,
124                                                     capture_time_ms);
125
126    // Packet should be stored in a send bucket.
127    EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
128                                            payload_length,
129                                            rtp_length,
130                                            capture_time_ms,
131                                            kAllowRetransmission,
132                                            PacedSender::kNormalPriority));
133  }
134};
135
136TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
137  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
138  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
139      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
140  EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
141            rtp_sender_->RtpHeaderExtensionTotalLength());
142  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
143      kRtpExtensionTransmissionTimeOffset));
144  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
145}
146
147TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
148  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
149  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
150      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
151  EXPECT_EQ(kRtpOneByteHeaderLength + kAbsoluteSendTimeLength,
152            rtp_sender_->RtpHeaderExtensionTotalLength());
153  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
154      kRtpExtensionAbsoluteSendTime));
155  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
156}
157
158TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
159  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
160  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
161      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
162  // Accounted size for audio level is zero because it is currently specially
163  // treated by RTPSenderAudio.
164  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
165  // EXPECT_EQ(kRtpOneByteHeaderLength + kAudioLevelLength,
166  //           rtp_sender_->RtpHeaderExtensionTotalLength());
167  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
168      kRtpExtensionAudioLevel));
169  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
170}
171
172TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
173  EXPECT_EQ(0, 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, rtp_sender_->RtpHeaderExtensionTotalLength());
186  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
187      kRtpExtensionTransmissionTimeOffset));
188  EXPECT_EQ(kRtpOneByteHeaderLength + kAbsoluteSendTimeLength,
189      rtp_sender_->RtpHeaderExtensionTotalLength());
190  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
191      kRtpExtensionAbsoluteSendTime));
192  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
193  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
194      kRtpExtensionAudioLevel));
195  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
196}
197
198TEST_F(RtpSenderTest, BuildRTPPacket) {
199  int32_t length = rtp_sender_->BuildRTPheader(packet_,
200                                               kPayload,
201                                               kMarkerBit,
202                                               kTimestamp,
203                                               0);
204  EXPECT_EQ(12, length);
205
206  // Verify
207  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
208  webrtc::RTPHeader rtp_header;
209
210  RtpHeaderExtensionMap map;
211  map.Register(kRtpExtensionTransmissionTimeOffset,
212               kTransmissionTimeOffsetExtensionId);
213  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
214
215  ASSERT_TRUE(valid_rtp_header);
216  ASSERT_FALSE(rtp_parser.RTCP());
217  VerifyRTPHeaderCommon(rtp_header);
218  EXPECT_EQ(length, rtp_header.headerLength);
219  EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
220  EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime);
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  int32_t length = rtp_sender_->BuildRTPheader(packet_,
229                                               kPayload,
230                                               kMarkerBit,
231                                               kTimestamp,
232                                               0);
233  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
234
235  // Verify
236  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
237  webrtc::RTPHeader rtp_header;
238
239  RtpHeaderExtensionMap map;
240  map.Register(kRtpExtensionTransmissionTimeOffset,
241               kTransmissionTimeOffsetExtensionId);
242  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
243
244  ASSERT_TRUE(valid_rtp_header);
245  ASSERT_FALSE(rtp_parser.RTCP());
246  VerifyRTPHeaderCommon(rtp_header);
247  EXPECT_EQ(length, rtp_header.headerLength);
248  EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
249
250  // Parse without map extension
251  webrtc::RTPHeader rtp_header2;
252  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
253
254  ASSERT_TRUE(valid_rtp_header2);
255  VerifyRTPHeaderCommon(rtp_header2);
256  EXPECT_EQ(length, rtp_header2.headerLength);
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  int32_t length = rtp_sender_->BuildRTPheader(packet_,
267                                               kPayload,
268                                               kMarkerBit,
269                                               kTimestamp,
270                                               0);
271  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
272
273  // Verify
274  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
275  webrtc::RTPHeader rtp_header;
276
277  RtpHeaderExtensionMap map;
278  map.Register(kRtpExtensionTransmissionTimeOffset,
279               kTransmissionTimeOffsetExtensionId);
280  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
281
282  ASSERT_TRUE(valid_rtp_header);
283  ASSERT_FALSE(rtp_parser.RTCP());
284  VerifyRTPHeaderCommon(rtp_header);
285  EXPECT_EQ(length, rtp_header.headerLength);
286  EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
287}
288
289TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
290  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
291  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
292      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
293
294  int32_t length = rtp_sender_->BuildRTPheader(packet_,
295                                               kPayload,
296                                               kMarkerBit,
297                                               kTimestamp,
298                                               0);
299  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
300
301  // Verify
302  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
303  webrtc::RTPHeader rtp_header;
304
305  RtpHeaderExtensionMap map;
306  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
307  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
308
309  ASSERT_TRUE(valid_rtp_header);
310  ASSERT_FALSE(rtp_parser.RTCP());
311  VerifyRTPHeaderCommon(rtp_header);
312  EXPECT_EQ(length, rtp_header.headerLength);
313  EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
314
315  // Parse without map extension
316  webrtc::RTPHeader rtp_header2;
317  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
318
319  ASSERT_TRUE(valid_rtp_header2);
320  VerifyRTPHeaderCommon(rtp_header2);
321  EXPECT_EQ(length, rtp_header2.headerLength);
322  EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
323}
324
325TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
326  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
327  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
328  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
329      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
330  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
331      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
332
333  int32_t length = rtp_sender_->BuildRTPheader(packet_,
334                                               kPayload,
335                                               kMarkerBit,
336                                               kTimestamp,
337                                               0);
338  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
339
340  // Verify
341  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
342  webrtc::RTPHeader rtp_header;
343
344  RtpHeaderExtensionMap map;
345  map.Register(kRtpExtensionTransmissionTimeOffset,
346               kTransmissionTimeOffsetExtensionId);
347  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
348  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
349
350  ASSERT_TRUE(valid_rtp_header);
351  ASSERT_FALSE(rtp_parser.RTCP());
352  VerifyRTPHeaderCommon(rtp_header);
353  EXPECT_EQ(length, rtp_header.headerLength);
354  EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
355  EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
356
357  // Parse without map extension
358  webrtc::RTPHeader rtp_header2;
359  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
360
361  ASSERT_TRUE(valid_rtp_header2);
362  VerifyRTPHeaderCommon(rtp_header2);
363  EXPECT_EQ(length, rtp_header2.headerLength);
364  EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
365  EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
366}
367
368TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
369  EXPECT_CALL(mock_paced_sender_,
370              SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
371                  WillOnce(testing::Return(false));
372
373  rtp_sender_->SetStorePacketsStatus(true, 10);
374  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
375      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
376  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
377      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
378  rtp_sender_->SetTargetSendBitrate(300000);
379  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
380  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
381                                                   kPayload,
382                                                   kMarkerBit,
383                                                   kTimestamp,
384                                                   capture_time_ms);
385
386  // Packet should be stored in a send bucket.
387  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
388                                          0,
389                                          rtp_length,
390                                          capture_time_ms,
391                                          kAllowRetransmission,
392                                          PacedSender::kNormalPriority));
393
394  EXPECT_EQ(0, transport_.packets_sent_);
395
396  const int kStoredTimeInMs = 100;
397  fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
398
399  rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
400
401  // Process send bucket. Packet should now be sent.
402  EXPECT_EQ(1, transport_.packets_sent_);
403  EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
404  // Parse sent packet.
405  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
406      transport_.last_sent_packet_, rtp_length);
407  webrtc::RTPHeader rtp_header;
408  RtpHeaderExtensionMap map;
409  map.Register(kRtpExtensionTransmissionTimeOffset,
410               kTransmissionTimeOffsetExtensionId);
411  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
412  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
413  ASSERT_TRUE(valid_rtp_header);
414
415  // Verify transmission time offset.
416  EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
417  uint64_t expected_send_time =
418      ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
419  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
420}
421
422TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
423  EXPECT_CALL(mock_paced_sender_,
424              SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
425                  WillOnce(testing::Return(false));
426
427  rtp_sender_->SetStorePacketsStatus(true, 10);
428  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
429      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
430  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
431      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
432  rtp_sender_->SetTargetSendBitrate(300000);
433  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
434  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
435                                                   kPayload,
436                                                   kMarkerBit,
437                                                   kTimestamp,
438                                                   capture_time_ms);
439
440  // Packet should be stored in a send bucket.
441  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
442                                          0,
443                                          rtp_length,
444                                          capture_time_ms,
445                                          kAllowRetransmission,
446                                          PacedSender::kNormalPriority));
447
448  EXPECT_EQ(0, transport_.packets_sent_);
449
450  EXPECT_CALL(mock_paced_sender_,
451              SendPacket(PacedSender::kHighPriority, _, kSeqNum, _, _, _)).
452                  WillOnce(testing::Return(false));
453
454  const int kStoredTimeInMs = 100;
455  fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
456
457  EXPECT_EQ(rtp_length, rtp_sender_->ReSendPacket(kSeqNum));
458  EXPECT_EQ(0, transport_.packets_sent_);
459
460  rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
461
462  // Process send bucket. Packet should now be sent.
463  EXPECT_EQ(1, transport_.packets_sent_);
464  EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
465
466  // Parse sent packet.
467  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
468      transport_.last_sent_packet_, rtp_length);
469  webrtc::RTPHeader rtp_header;
470  RtpHeaderExtensionMap map;
471  map.Register(kRtpExtensionTransmissionTimeOffset,
472               kTransmissionTimeOffsetExtensionId);
473  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
474  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
475  ASSERT_TRUE(valid_rtp_header);
476
477  // Verify transmission time offset.
478  EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
479  uint64_t expected_send_time =
480      ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
481  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
482}
483
484// This test sends 1 regular video packet, then 4 padding packets, and then
485// 1 more regular packet.
486TEST_F(RtpSenderTest, SendPadding) {
487  // Make all (non-padding) packets go to send queue.
488  EXPECT_CALL(mock_paced_sender_,
489              SendPacket(PacedSender::kNormalPriority, _, _, _, _, _)).
490                  WillRepeatedly(testing::Return(false));
491
492  uint16_t seq_num = kSeqNum;
493  uint32_t timestamp = kTimestamp;
494  rtp_sender_->SetStorePacketsStatus(true, 10);
495  int rtp_header_len = 12;
496  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
497      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
498  rtp_header_len += 4;  // 4 bytes extension.
499  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
500      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
501  rtp_header_len += 4;  // 4 bytes extension.
502  rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
503
504  // Create and set up parser.
505  scoped_ptr<webrtc::RtpHeaderParser> rtp_parser(
506      webrtc::RtpHeaderParser::Create());
507  ASSERT_TRUE(rtp_parser.get() != NULL);
508  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
509                                         kTransmissionTimeOffsetExtensionId);
510  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
511                                         kAbsoluteSendTimeExtensionId);
512  webrtc::RTPHeader rtp_header;
513
514  rtp_sender_->SetTargetSendBitrate(300000);
515  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
516  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
517                                                   kPayload,
518                                                   kMarkerBit,
519                                                   timestamp,
520                                                   capture_time_ms);
521
522  // Packet should be stored in a send bucket.
523  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
524                                          0,
525                                          rtp_length,
526                                          capture_time_ms,
527                                          kAllowRetransmission,
528                                          PacedSender::kNormalPriority));
529
530  int total_packets_sent = 0;
531  EXPECT_EQ(total_packets_sent, transport_.packets_sent_);
532
533  const int kStoredTimeInMs = 100;
534  fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
535  rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
536  // Packet should now be sent. This test doesn't verify the regular video
537  // packet, since it is tested in another test.
538  EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
539  timestamp += 90 * kStoredTimeInMs;
540
541  // Send padding 4 times, waiting 50 ms between each.
542  for (int i = 0; i < 4; ++i) {
543    const int kPaddingPeriodMs = 50;
544    const int kPaddingBytes = 100;
545    const int kMaxPaddingLength = 224;  // Value taken from rtp_sender.cc.
546    // Padding will be forced to full packets.
547    EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(kPaddingBytes));
548
549    // Process send bucket. Padding should now be sent.
550    EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
551    EXPECT_EQ(kMaxPaddingLength + rtp_header_len,
552              transport_.last_sent_packet_len_);
553    // Parse sent packet.
554    ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, kPaddingBytes,
555                                  &rtp_header));
556
557    // Verify sequence number and timestamp.
558    EXPECT_EQ(seq_num++, rtp_header.sequenceNumber);
559    EXPECT_EQ(timestamp, rtp_header.timestamp);
560    // Verify transmission time offset.
561    EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
562    uint64_t expected_send_time =
563        ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
564    EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
565    fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
566    timestamp += 90 * kPaddingPeriodMs;
567  }
568
569  // Send a regular video packet again.
570  capture_time_ms = fake_clock_.TimeInMilliseconds();
571  rtp_length = rtp_sender_->BuildRTPheader(packet_,
572                                           kPayload,
573                                           kMarkerBit,
574                                           timestamp,
575                                           capture_time_ms);
576
577  // Packet should be stored in a send bucket.
578  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
579                                          0,
580                                          rtp_length,
581                                          capture_time_ms,
582                                          kAllowRetransmission,
583                                          PacedSender::kNormalPriority));
584
585  rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false);
586  // Process send bucket.
587  EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
588  EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
589  // Parse sent packet.
590  ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, rtp_length,
591                                &rtp_header));
592
593  // Verify sequence number and timestamp.
594  EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
595  EXPECT_EQ(timestamp, rtp_header.timestamp);
596  // Verify transmission time offset. This packet is sent without delay.
597  EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
598  uint64_t expected_send_time =
599      ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
600  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
601}
602
603TEST_F(RtpSenderTest, SendRedundantPayloads) {
604  MockTransport transport;
605  rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport, NULL,
606                                  &mock_paced_sender_));
607  rtp_sender_->SetSequenceNumber(kSeqNum);
608  // Make all packets go through the pacer.
609  EXPECT_CALL(mock_paced_sender_,
610              SendPacket(PacedSender::kNormalPriority, _, _, _, _, _)).
611                  WillRepeatedly(testing::Return(false));
612
613  uint16_t seq_num = kSeqNum;
614  rtp_sender_->SetStorePacketsStatus(true, 10);
615  int rtp_header_len = 12;
616  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
617      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
618  rtp_header_len += 4;  // 4 bytes extension.
619  rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
620
621  rtp_sender_->SetRTXStatus(kRtxRetransmitted | kRtxRedundantPayloads, true,
622                            1234);
623
624  // Create and set up parser.
625  scoped_ptr<webrtc::RtpHeaderParser> rtp_parser(
626      webrtc::RtpHeaderParser::Create());
627  ASSERT_TRUE(rtp_parser.get() != NULL);
628  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
629                                         kTransmissionTimeOffsetExtensionId);
630  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
631                                         kAbsoluteSendTimeExtensionId);
632  rtp_sender_->SetTargetSendBitrate(300000);
633  const size_t kNumPayloadSizes = 10;
634  const int kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 750,
635      800, 850, 900, 950};
636  // Send 10 packets of increasing size.
637  for (size_t i = 0; i < kNumPayloadSizes; ++i) {
638    int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
639    EXPECT_CALL(transport, SendPacket(_, _, _))
640        .WillOnce(testing::ReturnArg<2>());
641    SendPacket(capture_time_ms, kPayloadSizes[i]);
642    rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
643    fake_clock_.AdvanceTimeMilliseconds(33);
644  }
645  const int kPaddingPayloadSize = 224;
646  // The amount of padding to send it too small to send a payload packet.
647  EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
648      .WillOnce(testing::ReturnArg<2>());
649  EXPECT_EQ(kPaddingPayloadSize, rtp_sender_->TimeToSendPadding(49));
650
651  const int kRtxHeaderSize = 2;
652  EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[0] +
653                                    rtp_header_len + kRtxHeaderSize))
654      .WillOnce(testing::ReturnArg<2>());
655  EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
656
657  EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[kNumPayloadSizes - 1] +
658                                    rtp_header_len + kRtxHeaderSize))
659      .WillOnce(testing::ReturnArg<2>());
660  EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
661      .WillOnce(testing::ReturnArg<2>());
662  EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kPaddingPayloadSize,
663            rtp_sender_->TimeToSendPadding(999));
664}
665
666TEST_F(RtpSenderTest, SendGenericVideo) {
667  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
668  const uint8_t payload_type = 127;
669  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
670                                            0, 1500));
671  uint8_t payload[] = {47, 11, 32, 93, 89};
672
673  // Send keyframe
674  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
675                                             4321, payload, sizeof(payload),
676                                             NULL));
677
678  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
679      transport_.last_sent_packet_len_);
680  webrtc::RTPHeader rtp_header;
681  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
682
683  const uint8_t* payload_data = GetPayloadData(rtp_header,
684      transport_.last_sent_packet_);
685  uint8_t generic_header = *payload_data++;
686
687  ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
688            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
689
690  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
691  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
692
693  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
694
695  // Send delta frame
696  payload[0] = 13;
697  payload[1] = 42;
698  payload[4] = 13;
699
700  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type,
701                                             1234, 4321, payload,
702                                             sizeof(payload), NULL));
703
704  ModuleRTPUtility::RTPHeaderParser rtp_parser2(transport_.last_sent_packet_,
705      transport_.last_sent_packet_len_);
706  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
707
708  payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
709  generic_header = *payload_data++;
710
711  EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
712  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
713
714  ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
715            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
716
717  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
718}
719
720TEST_F(RtpSenderTest, FrameCountCallbacks) {
721  class TestCallback : public FrameCountObserver {
722   public:
723    TestCallback()
724      : FrameCountObserver(), num_calls_(0), ssrc_(0),
725        key_frames_(0), delta_frames_(0) {}
726    virtual ~TestCallback() {}
727
728    virtual void FrameCountUpdated(FrameType frame_type,
729                                   uint32_t frame_count,
730                                   const unsigned int ssrc) {
731      ++num_calls_;
732      ssrc_ = ssrc;
733      switch (frame_type) {
734        case kVideoFrameDelta:
735          delta_frames_ = frame_count;
736          break;
737        case kVideoFrameKey:
738          key_frames_ = frame_count;
739          break;
740        default:
741          break;
742      }
743    }
744
745    uint32_t num_calls_;
746    uint32_t ssrc_;
747    uint32_t key_frames_;
748    uint32_t delta_frames_;
749  } callback;
750
751  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
752  const uint8_t payload_type = 127;
753  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
754                                            0, 1500));
755  uint8_t payload[] = {47, 11, 32, 93, 89};
756  rtp_sender_->SetStorePacketsStatus(true, 1);
757  uint32_t ssrc = rtp_sender_->SSRC();
758
759  rtp_sender_->RegisterFrameCountObserver(&callback);
760
761  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
762                                             4321, payload, sizeof(payload),
763                                             NULL));
764
765  EXPECT_EQ(1U, callback.num_calls_);
766  EXPECT_EQ(ssrc, callback.ssrc_);
767  EXPECT_EQ(1U, callback.key_frames_);
768  EXPECT_EQ(0U, callback.delta_frames_);
769
770  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta,
771                                             payload_type, 1234, 4321, payload,
772                                             sizeof(payload), NULL));
773
774  EXPECT_EQ(2U, callback.num_calls_);
775  EXPECT_EQ(ssrc, callback.ssrc_);
776  EXPECT_EQ(1U, callback.key_frames_);
777  EXPECT_EQ(1U, callback.delta_frames_);
778
779  rtp_sender_->RegisterFrameCountObserver(NULL);
780}
781
782class RtpSenderAudioTest : public RtpSenderTest {
783 protected:
784  RtpSenderAudioTest() {}
785
786  virtual void SetUp() {
787    payload_ = kAudioPayload;
788    rtp_sender_.reset(new RTPSender(0, true, &fake_clock_, &transport_, NULL,
789                                    &mock_paced_sender_));
790    rtp_sender_->SetSequenceNumber(kSeqNum);
791  }
792};
793
794TEST_F(RtpSenderAudioTest, BuildRTPPacketWithAudioLevelExtension) {
795  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(true,
796      kAudioLevelExtensionId));
797  EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
798  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
799      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
800
801  int32_t length = rtp_sender_->BuildRTPheader(packet_,
802                                               kAudioPayload,
803                                               kMarkerBit,
804                                               kTimestamp,
805                                               0);
806  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
807
808  // Currently, no space is added by for header extension by BuildRTPHeader().
809  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
810
811  // Verify
812  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
813  webrtc::RTPHeader rtp_header;
814
815  RtpHeaderExtensionMap map;
816  map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
817  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
818
819  ASSERT_TRUE(valid_rtp_header);
820  ASSERT_FALSE(rtp_parser.RTCP());
821  VerifyRTPHeaderCommon(rtp_header);
822  EXPECT_EQ(length, rtp_header.headerLength);
823  // TODO(solenberg): Should verify that we got audio level in header extension.
824
825  // Parse without map extension
826  webrtc::RTPHeader rtp_header2;
827  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
828
829  ASSERT_TRUE(valid_rtp_header2);
830  VerifyRTPHeaderCommon(rtp_header2);
831  EXPECT_EQ(length, rtp_header2.headerLength);
832  // TODO(solenberg): Should verify that we didn't get audio level.
833  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(false, 0));
834}
835
836TEST_F(RtpSenderAudioTest, SendAudio) {
837  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
838  const uint8_t payload_type = 127;
839  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
840                                            0, 1500));
841  uint8_t payload[] = {47, 11, 32, 93, 89};
842
843  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
844                                             4321, payload, sizeof(payload),
845                                             NULL));
846
847  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
848      transport_.last_sent_packet_len_);
849  webrtc::RTPHeader rtp_header;
850  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
851
852  const uint8_t* payload_data = GetPayloadData(rtp_header,
853      transport_.last_sent_packet_);
854
855  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(rtp_header,
856            transport_.last_sent_packet_len_));
857
858  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
859}
860
861TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
862  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(true,
863      kAudioLevelExtensionId));
864  EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
865  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
866      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
867
868  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
869  const uint8_t payload_type = 127;
870  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
871                                            0, 1500));
872  uint8_t payload[] = {47, 11, 32, 93, 89};
873
874  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
875                                             4321, payload, sizeof(payload),
876                                             NULL));
877
878  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
879      transport_.last_sent_packet_len_);
880  webrtc::RTPHeader rtp_header;
881  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
882
883  const uint8_t* payload_data = GetPayloadData(rtp_header,
884                                               transport_.last_sent_packet_);
885
886  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(
887      rtp_header, transport_.last_sent_packet_len_));
888
889  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
890
891  uint8_t extension[] = { 0xbe, 0xde, 0x00, 0x01,
892                          (kAudioLevelExtensionId << 4) + 0, // ID + length.
893                          kAudioLevel,                       // Data.
894                          0x00, 0x00                         // Padding.
895                        };
896
897  EXPECT_EQ(0, memcmp(extension, payload_data - sizeof(extension),
898                      sizeof(extension)));
899  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(false, 0));
900}
901
902}  // namespace webrtc
903