src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

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