rtp_sender_unittest.cc revision 9b82f5a6ed2ceb04f72b66c1d3cca67a2bbcec3a 
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_rtcp_defines.h"
19#include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
20#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
21#include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
22#include "webrtc/system_wrappers/interface/scoped_ptr.h"
23#include "webrtc/typedefs.h"
24
25namespace webrtc {
26
27namespace {
28const int kTransmissionTimeOffsetExtensionId = 1;
29const int kAbsoluteSendTimeExtensionId = 14;
30const int kPayload = 100;
31const uint32_t kTimestamp = 10;
32const uint16_t kSeqNum = 33;
33const int kTimeOffset = 22222;
34const int kMaxPacketLength = 1500;
35const uint32_t kAbsoluteSendTime = 0x00aabbcc;
36const uint8_t kAudioLevel = 0x5a;
37const uint8_t kAudioLevelExtensionId = 9;
38const int kAudioPayload = 103;
39}  // namespace
40
41using testing::_;
42
43const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
44                              const uint8_t* packet) {
45  return packet + rtp_header.headerLength;
46}
47
48uint16_t GetPayloadDataLength(const RTPHeader& rtp_header,
49                              const uint16_t packet_length) {
50  uint16_t length = packet_length - rtp_header.headerLength -
51      rtp_header.paddingLength;
52  return static_cast<uint16_t>(length);
53}
54
55class LoopbackTransportTest : public webrtc::Transport {
56 public:
57  LoopbackTransportTest()
58    : packets_sent_(0),
59      last_sent_packet_len_(0) {
60  }
61  virtual int SendPacket(int channel, const void *data, int len) {
62    packets_sent_++;
63    memcpy(last_sent_packet_, data, len);
64    last_sent_packet_len_ = len;
65    return len;
66  }
67  virtual int SendRTCPPacket(int channel, const void *data, int len) {
68    return -1;
69  }
70  int packets_sent_;
71  int last_sent_packet_len_;
72  uint8_t last_sent_packet_[kMaxPacketLength];
73};
74
75class RtpSenderTest : public ::testing::Test {
76 protected:
77  RtpSenderTest()
78    : fake_clock_(123456789),
79      mock_paced_sender_(),
80      rtp_sender_(),
81      payload_(kPayload),
82      transport_(),
83      kMarkerBit(true) {
84    EXPECT_CALL(mock_paced_sender_,
85        SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true));
86  }
87
88  virtual void SetUp() {
89    rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
90                                    &mock_paced_sender_));
91    rtp_sender_->SetSequenceNumber(kSeqNum);
92  }
93
94  SimulatedClock fake_clock_;
95  MockPacedSender mock_paced_sender_;
96  scoped_ptr<RTPSender> rtp_sender_;
97  int payload_;
98  LoopbackTransportTest transport_;
99  const bool kMarkerBit;
100  uint8_t packet_[kMaxPacketLength];
101
102  void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
103    EXPECT_EQ(kMarkerBit, rtp_header.markerBit);
104    EXPECT_EQ(payload_, rtp_header.payloadType);
105    EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
106    EXPECT_EQ(kTimestamp, rtp_header.timestamp);
107    EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
108    EXPECT_EQ(0, rtp_header.numCSRCs);
109    EXPECT_EQ(0, rtp_header.paddingLength);
110  }
111};
112
113TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
114  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
115  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
116      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
117  EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
118            rtp_sender_->RtpHeaderExtensionTotalLength());
119  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
120      kRtpExtensionTransmissionTimeOffset));
121  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
122}
123
124TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
125  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
126  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
127      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
128  EXPECT_EQ(kRtpOneByteHeaderLength + kAbsoluteSendTimeLength,
129            rtp_sender_->RtpHeaderExtensionTotalLength());
130  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
131      kRtpExtensionAbsoluteSendTime));
132  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
133}
134
135TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
136  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
137  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
138      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
139  // Accounted size for audio level is zero because it is currently specially
140  // treated by RTPSenderAudio.
141  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
142  // EXPECT_EQ(kRtpOneByteHeaderLength + kAudioLevelLength,
143  //           rtp_sender_->RtpHeaderExtensionTotalLength());
144  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
145      kRtpExtensionAudioLevel));
146  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
147}
148
149TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
150  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
151  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
152      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
153  EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
154            rtp_sender_->RtpHeaderExtensionTotalLength());
155  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
156      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
157  EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength +
158      kAbsoluteSendTimeLength, rtp_sender_->RtpHeaderExtensionTotalLength());
159  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
160      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
161  EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength +
162      kAbsoluteSendTimeLength, rtp_sender_->RtpHeaderExtensionTotalLength());
163  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
164      kRtpExtensionTransmissionTimeOffset));
165  EXPECT_EQ(kRtpOneByteHeaderLength + kAbsoluteSendTimeLength,
166      rtp_sender_->RtpHeaderExtensionTotalLength());
167  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
168      kRtpExtensionAbsoluteSendTime));
169  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
170  EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
171      kRtpExtensionAudioLevel));
172  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
173}
174
175TEST_F(RtpSenderTest, BuildRTPPacket) {
176  int32_t length = rtp_sender_->BuildRTPheader(packet_,
177                                               kPayload,
178                                               kMarkerBit,
179                                               kTimestamp,
180                                               0);
181  EXPECT_EQ(12, length);
182
183  // Verify
184  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
185  webrtc::RTPHeader rtp_header;
186
187  RtpHeaderExtensionMap map;
188  map.Register(kRtpExtensionTransmissionTimeOffset,
189               kTransmissionTimeOffsetExtensionId);
190  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
191
192  ASSERT_TRUE(valid_rtp_header);
193  ASSERT_FALSE(rtp_parser.RTCP());
194  VerifyRTPHeaderCommon(rtp_header);
195  EXPECT_EQ(length, rtp_header.headerLength);
196  EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
197  EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime);
198}
199
200TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
201  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
202  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
203      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
204
205  int32_t length = rtp_sender_->BuildRTPheader(packet_,
206                                               kPayload,
207                                               kMarkerBit,
208                                               kTimestamp,
209                                               0);
210  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
211
212  // Verify
213  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
214  webrtc::RTPHeader rtp_header;
215
216  RtpHeaderExtensionMap map;
217  map.Register(kRtpExtensionTransmissionTimeOffset,
218               kTransmissionTimeOffsetExtensionId);
219  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
220
221  ASSERT_TRUE(valid_rtp_header);
222  ASSERT_FALSE(rtp_parser.RTCP());
223  VerifyRTPHeaderCommon(rtp_header);
224  EXPECT_EQ(length, rtp_header.headerLength);
225  EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
226
227  // Parse without map extension
228  webrtc::RTPHeader rtp_header2;
229  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
230
231  ASSERT_TRUE(valid_rtp_header2);
232  VerifyRTPHeaderCommon(rtp_header2);
233  EXPECT_EQ(length, rtp_header2.headerLength);
234  EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
235}
236
237TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
238  const int kNegTimeOffset = -500;
239  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
240  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
241      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
242
243  int32_t length = rtp_sender_->BuildRTPheader(packet_,
244                                               kPayload,
245                                               kMarkerBit,
246                                               kTimestamp,
247                                               0);
248  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
249
250  // Verify
251  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
252  webrtc::RTPHeader rtp_header;
253
254  RtpHeaderExtensionMap map;
255  map.Register(kRtpExtensionTransmissionTimeOffset,
256               kTransmissionTimeOffsetExtensionId);
257  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
258
259  ASSERT_TRUE(valid_rtp_header);
260  ASSERT_FALSE(rtp_parser.RTCP());
261  VerifyRTPHeaderCommon(rtp_header);
262  EXPECT_EQ(length, rtp_header.headerLength);
263  EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
264}
265
266TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
267  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
268  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
269      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
270
271  int32_t length = rtp_sender_->BuildRTPheader(packet_,
272                                               kPayload,
273                                               kMarkerBit,
274                                               kTimestamp,
275                                               0);
276  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
277
278  // Verify
279  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
280  webrtc::RTPHeader rtp_header;
281
282  RtpHeaderExtensionMap map;
283  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
284  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
285
286  ASSERT_TRUE(valid_rtp_header);
287  ASSERT_FALSE(rtp_parser.RTCP());
288  VerifyRTPHeaderCommon(rtp_header);
289  EXPECT_EQ(length, rtp_header.headerLength);
290  EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
291
292  // Parse without map extension
293  webrtc::RTPHeader rtp_header2;
294  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
295
296  ASSERT_TRUE(valid_rtp_header2);
297  VerifyRTPHeaderCommon(rtp_header2);
298  EXPECT_EQ(length, rtp_header2.headerLength);
299  EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
300}
301
302TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
303  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
304  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
305  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
306      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
307  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
308      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
309
310  int32_t length = rtp_sender_->BuildRTPheader(packet_,
311                                               kPayload,
312                                               kMarkerBit,
313                                               kTimestamp,
314                                               0);
315  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
316
317  // Verify
318  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
319  webrtc::RTPHeader rtp_header;
320
321  RtpHeaderExtensionMap map;
322  map.Register(kRtpExtensionTransmissionTimeOffset,
323               kTransmissionTimeOffsetExtensionId);
324  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
325  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
326
327  ASSERT_TRUE(valid_rtp_header);
328  ASSERT_FALSE(rtp_parser.RTCP());
329  VerifyRTPHeaderCommon(rtp_header);
330  EXPECT_EQ(length, rtp_header.headerLength);
331  EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
332  EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
333
334  // Parse without map extension
335  webrtc::RTPHeader rtp_header2;
336  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
337
338  ASSERT_TRUE(valid_rtp_header2);
339  VerifyRTPHeaderCommon(rtp_header2);
340  EXPECT_EQ(length, rtp_header2.headerLength);
341  EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
342  EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
343}
344
345TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
346  EXPECT_CALL(mock_paced_sender_,
347              SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
348                  WillOnce(testing::Return(false));
349
350  rtp_sender_->SetStorePacketsStatus(true, 10);
351  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
352      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
353  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
354      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
355  rtp_sender_->SetTargetSendBitrate(300000);
356  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
357  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
358                                                   kPayload,
359                                                   kMarkerBit,
360                                                   kTimestamp,
361                                                   capture_time_ms);
362
363  // Packet should be stored in a send bucket.
364  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
365                                          0,
366                                          rtp_length,
367                                          capture_time_ms,
368                                          kAllowRetransmission,
369                                          PacedSender::kNormalPriority));
370
371  EXPECT_EQ(0, transport_.packets_sent_);
372
373  const int kStoredTimeInMs = 100;
374  fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
375
376  rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
377
378  // Process send bucket. Packet should now be sent.
379  EXPECT_EQ(1, transport_.packets_sent_);
380  EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
381  // Parse sent packet.
382  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
383      transport_.last_sent_packet_, rtp_length);
384  webrtc::RTPHeader rtp_header;
385  RtpHeaderExtensionMap map;
386  map.Register(kRtpExtensionTransmissionTimeOffset,
387               kTransmissionTimeOffsetExtensionId);
388  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
389  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
390  ASSERT_TRUE(valid_rtp_header);
391
392  // Verify transmission time offset.
393  EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
394  uint64_t expected_send_time =
395      0x00fffffful & ((fake_clock_.TimeInMilliseconds() << 18) / 1000);
396  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
397}
398
399TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
400  EXPECT_CALL(mock_paced_sender_,
401              SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
402                  WillOnce(testing::Return(false));
403
404  rtp_sender_->SetStorePacketsStatus(true, 10);
405  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
406      kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
407  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
408      kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
409  rtp_sender_->SetTargetSendBitrate(300000);
410  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
411  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
412                                                   kPayload,
413                                                   kMarkerBit,
414                                                   kTimestamp,
415                                                   capture_time_ms);
416
417  // Packet should be stored in a send bucket.
418  EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
419                                          0,
420                                          rtp_length,
421                                          capture_time_ms,
422                                          kAllowRetransmission,
423                                          PacedSender::kNormalPriority));
424
425  EXPECT_EQ(0, transport_.packets_sent_);
426
427  EXPECT_CALL(mock_paced_sender_,
428              SendPacket(PacedSender::kHighPriority, _, kSeqNum, _, _, _)).
429                  WillOnce(testing::Return(false));
430
431  const int kStoredTimeInMs = 100;
432  fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
433
434  EXPECT_EQ(rtp_length, rtp_sender_->ReSendPacket(kSeqNum));
435  EXPECT_EQ(0, transport_.packets_sent_);
436
437  rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
438
439  // Process send bucket. Packet should now be sent.
440  EXPECT_EQ(1, transport_.packets_sent_);
441  EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
442
443  // Parse sent packet.
444  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
445      transport_.last_sent_packet_, rtp_length);
446  webrtc::RTPHeader rtp_header;
447  RtpHeaderExtensionMap map;
448  map.Register(kRtpExtensionTransmissionTimeOffset,
449               kTransmissionTimeOffsetExtensionId);
450  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
451  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
452  ASSERT_TRUE(valid_rtp_header);
453
454  // Verify transmission time offset.
455  EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
456  uint64_t expected_send_time =
457      0x00fffffful & ((fake_clock_.TimeInMilliseconds() << 18) / 1000);
458  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
459}
460
461TEST_F(RtpSenderTest, SendGenericVideo) {
462  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
463  const uint8_t payload_type = 127;
464  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
465                                            0, 1500));
466  uint8_t payload[] = {47, 11, 32, 93, 89};
467
468  // Send keyframe
469  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
470                                             4321, payload, sizeof(payload),
471                                             NULL));
472
473  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
474      transport_.last_sent_packet_len_);
475  webrtc::RTPHeader rtp_header;
476  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
477
478  const uint8_t* payload_data = GetPayloadData(rtp_header,
479      transport_.last_sent_packet_);
480  uint8_t generic_header = *payload_data++;
481
482  ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
483            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
484
485  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
486  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
487
488  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
489
490  // Send delta frame
491  payload[0] = 13;
492  payload[1] = 42;
493  payload[4] = 13;
494
495  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type,
496                                             1234, 4321, payload,
497                                             sizeof(payload), NULL));
498
499  ModuleRTPUtility::RTPHeaderParser rtp_parser2(transport_.last_sent_packet_,
500      transport_.last_sent_packet_len_);
501  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
502
503  payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
504  generic_header = *payload_data++;
505
506  EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
507  EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
508
509  ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
510            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
511
512  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
513}
514
515class RtpSenderAudioTest : public RtpSenderTest {
516 protected:
517  RtpSenderAudioTest() {}
518
519  virtual void SetUp() {
520    payload_ = kAudioPayload;
521    rtp_sender_.reset(new RTPSender(0, true, &fake_clock_, &transport_, NULL,
522                                    &mock_paced_sender_));
523    rtp_sender_->SetSequenceNumber(kSeqNum);
524  }
525};
526
527TEST_F(RtpSenderAudioTest, BuildRTPPacketWithAudioLevelExtension) {
528  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(true,
529      kAudioLevelExtensionId));
530  EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
531  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
532      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
533
534  int32_t length = rtp_sender_->BuildRTPheader(packet_,
535                                               kAudioPayload,
536                                               kMarkerBit,
537                                               kTimestamp,
538                                               0);
539  EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
540
541  // Currently, no space is added by for header extension by BuildRTPHeader().
542  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
543
544  // Verify
545  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
546  webrtc::RTPHeader rtp_header;
547
548  RtpHeaderExtensionMap map;
549  map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
550  const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map);
551
552  ASSERT_TRUE(valid_rtp_header);
553  ASSERT_FALSE(rtp_parser.RTCP());
554  VerifyRTPHeaderCommon(rtp_header);
555  EXPECT_EQ(length, rtp_header.headerLength);
556  // TODO(solenberg): Should verify that we got audio level in header extension.
557
558  // Parse without map extension
559  webrtc::RTPHeader rtp_header2;
560  const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, NULL);
561
562  ASSERT_TRUE(valid_rtp_header2);
563  VerifyRTPHeaderCommon(rtp_header2);
564  EXPECT_EQ(length, rtp_header2.headerLength);
565  // TODO(solenberg): Should verify that we didn't get audio level.
566  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(false, 0));
567}
568
569TEST_F(RtpSenderAudioTest, SendAudio) {
570  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
571  const uint8_t payload_type = 127;
572  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
573                                            0, 1500));
574  uint8_t payload[] = {47, 11, 32, 93, 89};
575
576  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
577                                             4321, payload, sizeof(payload),
578                                             NULL));
579
580  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
581      transport_.last_sent_packet_len_);
582  webrtc::RTPHeader rtp_header;
583  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
584
585  const uint8_t* payload_data = GetPayloadData(rtp_header,
586      transport_.last_sent_packet_);
587
588  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(rtp_header,
589            transport_.last_sent_packet_len_));
590
591  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
592}
593
594TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
595  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(true,
596      kAudioLevelExtensionId));
597  EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
598  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
599      kRtpExtensionAudioLevel, kAudioLevelExtensionId));
600
601  char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
602  const uint8_t payload_type = 127;
603  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
604                                            0, 1500));
605  uint8_t payload[] = {47, 11, 32, 93, 89};
606
607  ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
608                                             4321, payload, sizeof(payload),
609                                             NULL));
610
611  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
612      transport_.last_sent_packet_len_);
613  webrtc::RTPHeader rtp_header;
614  ASSERT_TRUE(rtp_parser.Parse(rtp_header));
615
616  const uint8_t* payload_data = GetPayloadData(rtp_header,
617                                               transport_.last_sent_packet_);
618
619  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(
620      rtp_header, transport_.last_sent_packet_len_));
621
622  EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
623
624  uint8_t extension[] = { 0xbe, 0xde, 0x00, 0x01,
625                          (kAudioLevelExtensionId << 4) + 0, // ID + length.
626                          kAudioLevel,                       // Data.
627                          0x00, 0x00                         // Padding.
628                        };
629
630  EXPECT_EQ(0, memcmp(extension, payload_data - sizeof(extension),
631                      sizeof(extension)));
632  EXPECT_EQ(0, rtp_sender_->SetAudioLevelIndicationStatus(false, 0));
633}
634
635}  // namespace webrtc
636