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