1/* 2 * Copyright (c) 2013 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#include "testing/gmock/include/gmock/gmock.h" 12#include "testing/gtest/include/gtest/gtest.h" 13 14#include "webrtc/common_types.h" 15#include "webrtc/modules/pacing/include/mock/mock_paced_sender.h" 16#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" 17#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h" 18#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" 19#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" 20#include "webrtc/system_wrappers/interface/scoped_vector.h" 21 22using ::testing::_; 23using ::testing::NiceMock; 24using ::testing::Return; 25using ::testing::SaveArg; 26 27namespace webrtc { 28namespace { 29const uint32_t kSenderSsrc = 0x12345; 30const uint32_t kReceiverSsrc = 0x23456; 31const uint32_t kSenderRtxSsrc = 0x32345; 32const uint32_t kOneWayNetworkDelayMs = 100; 33const uint8_t kBaseLayerTid = 0; 34const uint8_t kHigherLayerTid = 1; 35const uint16_t kSequenceNumber = 100; 36 37class RtcpRttStatsTestImpl : public RtcpRttStats { 38 public: 39 RtcpRttStatsTestImpl() : rtt_ms_(0) {} 40 virtual ~RtcpRttStatsTestImpl() {} 41 42 virtual void OnRttUpdate(uint32_t rtt_ms) { 43 rtt_ms_ = rtt_ms; 44 } 45 virtual uint32_t LastProcessedRtt() const { 46 return rtt_ms_; 47 } 48 uint32_t rtt_ms_; 49}; 50 51class SendTransport : public Transport, 52 public NullRtpData { 53 public: 54 SendTransport() 55 : receiver_(NULL), 56 clock_(NULL), 57 delay_ms_(0), 58 rtp_packets_sent_(0) { 59 } 60 61 void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) { 62 receiver_ = receiver; 63 } 64 void SimulateNetworkDelay(uint32_t delay_ms, SimulatedClock* clock) { 65 clock_ = clock; 66 delay_ms_ = delay_ms; 67 } 68 virtual int SendPacket(int /*ch*/, const void* data, int len) { 69 RTPHeader header; 70 scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); 71 EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), 72 static_cast<size_t>(len), 73 &header)); 74 ++rtp_packets_sent_; 75 last_rtp_header_ = header; 76 return len; 77 } 78 virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) { 79 if (clock_) { 80 clock_->AdvanceTimeMilliseconds(delay_ms_); 81 } 82 EXPECT_TRUE(receiver_ != NULL); 83 EXPECT_EQ(0, receiver_->IncomingRtcpPacket( 84 static_cast<const uint8_t*>(data), len)); 85 return len; 86 } 87 ModuleRtpRtcpImpl* receiver_; 88 SimulatedClock* clock_; 89 uint32_t delay_ms_; 90 int rtp_packets_sent_; 91 RTPHeader last_rtp_header_; 92}; 93 94class RtpRtcpModule { 95 public: 96 RtpRtcpModule(SimulatedClock* clock) 97 : receive_statistics_(ReceiveStatistics::Create(clock)) { 98 RtpRtcp::Configuration config; 99 config.audio = false; 100 config.clock = clock; 101 config.outgoing_transport = &transport_; 102 config.receive_statistics = receive_statistics_.get(); 103 config.rtt_stats = &rtt_stats_; 104 105 impl_.reset(new ModuleRtpRtcpImpl(config)); 106 EXPECT_EQ(0, impl_->SetRTCPStatus(kRtcpCompound)); 107 108 transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock); 109 } 110 111 RtcpPacketTypeCounter packets_sent_; 112 RtcpPacketTypeCounter packets_received_; 113 scoped_ptr<ReceiveStatistics> receive_statistics_; 114 SendTransport transport_; 115 RtcpRttStatsTestImpl rtt_stats_; 116 scoped_ptr<ModuleRtpRtcpImpl> impl_; 117 118 RtcpPacketTypeCounter RtcpSent() { 119 impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_); 120 return packets_sent_; 121 } 122 RtcpPacketTypeCounter RtcpReceived() { 123 impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_); 124 return packets_received_; 125 } 126 int RtpSent() { 127 return transport_.rtp_packets_sent_; 128 } 129 uint16_t LastRtpSequenceNumber() { 130 return transport_.last_rtp_header_.sequenceNumber; 131 } 132}; 133} // namespace 134 135class RtpRtcpImplTest : public ::testing::Test { 136 protected: 137 RtpRtcpImplTest() 138 : clock_(1335900000), 139 sender_(&clock_), 140 receiver_(&clock_) { 141 // Send module. 142 EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true)); 143 EXPECT_EQ(0, sender_.impl_->SetSendingMediaStatus(true)); 144 sender_.impl_->SetSSRC(kSenderSsrc); 145 sender_.impl_->SetRemoteSSRC(kReceiverSsrc); 146 sender_.impl_->SetSequenceNumber(kSequenceNumber); 147 sender_.impl_->SetStorePacketsStatus(true, 100); 148 149 memset(&codec_, 0, sizeof(VideoCodec)); 150 codec_.plType = 100; 151 strncpy(codec_.plName, "VP8", 3); 152 codec_.width = 320; 153 codec_.height = 180; 154 EXPECT_EQ(0, sender_.impl_->RegisterSendPayload(codec_)); 155 156 // Receive module. 157 EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false)); 158 EXPECT_EQ(0, receiver_.impl_->SetSendingMediaStatus(false)); 159 receiver_.impl_->SetSSRC(kReceiverSsrc); 160 receiver_.impl_->SetRemoteSSRC(kSenderSsrc); 161 // Transport settings. 162 sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get()); 163 receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get()); 164 } 165 SimulatedClock clock_; 166 RtpRtcpModule sender_; 167 RtpRtcpModule receiver_; 168 VideoCodec codec_; 169 170 void SendFrame(const RtpRtcpModule* module, uint8_t tid) { 171 RTPVideoHeaderVP8 vp8_header = {}; 172 vp8_header.temporalIdx = tid; 173 RTPVideoHeader rtp_video_header = { 174 codec_.width, codec_.height, true, 0, kRtpVideoVp8, {vp8_header}}; 175 176 const uint8_t payload[100] = {0}; 177 EXPECT_EQ(0, module->impl_->SendOutgoingData(kVideoFrameKey, 178 codec_.plType, 179 0, 180 0, 181 payload, 182 sizeof(payload), 183 NULL, 184 &rtp_video_header)); 185 } 186 187 void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) { 188 rtcp::Nack nack; 189 uint16_t list[1]; 190 list[0] = sequence_number; 191 const uint16_t kListLength = sizeof(list) / sizeof(list[0]); 192 nack.From(kReceiverSsrc); 193 nack.To(kSenderSsrc); 194 nack.WithList(list, kListLength); 195 rtcp::RawPacket packet = nack.Build(); 196 EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.buffer(), 197 packet.buffer_length())); 198 } 199}; 200 201TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_BaseLayer) { 202 sender_.impl_->SetSelectiveRetransmissions(kRetransmitBaseLayer); 203 EXPECT_EQ(kRetransmitBaseLayer, sender_.impl_->SelectiveRetransmissions()); 204 205 // Send frames. 206 EXPECT_EQ(0, sender_.RtpSent()); 207 SendFrame(&sender_, kBaseLayerTid); // kSequenceNumber 208 SendFrame(&sender_, kHigherLayerTid); // kSequenceNumber + 1 209 SendFrame(&sender_, kNoTemporalIdx); // kSequenceNumber + 2 210 EXPECT_EQ(3, sender_.RtpSent()); 211 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber()); 212 213 // Frame with kBaseLayerTid re-sent. 214 IncomingRtcpNack(&sender_, kSequenceNumber); 215 EXPECT_EQ(4, sender_.RtpSent()); 216 EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber()); 217 // Frame with kHigherLayerTid not re-sent. 218 IncomingRtcpNack(&sender_, kSequenceNumber + 1); 219 EXPECT_EQ(4, sender_.RtpSent()); 220 // Frame with kNoTemporalIdx re-sent. 221 IncomingRtcpNack(&sender_, kSequenceNumber + 2); 222 EXPECT_EQ(5, sender_.RtpSent()); 223 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber()); 224} 225 226TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_HigherLayers) { 227 const uint8_t kSetting = kRetransmitBaseLayer + kRetransmitHigherLayers; 228 sender_.impl_->SetSelectiveRetransmissions(kSetting); 229 EXPECT_EQ(kSetting, sender_.impl_->SelectiveRetransmissions()); 230 231 // Send frames. 232 EXPECT_EQ(0, sender_.RtpSent()); 233 SendFrame(&sender_, kBaseLayerTid); // kSequenceNumber 234 SendFrame(&sender_, kHigherLayerTid); // kSequenceNumber + 1 235 SendFrame(&sender_, kNoTemporalIdx); // kSequenceNumber + 2 236 EXPECT_EQ(3, sender_.RtpSent()); 237 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber()); 238 239 // Frame with kBaseLayerTid re-sent. 240 IncomingRtcpNack(&sender_, kSequenceNumber); 241 EXPECT_EQ(4, sender_.RtpSent()); 242 EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber()); 243 // Frame with kHigherLayerTid re-sent. 244 IncomingRtcpNack(&sender_, kSequenceNumber + 1); 245 EXPECT_EQ(5, sender_.RtpSent()); 246 EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber()); 247 // Frame with kNoTemporalIdx re-sent. 248 IncomingRtcpNack(&sender_, kSequenceNumber + 2); 249 EXPECT_EQ(6, sender_.RtpSent()); 250 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber()); 251} 252 253TEST_F(RtpRtcpImplTest, Rtt) { 254 RTPHeader header; 255 header.timestamp = 1; 256 header.sequenceNumber = 123; 257 header.ssrc = kSenderSsrc; 258 header.headerLength = 12; 259 receiver_.receive_statistics_->IncomingPacket(header, 100, false); 260 261 // Sender module should send a SR. 262 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport)); 263 264 // Receiver module should send a RR with a response to the last received SR. 265 clock_.AdvanceTimeMilliseconds(1000); 266 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport)); 267 268 // Verify RTT. 269 uint16_t rtt; 270 uint16_t avg_rtt; 271 uint16_t min_rtt; 272 uint16_t max_rtt; 273 EXPECT_EQ(0, 274 sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt)); 275 EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt); 276 EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt); 277 EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt); 278 EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt); 279 280 // No RTT from other ssrc. 281 EXPECT_EQ(-1, 282 sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt)); 283 284 // Verify RTT from rtt_stats config. 285 EXPECT_EQ(0U, sender_.rtt_stats_.LastProcessedRtt()); 286 EXPECT_EQ(0U, sender_.impl_->rtt_ms()); 287 sender_.impl_->Process(); 288 EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt()); 289 EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms()); 290} 291 292TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) { 293 EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus()); 294 receiver_.impl_->SetRtcpXrRrtrStatus(true); 295 EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus()); 296} 297 298TEST_F(RtpRtcpImplTest, RttForReceiverOnly) { 299 receiver_.impl_->SetRtcpXrRrtrStatus(true); 300 301 // Receiver module should send a Receiver time reference report (RTRR). 302 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport)); 303 304 // Sender module should send a response to the last received RTRR (DLRR). 305 clock_.AdvanceTimeMilliseconds(1000); 306 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport)); 307 308 // Verify RTT. 309 EXPECT_EQ(0U, receiver_.rtt_stats_.LastProcessedRtt()); 310 EXPECT_EQ(0U, receiver_.impl_->rtt_ms()); 311 receiver_.impl_->Process(); 312 EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt()); 313 EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms()); 314} 315 316TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_Nack) { 317 EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets); 318 EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets); 319 // Receive module sends a NACK. 320 const uint16_t kNackLength = 1; 321 uint16_t nack_list[kNackLength] = {123}; 322 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength)); 323 EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets); 324 325 // Send module receives the NACK. 326 EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets); 327} 328 329TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) { 330 EXPECT_EQ(0U, sender_.RtcpReceived().fir_packets); 331 EXPECT_EQ(0U, receiver_.RtcpSent().fir_packets); 332 // Receive module sends a FIR. 333 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir)); 334 EXPECT_EQ(1U, receiver_.RtcpSent().fir_packets); 335 // Send module receives the FIR. 336 EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets); 337 338 // Receive module sends a FIR and PLI. 339 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli)); 340 EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets); 341 EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets); 342 // Send module receives the FIR and PLI. 343 EXPECT_EQ(2U, sender_.RtcpReceived().fir_packets); 344 EXPECT_EQ(1U, sender_.RtcpReceived().pli_packets); 345} 346 347class RtpSendingTestTransport : public Transport { 348 public: 349 void ResetCounters() { bytes_received_.clear(); } 350 351 virtual int SendPacket(int channel, const void* data, int length) { 352 RTPHeader header; 353 scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); 354 EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), 355 static_cast<size_t>(length), 356 &header)); 357 bytes_received_[header.ssrc] += length; 358 ++packets_received_[header.ssrc]; 359 return length; 360 } 361 362 virtual int SendRTCPPacket(int channel, const void* data, int length) { 363 return length; 364 } 365 366 int GetPacketsReceived(uint32_t ssrc) const { 367 std::map<uint32_t, int>::const_iterator it = packets_received_.find(ssrc); 368 if (it == packets_received_.end()) 369 return 0; 370 return it->second; 371 } 372 373 int GetBytesReceived(uint32_t ssrc) const { 374 std::map<uint32_t, int>::const_iterator it = bytes_received_.find(ssrc); 375 if (it == bytes_received_.end()) 376 return 0; 377 return it->second; 378 } 379 380 int GetTotalBytesReceived() const { 381 int sum = 0; 382 for (std::map<uint32_t, int>::const_iterator it = bytes_received_.begin(); 383 it != bytes_received_.end(); 384 ++it) { 385 sum += it->second; 386 } 387 return sum; 388 } 389 390 private: 391 std::map<uint32_t, int> bytes_received_; 392 std::map<uint32_t, int> packets_received_; 393}; 394 395class RtpSendingTest : public ::testing::Test { 396 protected: 397 // Map from SSRC to number of received packets and bytes. 398 typedef std::map<uint32_t, std::pair<int, int> > PaddingMap; 399 400 RtpSendingTest() { 401 // Send module. 402 RtpRtcp::Configuration config; 403 config.audio = false; 404 config.clock = Clock::GetRealTimeClock(); 405 config.outgoing_transport = &transport_; 406 config.receive_statistics = receive_statistics_.get(); 407 config.rtt_stats = &rtt_stats_; 408 config.paced_sender = &pacer_; 409 memset(&codec_, 0, sizeof(VideoCodec)); 410 codec_.plType = 100; 411 strncpy(codec_.plName, "VP8", 3); 412 codec_.numberOfSimulcastStreams = 3; 413 codec_.simulcastStream[0].width = 320; 414 codec_.simulcastStream[0].height = 180; 415 codec_.simulcastStream[0].maxBitrate = 300; 416 codec_.simulcastStream[1].width = 640; 417 codec_.simulcastStream[1].height = 360; 418 codec_.simulcastStream[1].maxBitrate = 600; 419 codec_.simulcastStream[2].width = 1280; 420 codec_.simulcastStream[2].height = 720; 421 codec_.simulcastStream[2].maxBitrate = 1200; 422 // We need numberOfSimulcastStreams + 1 RTP modules since we need one 423 // default module. 424 for (int i = 0; i < codec_.numberOfSimulcastStreams + 1; ++i) { 425 RtpRtcp* sender = RtpRtcp::CreateRtpRtcp(config); 426 EXPECT_EQ(0, sender->RegisterSendPayload(codec_)); 427 EXPECT_EQ(0, sender->SetSendingStatus(true)); 428 EXPECT_EQ(0, sender->SetSendingMediaStatus(true)); 429 sender->SetSSRC(kSenderSsrc + i); 430 sender->SetRemoteSSRC(kReceiverSsrc + i); 431 senders_.push_back(sender); 432 config.default_module = senders_[0]; 433 } 434 std::vector<uint32_t> bitrates; 435 bitrates.push_back(codec_.simulcastStream[0].maxBitrate); 436 bitrates.push_back(codec_.simulcastStream[1].maxBitrate); 437 bitrates.push_back(codec_.simulcastStream[2].maxBitrate); 438 senders_[0]->SetTargetSendBitrate(bitrates); 439 } 440 441 ~RtpSendingTest() { 442 for (int i = senders_.size() - 1; i >= 0; --i) { 443 delete senders_[i]; 444 } 445 } 446 447 void SendFrameOnSender(int sender_index, 448 const uint8_t* payload, 449 size_t length) { 450 RTPVideoHeader rtp_video_header = { 451 codec_.simulcastStream[sender_index].width, 452 codec_.simulcastStream[sender_index].height, 453 true, 454 0, 455 kRtpVideoVp8, 456 {}}; 457 uint32_t seq_num = 0; 458 uint32_t ssrc = 0; 459 int64_t capture_time_ms = 0; 460 bool retransmission = false; 461 EXPECT_CALL(pacer_, SendPacket(_, _, _, _, _, _)) 462 .WillRepeatedly(DoAll(SaveArg<1>(&ssrc), 463 SaveArg<2>(&seq_num), 464 SaveArg<3>(&capture_time_ms), 465 SaveArg<5>(&retransmission), 466 Return(true))); 467 EXPECT_EQ(0, 468 senders_[sender_index]->SendOutgoingData(kVideoFrameKey, 469 codec_.plType, 470 0, 471 0, 472 payload, 473 length, 474 NULL, 475 &rtp_video_header)); 476 EXPECT_TRUE(senders_[sender_index]->TimeToSendPacket( 477 ssrc, seq_num, capture_time_ms, retransmission)); 478 } 479 480 void ExpectPadding(const PaddingMap& expected_padding) { 481 int expected_total_bytes = 0; 482 for (PaddingMap::const_iterator it = expected_padding.begin(); 483 it != expected_padding.end(); 484 ++it) { 485 int packets_received = transport_.GetBytesReceived(it->first); 486 if (it->second.first > 0) { 487 EXPECT_GE(packets_received, it->second.first) 488 << "On SSRC: " << it->first; 489 } 490 int bytes_received = transport_.GetBytesReceived(it->first); 491 expected_total_bytes += bytes_received; 492 if (it->second.second > 0) { 493 EXPECT_GE(bytes_received, it->second.second) 494 << "On SSRC: " << it->first; 495 } else { 496 EXPECT_EQ(0, bytes_received) << "On SSRC: " << it->first; 497 } 498 } 499 EXPECT_EQ(expected_total_bytes, transport_.GetTotalBytesReceived()); 500 } 501 502 scoped_ptr<ReceiveStatistics> receive_statistics_; 503 RtcpRttStatsTestImpl rtt_stats_; 504 std::vector<RtpRtcp*> senders_; 505 RtpSendingTestTransport transport_; 506 NiceMock<MockPacedSender> pacer_; 507 VideoCodec codec_; 508}; 509 510TEST_F(RtpSendingTest, DISABLED_RoundRobinPadding) { 511 // We have to send on an SSRC to be allowed to pad, since a marker bit must 512 // be sent prior to padding packets. 513 const uint8_t payload[200] = {0}; 514 for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) { 515 SendFrameOnSender(i + 1, payload, sizeof(payload)); 516 } 517 transport_.ResetCounters(); 518 senders_[0]->TimeToSendPadding(500); 519 PaddingMap expected_padding; 520 expected_padding[kSenderSsrc + 1] = std::make_pair(2, 500); 521 expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0); 522 expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0); 523 ExpectPadding(expected_padding); 524 senders_[0]->TimeToSendPadding(1000); 525 expected_padding[kSenderSsrc + 2] = std::make_pair(4, 1000); 526 ExpectPadding(expected_padding); 527 senders_[0]->TimeToSendPadding(1500); 528 expected_padding[kSenderSsrc + 3] = std::make_pair(6, 1500); 529 ExpectPadding(expected_padding); 530} 531 532TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtx) { 533 // Enable RTX to allow padding to be sent prior to media. 534 for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) { 535 // Abs-send-time is needed to be allowed to send padding prior to media, 536 // as otherwise the timestmap used for BWE will be broken. 537 senders_[i]->RegisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 538 1); 539 senders_[i]->SetRtxSendPayloadType(96); 540 senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i); 541 senders_[i]->SetRTXSendStatus(kRtxRetransmitted); 542 } 543 transport_.ResetCounters(); 544 senders_[0]->TimeToSendPadding(500); 545 PaddingMap expected_padding; 546 expected_padding[kSenderSsrc + 1] = std::make_pair(0, 0); 547 expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0); 548 expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0); 549 expected_padding[kSenderRtxSsrc + 1] = std::make_pair(2, 500); 550 expected_padding[kSenderRtxSsrc + 2] = std::make_pair(0, 0); 551 expected_padding[kSenderRtxSsrc + 3] = std::make_pair(0, 0); 552 ExpectPadding(expected_padding); 553 senders_[0]->TimeToSendPadding(1000); 554 expected_padding[kSenderRtxSsrc + 2] = std::make_pair(4, 500); 555 ExpectPadding(expected_padding); 556 senders_[0]->TimeToSendPadding(1500); 557 558 expected_padding[kSenderRtxSsrc + 3] = std::make_pair(6, 500); 559 ExpectPadding(expected_padding); 560} 561 562TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtxRedundantPayloads) { 563 for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) { 564 senders_[i]->SetRtxSendPayloadType(96); 565 senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i); 566 senders_[i]->SetRTXSendStatus(kRtxRetransmitted | kRtxRedundantPayloads); 567 senders_[i]->SetStorePacketsStatus(true, 100); 568 } 569 // First send payloads so that we have something to retransmit. 570 const size_t kPayloadSize = 500; 571 const uint8_t payload[kPayloadSize] = {0}; 572 for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) { 573 SendFrameOnSender(i + 1, payload, sizeof(payload)); 574 } 575 transport_.ResetCounters(); 576 senders_[0]->TimeToSendPadding(500); 577 PaddingMap expected_padding; 578 expected_padding[kSenderSsrc + 1] = std::make_pair<int, int>(0, 0); 579 expected_padding[kSenderSsrc + 2] = std::make_pair<int, int>(0, 0); 580 expected_padding[kSenderSsrc + 3] = std::make_pair<int, int>(0, 0); 581 expected_padding[kSenderRtxSsrc + 1] = std::make_pair<int, int>(1, 500); 582 expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(0, 0); 583 expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(0, 0); 584 ExpectPadding(expected_padding); 585 senders_[0]->TimeToSendPadding(1000); 586 expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(2, 1000); 587 ExpectPadding(expected_padding); 588 senders_[0]->TimeToSendPadding(1500); 589 expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(3, 1500); 590 ExpectPadding(expected_padding); 591} 592} // namespace webrtc 593