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