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