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