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 #include <assert.h> 11 12 #include <algorithm> 13 #include <map> 14 #include <sstream> 15 #include <string> 16 17 #include "testing/gtest/include/gtest/gtest.h" 18 19 #include "webrtc/call.h" 20 #include "webrtc/frame_callback.h" 21 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" 22 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" 23 #include "webrtc/system_wrappers/interface/event_wrapper.h" 24 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 25 #include "webrtc/system_wrappers/interface/sleep.h" 26 #include "webrtc/test/call_test.h" 27 #include "webrtc/test/direct_transport.h" 28 #include "webrtc/test/encoder_settings.h" 29 #include "webrtc/test/fake_audio_device.h" 30 #include "webrtc/test/fake_decoder.h" 31 #include "webrtc/test/fake_encoder.h" 32 #include "webrtc/test/frame_generator.h" 33 #include "webrtc/test/frame_generator_capturer.h" 34 #include "webrtc/test/null_transport.h" 35 #include "webrtc/test/rtp_rtcp_observer.h" 36 #include "webrtc/test/testsupport/fileutils.h" 37 #include "webrtc/test/testsupport/gtest_disable.h" 38 #include "webrtc/test/testsupport/perf_test.h" 39 #include "webrtc/video/transport_adapter.h" 40 #include "webrtc/video_encoder.h" 41 42 namespace webrtc { 43 44 static const unsigned long kSilenceTimeoutMs = 2000; 45 46 class EndToEndTest : public test::CallTest { 47 public: 48 EndToEndTest() {} 49 50 virtual ~EndToEndTest() { 51 EXPECT_EQ(NULL, send_stream_); 52 EXPECT_TRUE(receive_streams_.empty()); 53 } 54 55 protected: 56 class UnusedTransport : public newapi::Transport { 57 private: 58 virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE { 59 ADD_FAILURE() << "Unexpected RTP sent."; 60 return false; 61 } 62 63 virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 64 ADD_FAILURE() << "Unexpected RTCP sent."; 65 return false; 66 } 67 }; 68 69 void DecodesRetransmittedFrame(bool retransmit_over_rtx); 70 void ReceivesPliAndRecovers(int rtp_history_ms); 71 void RespectsRtcpMode(newapi::RtcpMode rtcp_mode); 72 void TestXrReceiverReferenceTimeReport(bool enable_rrtr); 73 void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first); 74 void TestRtpStatePreservation(bool use_rtx); 75 }; 76 77 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) { 78 test::NullTransport transport; 79 CreateCalls(Call::Config(&transport), Call::Config(&transport)); 80 81 CreateSendConfig(1); 82 CreateMatchingReceiveConfigs(); 83 84 CreateStreams(); 85 86 receive_streams_[0]->Start(); 87 receive_streams_[0]->Start(); 88 89 DestroyStreams(); 90 } 91 92 TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) { 93 test::NullTransport transport; 94 CreateCalls(Call::Config(&transport), Call::Config(&transport)); 95 96 CreateSendConfig(1); 97 CreateMatchingReceiveConfigs(); 98 99 CreateStreams(); 100 101 receive_streams_[0]->Stop(); 102 receive_streams_[0]->Stop(); 103 104 DestroyStreams(); 105 } 106 107 TEST_F(EndToEndTest, RendersSingleDelayedFrame) { 108 static const int kWidth = 320; 109 static const int kHeight = 240; 110 // This constant is chosen to be higher than the timeout in the video_render 111 // module. This makes sure that frames aren't dropped if there are no other 112 // frames in the queue. 113 static const int kDelayRenderCallbackMs = 1000; 114 115 class Renderer : public VideoRenderer { 116 public: 117 Renderer() : event_(EventWrapper::Create()) {} 118 119 virtual void RenderFrame(const I420VideoFrame& video_frame, 120 int /*time_to_render_ms*/) OVERRIDE { 121 event_->Set(); 122 } 123 124 EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } 125 126 scoped_ptr<EventWrapper> event_; 127 } renderer; 128 129 class TestFrameCallback : public I420FrameCallback { 130 public: 131 TestFrameCallback() : event_(EventWrapper::Create()) {} 132 133 EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } 134 135 private: 136 virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE { 137 SleepMs(kDelayRenderCallbackMs); 138 event_->Set(); 139 } 140 141 scoped_ptr<EventWrapper> event_; 142 }; 143 144 test::DirectTransport sender_transport, receiver_transport; 145 146 CreateCalls(Call::Config(&sender_transport), 147 Call::Config(&receiver_transport)); 148 149 sender_transport.SetReceiver(receiver_call_->Receiver()); 150 receiver_transport.SetReceiver(sender_call_->Receiver()); 151 152 CreateSendConfig(1); 153 CreateMatchingReceiveConfigs(); 154 155 TestFrameCallback pre_render_callback; 156 receive_configs_[0].pre_render_callback = &pre_render_callback; 157 receive_configs_[0].renderer = &renderer; 158 159 CreateStreams(); 160 Start(); 161 162 // Create frames that are smaller than the send width/height, this is done to 163 // check that the callbacks are done after processing video. 164 scoped_ptr<test::FrameGenerator> frame_generator( 165 test::FrameGenerator::Create(kWidth, kHeight)); 166 send_stream_->Input()->SwapFrame(frame_generator->NextFrame()); 167 EXPECT_EQ(kEventSignaled, pre_render_callback.Wait()) 168 << "Timed out while waiting for pre-render callback."; 169 EXPECT_EQ(kEventSignaled, renderer.Wait()) 170 << "Timed out while waiting for the frame to render."; 171 172 Stop(); 173 174 sender_transport.StopSending(); 175 receiver_transport.StopSending(); 176 177 DestroyStreams(); 178 } 179 180 TEST_F(EndToEndTest, TransmitsFirstFrame) { 181 class Renderer : public VideoRenderer { 182 public: 183 Renderer() : event_(EventWrapper::Create()) {} 184 185 virtual void RenderFrame(const I420VideoFrame& video_frame, 186 int /*time_to_render_ms*/) OVERRIDE { 187 event_->Set(); 188 } 189 190 EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } 191 192 scoped_ptr<EventWrapper> event_; 193 } renderer; 194 195 test::DirectTransport sender_transport, receiver_transport; 196 197 CreateCalls(Call::Config(&sender_transport), 198 Call::Config(&receiver_transport)); 199 200 sender_transport.SetReceiver(receiver_call_->Receiver()); 201 receiver_transport.SetReceiver(sender_call_->Receiver()); 202 203 CreateSendConfig(1); 204 CreateMatchingReceiveConfigs(); 205 receive_configs_[0].renderer = &renderer; 206 207 CreateStreams(); 208 Start(); 209 210 scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create( 211 encoder_config_.streams[0].width, encoder_config_.streams[0].height)); 212 send_stream_->Input()->SwapFrame(frame_generator->NextFrame()); 213 214 EXPECT_EQ(kEventSignaled, renderer.Wait()) 215 << "Timed out while waiting for the frame to render."; 216 217 Stop(); 218 219 sender_transport.StopSending(); 220 receiver_transport.StopSending(); 221 222 DestroyStreams(); 223 } 224 225 TEST_F(EndToEndTest, SendsAndReceivesH264) { 226 class H264Observer : public test::EndToEndTest, public VideoRenderer { 227 public: 228 H264Observer() 229 : EndToEndTest(2 * kDefaultTimeoutMs), 230 fake_encoder_(Clock::GetRealTimeClock()), 231 frame_counter_(0) {} 232 233 virtual void PerformTest() OVERRIDE { 234 EXPECT_EQ(kEventSignaled, Wait()) 235 << "Timed out while waiting for enough frames to be decoded."; 236 } 237 238 virtual void ModifyConfigs( 239 VideoSendStream::Config* send_config, 240 std::vector<VideoReceiveStream::Config>* receive_configs, 241 VideoEncoderConfig* encoder_config) OVERRIDE { 242 send_config->encoder_settings.encoder = &fake_encoder_; 243 send_config->encoder_settings.payload_name = "H264"; 244 send_config->encoder_settings.payload_type = kFakeSendPayloadType; 245 encoder_config->streams[0].min_bitrate_bps = 50000; 246 encoder_config->streams[0].target_bitrate_bps = 247 encoder_config->streams[0].max_bitrate_bps = 2000000; 248 249 (*receive_configs)[0].renderer = this; 250 VideoCodec codec = 251 test::CreateDecoderVideoCodec(send_config->encoder_settings); 252 (*receive_configs)[0].codecs.resize(1); 253 (*receive_configs)[0].codecs[0] = codec; 254 (*receive_configs)[0].external_decoders.resize(1); 255 (*receive_configs)[0].external_decoders[0].payload_type = 256 send_config->encoder_settings.payload_type; 257 (*receive_configs)[0].external_decoders[0].decoder = &fake_decoder_; 258 } 259 260 virtual void RenderFrame(const I420VideoFrame& video_frame, 261 int time_to_render_ms) OVERRIDE { 262 const int kRequiredFrames = 500; 263 if (++frame_counter_ == kRequiredFrames) 264 observation_complete_->Set(); 265 } 266 267 private: 268 test::FakeH264Decoder fake_decoder_; 269 test::FakeH264Encoder fake_encoder_; 270 int frame_counter_; 271 } test; 272 273 RunBaseTest(&test); 274 } 275 276 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) { 277 class SyncRtcpObserver : public test::EndToEndTest { 278 public: 279 SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {} 280 281 virtual Action OnReceiveRtcp(const uint8_t* packet, 282 size_t length) OVERRIDE { 283 RTCPUtility::RTCPParserV2 parser(packet, length, true); 284 EXPECT_TRUE(parser.IsValid()); 285 uint32_t ssrc = 0; 286 ssrc |= static_cast<uint32_t>(packet[4]) << 24; 287 ssrc |= static_cast<uint32_t>(packet[5]) << 16; 288 ssrc |= static_cast<uint32_t>(packet[6]) << 8; 289 ssrc |= static_cast<uint32_t>(packet[7]) << 0; 290 EXPECT_EQ(kReceiverLocalSsrc, ssrc); 291 observation_complete_->Set(); 292 293 return SEND_PACKET; 294 } 295 296 virtual void PerformTest() OVERRIDE { 297 EXPECT_EQ(kEventSignaled, Wait()) 298 << "Timed out while waiting for a receiver RTCP packet to be sent."; 299 } 300 } test; 301 302 RunBaseTest(&test); 303 } 304 305 TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) { 306 static const int kNumberOfNacksToObserve = 2; 307 static const int kLossBurstSize = 2; 308 static const int kPacketsBetweenLossBursts = 9; 309 class NackObserver : public test::EndToEndTest { 310 public: 311 NackObserver() 312 : EndToEndTest(kLongTimeoutMs), 313 rtp_parser_(RtpHeaderParser::Create()), 314 sent_rtp_packets_(0), 315 packets_left_to_drop_(0), 316 nacks_left_(kNumberOfNacksToObserve) {} 317 318 private: 319 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 320 RTPHeader header; 321 EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); 322 323 // Never drop retransmitted packets. 324 if (dropped_packets_.find(header.sequenceNumber) != 325 dropped_packets_.end()) { 326 retransmitted_packets_.insert(header.sequenceNumber); 327 if (nacks_left_ == 0 && 328 retransmitted_packets_.size() == dropped_packets_.size()) { 329 observation_complete_->Set(); 330 } 331 return SEND_PACKET; 332 } 333 334 ++sent_rtp_packets_; 335 336 // Enough NACKs received, stop dropping packets. 337 if (nacks_left_ == 0) 338 return SEND_PACKET; 339 340 // Check if it's time for a new loss burst. 341 if (sent_rtp_packets_ % kPacketsBetweenLossBursts == 0) 342 packets_left_to_drop_ = kLossBurstSize; 343 344 if (packets_left_to_drop_ > 0) { 345 --packets_left_to_drop_; 346 dropped_packets_.insert(header.sequenceNumber); 347 return DROP_PACKET; 348 } 349 350 return SEND_PACKET; 351 } 352 353 virtual Action OnReceiveRtcp(const uint8_t* packet, 354 size_t length) OVERRIDE { 355 RTCPUtility::RTCPParserV2 parser(packet, length, true); 356 EXPECT_TRUE(parser.IsValid()); 357 358 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 359 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 360 if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) { 361 --nacks_left_; 362 break; 363 } 364 packet_type = parser.Iterate(); 365 } 366 return SEND_PACKET; 367 } 368 369 virtual void ModifyConfigs( 370 VideoSendStream::Config* send_config, 371 std::vector<VideoReceiveStream::Config>* receive_configs, 372 VideoEncoderConfig* encoder_config) OVERRIDE { 373 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 374 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 375 } 376 377 virtual void PerformTest() OVERRIDE { 378 EXPECT_EQ(kEventSignaled, Wait()) 379 << "Timed out waiting for packets to be NACKed, retransmitted and " 380 "rendered."; 381 } 382 383 scoped_ptr<RtpHeaderParser> rtp_parser_; 384 std::set<uint16_t> dropped_packets_; 385 std::set<uint16_t> retransmitted_packets_; 386 uint64_t sent_rtp_packets_; 387 int packets_left_to_drop_; 388 int nacks_left_; 389 } test; 390 391 RunBaseTest(&test); 392 } 393 394 // TODO(pbos): Flaky, webrtc:3269 395 TEST_F(EndToEndTest, DISABLED_CanReceiveFec) { 396 class FecRenderObserver : public test::EndToEndTest, public VideoRenderer { 397 public: 398 FecRenderObserver() 399 : EndToEndTest(kDefaultTimeoutMs), 400 state_(kFirstPacket), 401 protected_sequence_number_(0), 402 protected_frame_timestamp_(0) {} 403 404 private: 405 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE 406 EXCLUSIVE_LOCKS_REQUIRED(crit_) { 407 RTPHeader header; 408 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 409 410 EXPECT_EQ(kRedPayloadType, header.payloadType); 411 int encapsulated_payload_type = 412 static_cast<int>(packet[header.headerLength]); 413 if (encapsulated_payload_type != kFakeSendPayloadType) 414 EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type); 415 416 switch (state_) { 417 case kFirstPacket: 418 state_ = kDropEveryOtherPacketUntilFec; 419 break; 420 case kDropEveryOtherPacketUntilFec: 421 if (encapsulated_payload_type == kUlpfecPayloadType) { 422 state_ = kDropNextMediaPacket; 423 return SEND_PACKET; 424 } 425 if (header.sequenceNumber % 2 == 0) 426 return DROP_PACKET; 427 break; 428 case kDropNextMediaPacket: 429 if (encapsulated_payload_type == kFakeSendPayloadType) { 430 protected_sequence_number_ = header.sequenceNumber; 431 protected_frame_timestamp_ = header.timestamp; 432 state_ = kProtectedPacketDropped; 433 return DROP_PACKET; 434 } 435 break; 436 case kProtectedPacketDropped: 437 EXPECT_NE(header.sequenceNumber, protected_sequence_number_) 438 << "Protected packet retransmitted. Should not happen with FEC."; 439 break; 440 } 441 442 return SEND_PACKET; 443 } 444 445 virtual void RenderFrame(const I420VideoFrame& video_frame, 446 int time_to_render_ms) OVERRIDE { 447 CriticalSectionScoped lock(crit_.get()); 448 // Rendering frame with timestamp associated with dropped packet -> FEC 449 // protection worked. 450 if (state_ == kProtectedPacketDropped && 451 video_frame.timestamp() == protected_frame_timestamp_) { 452 observation_complete_->Set(); 453 } 454 } 455 456 enum { 457 kFirstPacket, 458 kDropEveryOtherPacketUntilFec, 459 kDropNextMediaPacket, 460 kProtectedPacketDropped, 461 } state_; 462 463 virtual void ModifyConfigs( 464 VideoSendStream::Config* send_config, 465 std::vector<VideoReceiveStream::Config>* receive_configs, 466 VideoEncoderConfig* encoder_config) OVERRIDE { 467 // TODO(pbos): Run this test with combined NACK/FEC enabled as well. 468 // int rtp_history_ms = 1000; 469 // (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms; 470 // send_config->rtp.nack.rtp_history_ms = rtp_history_ms; 471 send_config->rtp.fec.red_payload_type = kRedPayloadType; 472 send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; 473 474 (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType; 475 (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; 476 (*receive_configs)[0].renderer = this; 477 } 478 479 virtual void PerformTest() OVERRIDE { 480 EXPECT_EQ(kEventSignaled, Wait()) 481 << "Timed out while waiting for retransmitted NACKed frames to be " 482 "rendered again."; 483 } 484 485 uint32_t protected_sequence_number_ GUARDED_BY(crit_); 486 uint32_t protected_frame_timestamp_ GUARDED_BY(crit_); 487 } test; 488 489 RunBaseTest(&test); 490 } 491 492 // This test drops second RTP packet with a marker bit set, makes sure it's 493 // retransmitted and renders. Retransmission SSRCs are also checked. 494 void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { 495 static const int kDroppedFrameNumber = 2; 496 class RetransmissionObserver : public test::EndToEndTest, 497 public I420FrameCallback { 498 public: 499 explicit RetransmissionObserver(bool expect_rtx) 500 : EndToEndTest(kDefaultTimeoutMs), 501 retransmission_ssrc_(expect_rtx ? kSendRtxSsrcs[0] : kSendSsrcs[0]), 502 retransmission_payload_type_(expect_rtx ? kSendRtxPayloadType 503 : kFakeSendPayloadType), 504 marker_bits_observed_(0), 505 retransmitted_timestamp_(0), 506 frame_retransmitted_(false) {} 507 508 private: 509 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 510 RTPHeader header; 511 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 512 513 if (header.timestamp == retransmitted_timestamp_) { 514 EXPECT_EQ(retransmission_ssrc_, header.ssrc); 515 EXPECT_EQ(retransmission_payload_type_, header.payloadType); 516 frame_retransmitted_ = true; 517 return SEND_PACKET; 518 } 519 520 EXPECT_EQ(kSendSsrcs[0], header.ssrc); 521 EXPECT_EQ(kFakeSendPayloadType, header.payloadType); 522 523 // Found the second frame's final packet, drop this and expect a 524 // retransmission. 525 if (header.markerBit && ++marker_bits_observed_ == kDroppedFrameNumber) { 526 retransmitted_timestamp_ = header.timestamp; 527 return DROP_PACKET; 528 } 529 530 return SEND_PACKET; 531 } 532 533 virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE { 534 CriticalSectionScoped lock(crit_.get()); 535 if (frame->timestamp() == retransmitted_timestamp_) { 536 EXPECT_TRUE(frame_retransmitted_); 537 observation_complete_->Set(); 538 } 539 } 540 541 virtual void ModifyConfigs( 542 VideoSendStream::Config* send_config, 543 std::vector<VideoReceiveStream::Config>* receive_configs, 544 VideoEncoderConfig* encoder_config) OVERRIDE { 545 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 546 (*receive_configs)[0].pre_render_callback = this; 547 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 548 if (retransmission_ssrc_ == kSendRtxSsrcs[0]) { 549 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); 550 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; 551 (*receive_configs)[0].rtp.rtx[kSendRtxPayloadType].ssrc = 552 kSendRtxSsrcs[0]; 553 (*receive_configs)[0].rtp.rtx[kSendRtxPayloadType].payload_type = 554 kSendRtxPayloadType; 555 } 556 } 557 558 virtual void PerformTest() OVERRIDE { 559 EXPECT_EQ(kEventSignaled, Wait()) 560 << "Timed out while waiting for retransmission to render."; 561 } 562 563 const uint32_t retransmission_ssrc_; 564 const int retransmission_payload_type_; 565 int marker_bits_observed_; 566 uint32_t retransmitted_timestamp_; 567 bool frame_retransmitted_; 568 } test(retransmit_over_rtx); 569 570 RunBaseTest(&test); 571 } 572 573 TEST_F(EndToEndTest, DecodesRetransmittedFrame) { 574 DecodesRetransmittedFrame(false); 575 } 576 577 TEST_F(EndToEndTest, DecodesRetransmittedFrameOverRtx) { 578 DecodesRetransmittedFrame(true); 579 } 580 581 TEST_F(EndToEndTest, UsesFrameCallbacks) { 582 static const int kWidth = 320; 583 static const int kHeight = 240; 584 585 class Renderer : public VideoRenderer { 586 public: 587 Renderer() : event_(EventWrapper::Create()) {} 588 589 virtual void RenderFrame(const I420VideoFrame& video_frame, 590 int /*time_to_render_ms*/) OVERRIDE { 591 EXPECT_EQ(0, *video_frame.buffer(kYPlane)) 592 << "Rendered frame should have zero luma which is applied by the " 593 "pre-render callback."; 594 event_->Set(); 595 } 596 597 EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } 598 scoped_ptr<EventWrapper> event_; 599 } renderer; 600 601 class TestFrameCallback : public I420FrameCallback { 602 public: 603 TestFrameCallback(int expected_luma_byte, int next_luma_byte) 604 : event_(EventWrapper::Create()), 605 expected_luma_byte_(expected_luma_byte), 606 next_luma_byte_(next_luma_byte) {} 607 608 EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } 609 610 private: 611 virtual void FrameCallback(I420VideoFrame* frame) { 612 EXPECT_EQ(kWidth, frame->width()) 613 << "Width not as expected, callback done before resize?"; 614 EXPECT_EQ(kHeight, frame->height()) 615 << "Height not as expected, callback done before resize?"; 616 617 // Previous luma specified, observed luma should be fairly close. 618 if (expected_luma_byte_ != -1) { 619 EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10); 620 } 621 622 memset(frame->buffer(kYPlane), 623 next_luma_byte_, 624 frame->allocated_size(kYPlane)); 625 626 event_->Set(); 627 } 628 629 scoped_ptr<EventWrapper> event_; 630 int expected_luma_byte_; 631 int next_luma_byte_; 632 }; 633 634 TestFrameCallback pre_encode_callback(-1, 255); // Changes luma to 255. 635 TestFrameCallback pre_render_callback(255, 0); // Changes luma from 255 to 0. 636 637 test::DirectTransport sender_transport, receiver_transport; 638 639 CreateCalls(Call::Config(&sender_transport), 640 Call::Config(&receiver_transport)); 641 642 sender_transport.SetReceiver(receiver_call_->Receiver()); 643 receiver_transport.SetReceiver(sender_call_->Receiver()); 644 645 CreateSendConfig(1); 646 scoped_ptr<VideoEncoder> encoder( 647 VideoEncoder::Create(VideoEncoder::kVp8)); 648 send_config_.encoder_settings.encoder = encoder.get(); 649 send_config_.encoder_settings.payload_name = "VP8"; 650 ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error."; 651 encoder_config_.streams[0].width = kWidth; 652 encoder_config_.streams[0].height = kHeight; 653 send_config_.pre_encode_callback = &pre_encode_callback; 654 655 CreateMatchingReceiveConfigs(); 656 receive_configs_[0].pre_render_callback = &pre_render_callback; 657 receive_configs_[0].renderer = &renderer; 658 659 CreateStreams(); 660 Start(); 661 662 // Create frames that are smaller than the send width/height, this is done to 663 // check that the callbacks are done after processing video. 664 scoped_ptr<test::FrameGenerator> frame_generator( 665 test::FrameGenerator::Create(kWidth / 2, kHeight / 2)); 666 send_stream_->Input()->SwapFrame(frame_generator->NextFrame()); 667 668 EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait()) 669 << "Timed out while waiting for pre-encode callback."; 670 EXPECT_EQ(kEventSignaled, pre_render_callback.Wait()) 671 << "Timed out while waiting for pre-render callback."; 672 EXPECT_EQ(kEventSignaled, renderer.Wait()) 673 << "Timed out while waiting for the frame to render."; 674 675 Stop(); 676 677 sender_transport.StopSending(); 678 receiver_transport.StopSending(); 679 680 DestroyStreams(); 681 } 682 683 void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { 684 static const int kPacketsToDrop = 1; 685 686 class PliObserver : public test::EndToEndTest, public VideoRenderer { 687 public: 688 explicit PliObserver(int rtp_history_ms) 689 : EndToEndTest(kLongTimeoutMs), 690 rtp_history_ms_(rtp_history_ms), 691 nack_enabled_(rtp_history_ms > 0), 692 highest_dropped_timestamp_(0), 693 frames_to_drop_(0), 694 received_pli_(false) {} 695 696 private: 697 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 698 RTPHeader header; 699 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 700 701 // Drop all retransmitted packets to force a PLI. 702 if (header.timestamp <= highest_dropped_timestamp_) 703 return DROP_PACKET; 704 705 if (frames_to_drop_ > 0) { 706 highest_dropped_timestamp_ = header.timestamp; 707 --frames_to_drop_; 708 return DROP_PACKET; 709 } 710 711 return SEND_PACKET; 712 } 713 714 virtual Action OnReceiveRtcp(const uint8_t* packet, 715 size_t length) OVERRIDE { 716 RTCPUtility::RTCPParserV2 parser(packet, length, true); 717 EXPECT_TRUE(parser.IsValid()); 718 719 for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 720 packet_type != RTCPUtility::kRtcpNotValidCode; 721 packet_type = parser.Iterate()) { 722 if (!nack_enabled_) 723 EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode); 724 725 if (packet_type == RTCPUtility::kRtcpPsfbPliCode) { 726 received_pli_ = true; 727 break; 728 } 729 } 730 return SEND_PACKET; 731 } 732 733 virtual void RenderFrame(const I420VideoFrame& video_frame, 734 int time_to_render_ms) OVERRIDE { 735 CriticalSectionScoped lock(crit_.get()); 736 if (received_pli_ && 737 video_frame.timestamp() > highest_dropped_timestamp_) { 738 observation_complete_->Set(); 739 } 740 if (!received_pli_) 741 frames_to_drop_ = kPacketsToDrop; 742 } 743 744 virtual void ModifyConfigs( 745 VideoSendStream::Config* send_config, 746 std::vector<VideoReceiveStream::Config>* receive_configs, 747 VideoEncoderConfig* encoder_config) OVERRIDE { 748 send_config->rtp.nack.rtp_history_ms = rtp_history_ms_; 749 (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_; 750 (*receive_configs)[0].renderer = this; 751 } 752 753 virtual void PerformTest() OVERRIDE { 754 EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be " 755 "received and a frame to be " 756 "rendered afterwards."; 757 } 758 759 int rtp_history_ms_; 760 bool nack_enabled_; 761 uint32_t highest_dropped_timestamp_; 762 int frames_to_drop_; 763 bool received_pli_; 764 } test(rtp_history_ms); 765 766 RunBaseTest(&test); 767 } 768 769 TEST_F(EndToEndTest, ReceivesPliAndRecoversWithNack) { 770 ReceivesPliAndRecovers(1000); 771 } 772 773 // TODO(pbos): Enable this when 2250 is resolved. 774 TEST_F(EndToEndTest, DISABLED_ReceivesPliAndRecoversWithoutNack) { 775 ReceivesPliAndRecovers(0); 776 } 777 778 TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) { 779 class PacketInputObserver : public PacketReceiver { 780 public: 781 explicit PacketInputObserver(PacketReceiver* receiver) 782 : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {} 783 784 EventTypeWrapper Wait() { 785 return delivered_packet_->Wait(kDefaultTimeoutMs); 786 } 787 788 private: 789 virtual DeliveryStatus DeliverPacket(const uint8_t* packet, 790 size_t length) OVERRIDE { 791 if (RtpHeaderParser::IsRtcp(packet, length)) { 792 return receiver_->DeliverPacket(packet, length); 793 } else { 794 DeliveryStatus delivery_status = 795 receiver_->DeliverPacket(packet, length); 796 EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status); 797 delivered_packet_->Set(); 798 return delivery_status; 799 } 800 } 801 802 PacketReceiver* receiver_; 803 scoped_ptr<EventWrapper> delivered_packet_; 804 }; 805 806 test::DirectTransport send_transport, receive_transport; 807 808 CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport)); 809 PacketInputObserver input_observer(receiver_call_->Receiver()); 810 811 send_transport.SetReceiver(&input_observer); 812 receive_transport.SetReceiver(sender_call_->Receiver()); 813 814 CreateSendConfig(1); 815 CreateMatchingReceiveConfigs(); 816 817 CreateStreams(); 818 CreateFrameGeneratorCapturer(); 819 Start(); 820 821 receiver_call_->DestroyVideoReceiveStream(receive_streams_[0]); 822 receive_streams_.clear(); 823 824 // Wait() waits for a received packet. 825 EXPECT_EQ(kEventSignaled, input_observer.Wait()); 826 827 Stop(); 828 829 DestroyStreams(); 830 831 send_transport.StopSending(); 832 receive_transport.StopSending(); 833 } 834 835 void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) { 836 static const int kNumCompoundRtcpPacketsToObserve = 10; 837 class RtcpModeObserver : public test::EndToEndTest { 838 public: 839 explicit RtcpModeObserver(newapi::RtcpMode rtcp_mode) 840 : EndToEndTest(kDefaultTimeoutMs), 841 rtcp_mode_(rtcp_mode), 842 sent_rtp_(0), 843 sent_rtcp_(0) {} 844 845 private: 846 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 847 if (++sent_rtp_ % 3 == 0) 848 return DROP_PACKET; 849 850 return SEND_PACKET; 851 } 852 853 virtual Action OnReceiveRtcp(const uint8_t* packet, 854 size_t length) OVERRIDE { 855 ++sent_rtcp_; 856 RTCPUtility::RTCPParserV2 parser(packet, length, true); 857 EXPECT_TRUE(parser.IsValid()); 858 859 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 860 bool has_report_block = false; 861 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 862 EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type); 863 if (packet_type == RTCPUtility::kRtcpRrCode) { 864 has_report_block = true; 865 break; 866 } 867 packet_type = parser.Iterate(); 868 } 869 870 switch (rtcp_mode_) { 871 case newapi::kRtcpCompound: 872 if (!has_report_block) { 873 ADD_FAILURE() << "Received RTCP packet without receiver report for " 874 "kRtcpCompound."; 875 observation_complete_->Set(); 876 } 877 878 if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve) 879 observation_complete_->Set(); 880 881 break; 882 case newapi::kRtcpReducedSize: 883 if (!has_report_block) 884 observation_complete_->Set(); 885 break; 886 } 887 888 return SEND_PACKET; 889 } 890 891 virtual void ModifyConfigs( 892 VideoSendStream::Config* send_config, 893 std::vector<VideoReceiveStream::Config>* receive_configs, 894 VideoEncoderConfig* encoder_config) OVERRIDE { 895 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 896 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 897 (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_; 898 } 899 900 virtual void PerformTest() OVERRIDE { 901 EXPECT_EQ(kEventSignaled, Wait()) 902 << (rtcp_mode_ == newapi::kRtcpCompound 903 ? "Timed out before observing enough compound packets." 904 : "Timed out before receiving a non-compound RTCP packet."); 905 } 906 907 newapi::RtcpMode rtcp_mode_; 908 int sent_rtp_; 909 int sent_rtcp_; 910 } test(rtcp_mode); 911 912 RunBaseTest(&test); 913 } 914 915 TEST_F(EndToEndTest, UsesRtcpCompoundMode) { 916 RespectsRtcpMode(newapi::kRtcpCompound); 917 } 918 919 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) { 920 RespectsRtcpMode(newapi::kRtcpReducedSize); 921 } 922 923 // Test sets up a Call multiple senders with different resolutions and SSRCs. 924 // Another is set up to receive all three of these with different renderers. 925 // Each renderer verifies that it receives the expected resolution, and as soon 926 // as every renderer has received a frame, the test finishes. 927 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { 928 static const size_t kNumStreams = 3; 929 930 class VideoOutputObserver : public VideoRenderer { 931 public: 932 VideoOutputObserver(test::FrameGeneratorCapturer** capturer, 933 int width, 934 int height) 935 : capturer_(capturer), 936 width_(width), 937 height_(height), 938 done_(EventWrapper::Create()) {} 939 940 virtual void RenderFrame(const I420VideoFrame& video_frame, 941 int time_to_render_ms) OVERRIDE { 942 EXPECT_EQ(width_, video_frame.width()); 943 EXPECT_EQ(height_, video_frame.height()); 944 (*capturer_)->Stop(); 945 done_->Set(); 946 } 947 948 EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } 949 950 private: 951 test::FrameGeneratorCapturer** capturer_; 952 int width_; 953 int height_; 954 scoped_ptr<EventWrapper> done_; 955 }; 956 957 struct { 958 uint32_t ssrc; 959 int width; 960 int height; 961 } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}}; 962 963 test::DirectTransport sender_transport, receiver_transport; 964 scoped_ptr<Call> sender_call(Call::Create(Call::Config(&sender_transport))); 965 scoped_ptr<Call> receiver_call( 966 Call::Create(Call::Config(&receiver_transport))); 967 sender_transport.SetReceiver(receiver_call->Receiver()); 968 receiver_transport.SetReceiver(sender_call->Receiver()); 969 970 VideoSendStream* send_streams[kNumStreams]; 971 VideoReceiveStream* receive_streams[kNumStreams]; 972 973 VideoOutputObserver* observers[kNumStreams]; 974 test::FrameGeneratorCapturer* frame_generators[kNumStreams]; 975 976 scoped_ptr<VideoEncoder> encoders[kNumStreams]; 977 for (size_t i = 0; i < kNumStreams; ++i) 978 encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8)); 979 980 for (size_t i = 0; i < kNumStreams; ++i) { 981 uint32_t ssrc = codec_settings[i].ssrc; 982 int width = codec_settings[i].width; 983 int height = codec_settings[i].height; 984 observers[i] = new VideoOutputObserver(&frame_generators[i], width, height); 985 986 VideoSendStream::Config send_config; 987 send_config.rtp.ssrcs.push_back(ssrc); 988 send_config.encoder_settings.encoder = encoders[i].get(); 989 send_config.encoder_settings.payload_name = "VP8"; 990 send_config.encoder_settings.payload_type = 124; 991 VideoEncoderConfig encoder_config; 992 encoder_config.streams = test::CreateVideoStreams(1); 993 VideoStream* stream = &encoder_config.streams[0]; 994 stream->width = width; 995 stream->height = height; 996 stream->max_framerate = 5; 997 stream->min_bitrate_bps = stream->target_bitrate_bps = 998 stream->max_bitrate_bps = 100000; 999 send_streams[i] = 1000 sender_call->CreateVideoSendStream(send_config, encoder_config); 1001 send_streams[i]->Start(); 1002 1003 VideoReceiveStream::Config receive_config; 1004 receive_config.renderer = observers[i]; 1005 receive_config.rtp.remote_ssrc = ssrc; 1006 receive_config.rtp.local_ssrc = kReceiverLocalSsrc; 1007 VideoCodec codec = 1008 test::CreateDecoderVideoCodec(send_config.encoder_settings); 1009 receive_config.codecs.push_back(codec); 1010 receive_streams[i] = 1011 receiver_call->CreateVideoReceiveStream(receive_config); 1012 receive_streams[i]->Start(); 1013 1014 frame_generators[i] = test::FrameGeneratorCapturer::Create( 1015 send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock()); 1016 frame_generators[i]->Start(); 1017 } 1018 1019 for (size_t i = 0; i < kNumStreams; ++i) { 1020 EXPECT_EQ(kEventSignaled, observers[i]->Wait()) 1021 << "Timed out while waiting for observer " << i << " to render."; 1022 } 1023 1024 for (size_t i = 0; i < kNumStreams; ++i) { 1025 frame_generators[i]->Stop(); 1026 sender_call->DestroyVideoSendStream(send_streams[i]); 1027 receiver_call->DestroyVideoReceiveStream(receive_streams[i]); 1028 delete frame_generators[i]; 1029 delete observers[i]; 1030 } 1031 1032 sender_transport.StopSending(); 1033 receiver_transport.StopSending(); 1034 } 1035 1036 TEST_F(EndToEndTest, ObserversEncodedFrames) { 1037 class EncodedFrameTestObserver : public EncodedFrameObserver { 1038 public: 1039 EncodedFrameTestObserver() 1040 : length_(0), 1041 frame_type_(kFrameEmpty), 1042 called_(EventWrapper::Create()) {} 1043 virtual ~EncodedFrameTestObserver() {} 1044 1045 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { 1046 frame_type_ = encoded_frame.frame_type_; 1047 length_ = encoded_frame.length_; 1048 buffer_.reset(new uint8_t[length_]); 1049 memcpy(buffer_.get(), encoded_frame.data_, length_); 1050 called_->Set(); 1051 } 1052 1053 EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); } 1054 1055 void ExpectEqualFrames(const EncodedFrameTestObserver& observer) { 1056 ASSERT_EQ(length_, observer.length_) 1057 << "Observed frames are of different lengths."; 1058 EXPECT_EQ(frame_type_, observer.frame_type_) 1059 << "Observed frames have different frame types."; 1060 EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_)) 1061 << "Observed encoded frames have different content."; 1062 } 1063 1064 private: 1065 scoped_ptr<uint8_t[]> buffer_; 1066 size_t length_; 1067 FrameType frame_type_; 1068 scoped_ptr<EventWrapper> called_; 1069 }; 1070 1071 EncodedFrameTestObserver post_encode_observer; 1072 EncodedFrameTestObserver pre_decode_observer; 1073 1074 test::DirectTransport sender_transport, receiver_transport; 1075 1076 CreateCalls(Call::Config(&sender_transport), 1077 Call::Config(&receiver_transport)); 1078 1079 sender_transport.SetReceiver(receiver_call_->Receiver()); 1080 receiver_transport.SetReceiver(sender_call_->Receiver()); 1081 1082 CreateSendConfig(1); 1083 CreateMatchingReceiveConfigs(); 1084 send_config_.post_encode_callback = &post_encode_observer; 1085 receive_configs_[0].pre_decode_callback = &pre_decode_observer; 1086 1087 CreateStreams(); 1088 Start(); 1089 1090 scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create( 1091 encoder_config_.streams[0].width, encoder_config_.streams[0].height)); 1092 send_stream_->Input()->SwapFrame(frame_generator->NextFrame()); 1093 1094 EXPECT_EQ(kEventSignaled, post_encode_observer.Wait()) 1095 << "Timed out while waiting for send-side encoded-frame callback."; 1096 1097 EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait()) 1098 << "Timed out while waiting for pre-decode encoded-frame callback."; 1099 1100 post_encode_observer.ExpectEqualFrames(pre_decode_observer); 1101 1102 Stop(); 1103 1104 sender_transport.StopSending(); 1105 receiver_transport.StopSending(); 1106 1107 DestroyStreams(); 1108 } 1109 1110 TEST_F(EndToEndTest, ReceiveStreamSendsRemb) { 1111 class RembObserver : public test::EndToEndTest { 1112 public: 1113 RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} 1114 1115 virtual Action OnReceiveRtcp(const uint8_t* packet, 1116 size_t length) OVERRIDE { 1117 RTCPUtility::RTCPParserV2 parser(packet, length, true); 1118 EXPECT_TRUE(parser.IsValid()); 1119 1120 bool received_psfb = false; 1121 bool received_remb = false; 1122 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 1123 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 1124 if (packet_type == RTCPUtility::kRtcpPsfbRembCode) { 1125 const RTCPUtility::RTCPPacket& packet = parser.Packet(); 1126 EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc); 1127 received_psfb = true; 1128 } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) { 1129 const RTCPUtility::RTCPPacket& packet = parser.Packet(); 1130 EXPECT_GT(packet.REMBItem.BitRate, 0u); 1131 EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u); 1132 EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrcs[0]); 1133 received_remb = true; 1134 } 1135 packet_type = parser.Iterate(); 1136 } 1137 if (received_psfb && received_remb) 1138 observation_complete_->Set(); 1139 return SEND_PACKET; 1140 } 1141 virtual void PerformTest() OVERRIDE { 1142 EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a " 1143 "receiver RTCP REMB packet to be " 1144 "sent."; 1145 } 1146 } test; 1147 1148 RunBaseTest(&test); 1149 } 1150 1151 void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) { 1152 static const int kNumRtcpReportPacketsToObserve = 5; 1153 class RtcpXrObserver : public test::EndToEndTest { 1154 public: 1155 explicit RtcpXrObserver(bool enable_rrtr) 1156 : EndToEndTest(kDefaultTimeoutMs), 1157 enable_rrtr_(enable_rrtr), 1158 sent_rtcp_sr_(0), 1159 sent_rtcp_rr_(0), 1160 sent_rtcp_rrtr_(0), 1161 sent_rtcp_dlrr_(0) {} 1162 1163 private: 1164 // Receive stream should send RR packets (and RRTR packets if enabled). 1165 virtual Action OnReceiveRtcp(const uint8_t* packet, 1166 size_t length) OVERRIDE { 1167 RTCPUtility::RTCPParserV2 parser(packet, length, true); 1168 EXPECT_TRUE(parser.IsValid()); 1169 1170 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 1171 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 1172 if (packet_type == RTCPUtility::kRtcpRrCode) { 1173 ++sent_rtcp_rr_; 1174 } else if (packet_type == 1175 RTCPUtility::kRtcpXrReceiverReferenceTimeCode) { 1176 ++sent_rtcp_rrtr_; 1177 } 1178 EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode); 1179 EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode); 1180 packet_type = parser.Iterate(); 1181 } 1182 return SEND_PACKET; 1183 } 1184 // Send stream should send SR packets (and DLRR packets if enabled). 1185 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) { 1186 RTCPUtility::RTCPParserV2 parser(packet, length, true); 1187 EXPECT_TRUE(parser.IsValid()); 1188 1189 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 1190 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 1191 if (packet_type == RTCPUtility::kRtcpSrCode) { 1192 ++sent_rtcp_sr_; 1193 } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) { 1194 ++sent_rtcp_dlrr_; 1195 } 1196 EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode); 1197 packet_type = parser.Iterate(); 1198 } 1199 if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve && 1200 sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) { 1201 if (enable_rrtr_) { 1202 EXPECT_GT(sent_rtcp_rrtr_, 0); 1203 EXPECT_GT(sent_rtcp_dlrr_, 0); 1204 } else { 1205 EXPECT_EQ(0, sent_rtcp_rrtr_); 1206 EXPECT_EQ(0, sent_rtcp_dlrr_); 1207 } 1208 observation_complete_->Set(); 1209 } 1210 return SEND_PACKET; 1211 } 1212 1213 virtual void ModifyConfigs( 1214 VideoSendStream::Config* send_config, 1215 std::vector<VideoReceiveStream::Config>* receive_configs, 1216 VideoEncoderConfig* encoder_config) OVERRIDE { 1217 (*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize; 1218 (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = 1219 enable_rrtr_; 1220 } 1221 1222 virtual void PerformTest() OVERRIDE { 1223 EXPECT_EQ(kEventSignaled, Wait()) 1224 << "Timed out while waiting for RTCP SR/RR packets to be sent."; 1225 } 1226 1227 bool enable_rrtr_; 1228 int sent_rtcp_sr_; 1229 int sent_rtcp_rr_; 1230 int sent_rtcp_rrtr_; 1231 int sent_rtcp_dlrr_; 1232 } test(enable_rrtr); 1233 1234 RunBaseTest(&test); 1235 } 1236 1237 void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, 1238 bool send_single_ssrc_first) { 1239 class SendsSetSsrcs : public test::EndToEndTest { 1240 public: 1241 SendsSetSsrcs(const uint32_t* ssrcs, 1242 size_t num_ssrcs, 1243 bool send_single_ssrc_first) 1244 : EndToEndTest(kDefaultTimeoutMs), 1245 num_ssrcs_(num_ssrcs), 1246 send_single_ssrc_first_(send_single_ssrc_first), 1247 ssrcs_to_observe_(num_ssrcs), 1248 expect_single_ssrc_(send_single_ssrc_first) { 1249 for (size_t i = 0; i < num_ssrcs; ++i) 1250 valid_ssrcs_[ssrcs[i]] = true; 1251 } 1252 1253 private: 1254 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1255 RTPHeader header; 1256 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 1257 1258 EXPECT_TRUE(valid_ssrcs_[header.ssrc]) 1259 << "Received unknown SSRC: " << header.ssrc; 1260 1261 if (!valid_ssrcs_[header.ssrc]) 1262 observation_complete_->Set(); 1263 1264 if (!is_observed_[header.ssrc]) { 1265 is_observed_[header.ssrc] = true; 1266 --ssrcs_to_observe_; 1267 if (expect_single_ssrc_) { 1268 expect_single_ssrc_ = false; 1269 observation_complete_->Set(); 1270 } 1271 } 1272 1273 if (ssrcs_to_observe_ == 0) 1274 observation_complete_->Set(); 1275 1276 return SEND_PACKET; 1277 } 1278 1279 virtual size_t GetNumStreams() const OVERRIDE { return num_ssrcs_; } 1280 1281 virtual void ModifyConfigs( 1282 VideoSendStream::Config* send_config, 1283 std::vector<VideoReceiveStream::Config>* receive_configs, 1284 VideoEncoderConfig* encoder_config) OVERRIDE { 1285 if (num_ssrcs_ > 1) { 1286 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. 1287 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { 1288 encoder_config->streams[i].min_bitrate_bps = 10000; 1289 encoder_config->streams[i].target_bitrate_bps = 15000; 1290 encoder_config->streams[i].max_bitrate_bps = 20000; 1291 } 1292 } 1293 1294 encoder_config_all_streams_ = *encoder_config; 1295 if (send_single_ssrc_first_) 1296 encoder_config->streams.resize(1); 1297 } 1298 1299 virtual void OnStreamsCreated( 1300 VideoSendStream* send_stream, 1301 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1302 send_stream_ = send_stream; 1303 } 1304 1305 virtual void PerformTest() OVERRIDE { 1306 EXPECT_EQ(kEventSignaled, Wait()) 1307 << "Timed out while waiting for " 1308 << (send_single_ssrc_first_ ? "first SSRC." : "SSRCs."); 1309 1310 if (send_single_ssrc_first_) { 1311 // Set full simulcast and continue with the rest of the SSRCs. 1312 send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_); 1313 EXPECT_EQ(kEventSignaled, Wait()) 1314 << "Timed out while waiting on additional SSRCs."; 1315 } 1316 } 1317 1318 private: 1319 std::map<uint32_t, bool> valid_ssrcs_; 1320 std::map<uint32_t, bool> is_observed_; 1321 1322 const size_t num_ssrcs_; 1323 const bool send_single_ssrc_first_; 1324 1325 size_t ssrcs_to_observe_; 1326 bool expect_single_ssrc_; 1327 1328 VideoSendStream* send_stream_; 1329 VideoEncoderConfig encoder_config_all_streams_; 1330 } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first); 1331 1332 RunBaseTest(&test); 1333 } 1334 1335 TEST_F(EndToEndTest, GetStats) { 1336 class StatsObserver : public test::EndToEndTest, public I420FrameCallback { 1337 public: 1338 StatsObserver() 1339 : EndToEndTest(kLongTimeoutMs), 1340 receive_stream_(NULL), 1341 send_stream_(NULL), 1342 expected_receive_ssrc_(), 1343 expected_send_ssrcs_(), 1344 check_stats_event_(EventWrapper::Create()) {} 1345 1346 private: 1347 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1348 check_stats_event_->Set(); 1349 return SEND_PACKET; 1350 } 1351 1352 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 1353 check_stats_event_->Set(); 1354 return SEND_PACKET; 1355 } 1356 1357 virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE { 1358 check_stats_event_->Set(); 1359 return SEND_PACKET; 1360 } 1361 1362 virtual Action OnReceiveRtcp(const uint8_t* packet, 1363 size_t length) OVERRIDE { 1364 check_stats_event_->Set(); 1365 return SEND_PACKET; 1366 } 1367 1368 virtual void FrameCallback(I420VideoFrame* video_frame) OVERRIDE { 1369 // Ensure that we have at least 5ms send side delay. 1370 int64_t render_time = video_frame->render_time_ms(); 1371 if (render_time > 0) 1372 video_frame->set_render_time_ms(render_time - 5); 1373 } 1374 1375 bool CheckReceiveStats() { 1376 assert(receive_stream_ != NULL); 1377 VideoReceiveStream::Stats stats = receive_stream_->GetStats(); 1378 EXPECT_EQ(expected_receive_ssrc_, stats.ssrc); 1379 1380 // Make sure all fields have been populated. 1381 1382 receive_stats_filled_["IncomingRate"] |= 1383 stats.network_frame_rate != 0 || stats.bitrate_bps != 0; 1384 1385 receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0; 1386 1387 receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0; 1388 1389 receive_stats_filled_["StatisticsUpdated"] |= 1390 stats.rtcp_stats.cumulative_lost != 0 || 1391 stats.rtcp_stats.extended_max_sequence_number != 0 || 1392 stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0; 1393 1394 receive_stats_filled_["DataCountersUpdated"] |= 1395 stats.rtp_stats.bytes != 0 || stats.rtp_stats.fec_packets != 0 || 1396 stats.rtp_stats.header_bytes != 0 || stats.rtp_stats.packets != 0 || 1397 stats.rtp_stats.padding_bytes != 0 || 1398 stats.rtp_stats.retransmitted_packets != 0; 1399 1400 receive_stats_filled_["CodecStats"] |= 1401 stats.avg_delay_ms != 0 || stats.discarded_packets != 0 || 1402 stats.key_frames != 0 || stats.delta_frames != 0; 1403 1404 return AllStatsFilled(receive_stats_filled_); 1405 } 1406 1407 bool CheckSendStats() { 1408 assert(send_stream_ != NULL); 1409 VideoSendStream::Stats stats = send_stream_->GetStats(); 1410 1411 send_stats_filled_["NumStreams"] |= 1412 stats.substreams.size() == expected_send_ssrcs_.size(); 1413 1414 for (std::map<uint32_t, StreamStats>::const_iterator it = 1415 stats.substreams.begin(); 1416 it != stats.substreams.end(); 1417 ++it) { 1418 EXPECT_TRUE(expected_send_ssrcs_.find(it->first) != 1419 expected_send_ssrcs_.end()); 1420 1421 send_stats_filled_[CompoundKey("IncomingRate", it->first)] |= 1422 stats.input_frame_rate != 0; 1423 1424 const StreamStats& stream_stats = it->second; 1425 1426 send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |= 1427 stream_stats.rtcp_stats.cumulative_lost != 0 || 1428 stream_stats.rtcp_stats.extended_max_sequence_number != 0 || 1429 stream_stats.rtcp_stats.fraction_lost != 0; 1430 1431 send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |= 1432 stream_stats.rtp_stats.fec_packets != 0 || 1433 stream_stats.rtp_stats.padding_bytes != 0 || 1434 stream_stats.rtp_stats.retransmitted_packets != 0 || 1435 stream_stats.rtp_stats.packets != 0; 1436 1437 send_stats_filled_[CompoundKey("BitrateStatisticsObserver", 1438 it->first)] |= 1439 stream_stats.bitrate_bps != 0; 1440 1441 send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |= 1442 stream_stats.delta_frames != 0 || stream_stats.key_frames != 0; 1443 1444 send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |= 1445 stats.encode_frame_rate != 0; 1446 1447 send_stats_filled_[CompoundKey("Delay", it->first)] |= 1448 stream_stats.avg_delay_ms != 0 || stream_stats.max_delay_ms != 0; 1449 } 1450 1451 return AllStatsFilled(send_stats_filled_); 1452 } 1453 1454 std::string CompoundKey(const char* name, uint32_t ssrc) { 1455 std::ostringstream oss; 1456 oss << name << "_" << ssrc; 1457 return oss.str(); 1458 } 1459 1460 bool AllStatsFilled(const std::map<std::string, bool>& stats_map) { 1461 for (std::map<std::string, bool>::const_iterator it = stats_map.begin(); 1462 it != stats_map.end(); 1463 ++it) { 1464 if (!it->second) 1465 return false; 1466 } 1467 return true; 1468 } 1469 1470 virtual void ModifyConfigs( 1471 VideoSendStream::Config* send_config, 1472 std::vector<VideoReceiveStream::Config>* receive_configs, 1473 VideoEncoderConfig* encoder_config) OVERRIDE { 1474 send_config->pre_encode_callback = this; // Used to inject delay. 1475 send_config->rtp.c_name = "SomeCName"; 1476 1477 expected_receive_ssrc_ = (*receive_configs)[0].rtp.local_ssrc; 1478 const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs; 1479 for (size_t i = 0; i < ssrcs.size(); ++i) 1480 expected_send_ssrcs_.insert(ssrcs[i]); 1481 1482 expected_cname_ = send_config->rtp.c_name; 1483 } 1484 1485 virtual void OnStreamsCreated( 1486 VideoSendStream* send_stream, 1487 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1488 send_stream_ = send_stream; 1489 receive_stream_ = receive_streams[0]; 1490 } 1491 1492 virtual void PerformTest() OVERRIDE { 1493 Clock* clock = Clock::GetRealTimeClock(); 1494 int64_t now = clock->TimeInMilliseconds(); 1495 int64_t stop_time = now + test::CallTest::kLongTimeoutMs; 1496 bool receive_ok = false; 1497 bool send_ok = false; 1498 1499 while (now < stop_time) { 1500 if (!receive_ok) 1501 receive_ok = CheckReceiveStats(); 1502 if (!send_ok) 1503 send_ok = CheckSendStats(); 1504 1505 if (receive_ok && send_ok) 1506 return; 1507 1508 int64_t time_until_timout_ = stop_time - now; 1509 if (time_until_timout_ > 0) 1510 check_stats_event_->Wait(time_until_timout_); 1511 now = clock->TimeInMilliseconds(); 1512 } 1513 1514 ADD_FAILURE() << "Timed out waiting for filled stats."; 1515 for (std::map<std::string, bool>::const_iterator it = 1516 receive_stats_filled_.begin(); 1517 it != receive_stats_filled_.end(); 1518 ++it) { 1519 if (!it->second) { 1520 ADD_FAILURE() << "Missing receive stats: " << it->first; 1521 } 1522 } 1523 1524 for (std::map<std::string, bool>::const_iterator it = 1525 send_stats_filled_.begin(); 1526 it != send_stats_filled_.end(); 1527 ++it) { 1528 if (!it->second) { 1529 ADD_FAILURE() << "Missing send stats: " << it->first; 1530 } 1531 } 1532 } 1533 1534 VideoReceiveStream* receive_stream_; 1535 std::map<std::string, bool> receive_stats_filled_; 1536 1537 VideoSendStream* send_stream_; 1538 std::map<std::string, bool> send_stats_filled_; 1539 1540 uint32_t expected_receive_ssrc_; 1541 std::set<uint32_t> expected_send_ssrcs_; 1542 std::string expected_cname_; 1543 1544 scoped_ptr<EventWrapper> check_stats_event_; 1545 } test; 1546 1547 RunBaseTest(&test); 1548 } 1549 1550 TEST_F(EndToEndTest, ReceiverReferenceTimeReportEnabled) { 1551 TestXrReceiverReferenceTimeReport(true); 1552 } 1553 1554 TEST_F(EndToEndTest, ReceiverReferenceTimeReportDisabled) { 1555 TestXrReceiverReferenceTimeReport(false); 1556 } 1557 1558 TEST_F(EndToEndTest, TestReceivedRtpPacketStats) { 1559 static const size_t kNumRtpPacketsToSend = 5; 1560 class ReceivedRtpStatsObserver : public test::EndToEndTest { 1561 public: 1562 ReceivedRtpStatsObserver() 1563 : EndToEndTest(kDefaultTimeoutMs), 1564 receive_stream_(NULL), 1565 sent_rtp_(0) {} 1566 1567 private: 1568 virtual void OnStreamsCreated( 1569 VideoSendStream* send_stream, 1570 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1571 receive_stream_ = receive_streams[0]; 1572 } 1573 1574 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1575 if (sent_rtp_ >= kNumRtpPacketsToSend) { 1576 VideoReceiveStream::Stats stats = receive_stream_->GetStats(); 1577 if (kNumRtpPacketsToSend == stats.rtp_stats.packets) { 1578 observation_complete_->Set(); 1579 } 1580 return DROP_PACKET; 1581 } 1582 ++sent_rtp_; 1583 return SEND_PACKET; 1584 } 1585 1586 virtual void PerformTest() OVERRIDE { 1587 EXPECT_EQ(kEventSignaled, Wait()) 1588 << "Timed out while verifying number of received RTP packets."; 1589 } 1590 1591 VideoReceiveStream* receive_stream_; 1592 uint32_t sent_rtp_; 1593 } test; 1594 1595 RunBaseTest(&test); 1596 } 1597 1598 TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); } 1599 1600 TEST_F(EndToEndTest, SendsSetSimulcastSsrcs) { 1601 TestSendsSetSsrcs(kNumSsrcs, false); 1602 } 1603 1604 TEST_F(EndToEndTest, CanSwitchToUseAllSsrcs) { 1605 TestSendsSetSsrcs(kNumSsrcs, true); 1606 } 1607 1608 TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { 1609 class ObserveRedundantPayloads: public test::EndToEndTest { 1610 public: 1611 ObserveRedundantPayloads() 1612 : EndToEndTest(kDefaultTimeoutMs), ssrcs_to_observe_(kNumSsrcs) { 1613 for (size_t i = 0; i < kNumSsrcs; ++i) { 1614 registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true; 1615 } 1616 } 1617 1618 private: 1619 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1620 RTPHeader header; 1621 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 1622 1623 if (!registered_rtx_ssrc_[header.ssrc]) 1624 return SEND_PACKET; 1625 1626 EXPECT_LE(static_cast<size_t>(header.headerLength + header.paddingLength), 1627 length); 1628 const bool packet_is_redundant_payload = 1629 static_cast<size_t>(header.headerLength + header.paddingLength) < 1630 length; 1631 1632 if (!packet_is_redundant_payload) 1633 return SEND_PACKET; 1634 1635 if (!observed_redundant_retransmission_[header.ssrc]) { 1636 observed_redundant_retransmission_[header.ssrc] = true; 1637 if (--ssrcs_to_observe_ == 0) 1638 observation_complete_->Set(); 1639 } 1640 1641 return SEND_PACKET; 1642 } 1643 1644 virtual size_t GetNumStreams() const OVERRIDE { return kNumSsrcs; } 1645 1646 virtual void ModifyConfigs( 1647 VideoSendStream::Config* send_config, 1648 std::vector<VideoReceiveStream::Config>* receive_configs, 1649 VideoEncoderConfig* encoder_config) OVERRIDE { 1650 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. 1651 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { 1652 encoder_config->streams[i].min_bitrate_bps = 10000; 1653 encoder_config->streams[i].target_bitrate_bps = 15000; 1654 encoder_config->streams[i].max_bitrate_bps = 20000; 1655 } 1656 // Significantly higher than max bitrates for all video streams -> forcing 1657 // padding to trigger redundant padding on all RTX SSRCs. 1658 send_config->rtp.min_transmit_bitrate_bps = 100000; 1659 1660 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; 1661 send_config->rtp.rtx.pad_with_redundant_payloads = true; 1662 1663 for (size_t i = 0; i < kNumSsrcs; ++i) 1664 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); 1665 } 1666 1667 virtual void PerformTest() OVERRIDE { 1668 EXPECT_EQ(kEventSignaled, Wait()) 1669 << "Timed out while waiting for redundant payloads on all SSRCs."; 1670 } 1671 1672 private: 1673 size_t ssrcs_to_observe_; 1674 std::map<uint32_t, bool> observed_redundant_retransmission_; 1675 std::map<uint32_t, bool> registered_rtx_ssrc_; 1676 } test; 1677 1678 RunBaseTest(&test); 1679 } 1680 1681 void EndToEndTest::TestRtpStatePreservation(bool use_rtx) { 1682 static const uint32_t kMaxSequenceNumberGap = 100; 1683 static const uint64_t kMaxTimestampGap = kDefaultTimeoutMs * 90; 1684 class RtpSequenceObserver : public test::RtpRtcpObserver { 1685 public: 1686 explicit RtpSequenceObserver(bool use_rtx) 1687 : test::RtpRtcpObserver(kDefaultTimeoutMs), 1688 crit_(CriticalSectionWrapper::CreateCriticalSection()), 1689 ssrcs_to_observe_(kNumSsrcs) { 1690 for (size_t i = 0; i < kNumSsrcs; ++i) { 1691 configured_ssrcs_[kSendSsrcs[i]] = true; 1692 if (use_rtx) 1693 configured_ssrcs_[kSendRtxSsrcs[i]] = true; 1694 } 1695 } 1696 1697 void ResetExpectedSsrcs(size_t num_expected_ssrcs) { 1698 CriticalSectionScoped lock(crit_.get()); 1699 ssrc_observed_.clear(); 1700 ssrcs_to_observe_ = num_expected_ssrcs; 1701 } 1702 1703 private: 1704 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1705 RTPHeader header; 1706 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 1707 const uint32_t ssrc = header.ssrc; 1708 const uint16_t sequence_number = header.sequenceNumber; 1709 const uint32_t timestamp = header.timestamp; 1710 const bool only_padding = 1711 static_cast<size_t>(header.headerLength + header.paddingLength) == 1712 length; 1713 1714 EXPECT_TRUE(configured_ssrcs_[ssrc]) 1715 << "Received SSRC that wasn't configured: " << ssrc; 1716 1717 std::map<uint32_t, uint16_t>::iterator it = 1718 last_observed_sequence_number_.find(header.ssrc); 1719 if (it == last_observed_sequence_number_.end()) { 1720 last_observed_sequence_number_[ssrc] = sequence_number; 1721 last_observed_timestamp_[ssrc] = timestamp; 1722 } else { 1723 // Verify sequence numbers are reasonably close. 1724 uint32_t extended_sequence_number = sequence_number; 1725 // Check for roll-over. 1726 if (sequence_number < last_observed_sequence_number_[ssrc]) 1727 extended_sequence_number += 0xFFFFu + 1; 1728 EXPECT_LE( 1729 extended_sequence_number - last_observed_sequence_number_[ssrc], 1730 kMaxSequenceNumberGap) 1731 << "Gap in sequence numbers (" 1732 << last_observed_sequence_number_[ssrc] << " -> " << sequence_number 1733 << ") too large for SSRC: " << ssrc << "."; 1734 last_observed_sequence_number_[ssrc] = sequence_number; 1735 1736 // TODO(pbos): Remove this check if we ever have monotonically 1737 // increasing timestamps. Right now padding packets add a delta which 1738 // can cause reordering between padding packets and regular packets, 1739 // hence we drop padding-only packets to not flake. 1740 if (only_padding) { 1741 // Verify that timestamps are reasonably close. 1742 uint64_t extended_timestamp = timestamp; 1743 // Check for roll-over. 1744 if (timestamp < last_observed_timestamp_[ssrc]) 1745 extended_timestamp += static_cast<uint64_t>(0xFFFFFFFFu) + 1; 1746 EXPECT_LE(extended_timestamp - last_observed_timestamp_[ssrc], 1747 kMaxTimestampGap) 1748 << "Gap in timestamps (" << last_observed_timestamp_[ssrc] 1749 << " -> " << timestamp << ") too large for SSRC: " << ssrc << "."; 1750 } 1751 last_observed_timestamp_[ssrc] = timestamp; 1752 } 1753 1754 CriticalSectionScoped lock(crit_.get()); 1755 // Wait for media packets on all ssrcs. 1756 if (!ssrc_observed_[ssrc] && !only_padding) { 1757 ssrc_observed_[ssrc] = true; 1758 if (--ssrcs_to_observe_ == 0) 1759 observation_complete_->Set(); 1760 } 1761 1762 return SEND_PACKET; 1763 } 1764 1765 std::map<uint32_t, uint16_t> last_observed_sequence_number_; 1766 std::map<uint32_t, uint32_t> last_observed_timestamp_; 1767 std::map<uint32_t, bool> configured_ssrcs_; 1768 1769 scoped_ptr<CriticalSectionWrapper> crit_; 1770 size_t ssrcs_to_observe_ GUARDED_BY(crit_); 1771 std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_); 1772 } observer(use_rtx); 1773 1774 CreateCalls(Call::Config(observer.SendTransport()), 1775 Call::Config(observer.ReceiveTransport())); 1776 observer.SetReceivers(sender_call_->Receiver(), NULL); 1777 1778 CreateSendConfig(kNumSsrcs); 1779 1780 if (use_rtx) { 1781 for (size_t i = 0; i < kNumSsrcs; ++i) { 1782 send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); 1783 } 1784 send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; 1785 } 1786 1787 // Lower bitrates so that all streams send initially. 1788 for (size_t i = 0; i < encoder_config_.streams.size(); ++i) { 1789 encoder_config_.streams[i].min_bitrate_bps = 10000; 1790 encoder_config_.streams[i].target_bitrate_bps = 15000; 1791 encoder_config_.streams[i].max_bitrate_bps = 20000; 1792 } 1793 1794 CreateMatchingReceiveConfigs(); 1795 1796 CreateStreams(); 1797 CreateFrameGeneratorCapturer(); 1798 1799 Start(); 1800 EXPECT_EQ(kEventSignaled, observer.Wait()) 1801 << "Timed out waiting for all SSRCs to send packets."; 1802 1803 // Test stream resetting more than once to make sure that the state doesn't 1804 // get set once (this could be due to using std::map::insert for instance). 1805 for (size_t i = 0; i < 3; ++i) { 1806 frame_generator_capturer_->Stop(); 1807 sender_call_->DestroyVideoSendStream(send_stream_); 1808 1809 // Re-create VideoSendStream with only one stream. 1810 VideoEncoderConfig one_stream = encoder_config_; 1811 one_stream.streams.resize(1); 1812 send_stream_ = 1813 sender_call_->CreateVideoSendStream(send_config_, one_stream); 1814 send_stream_->Start(); 1815 CreateFrameGeneratorCapturer(); 1816 frame_generator_capturer_->Start(); 1817 1818 observer.ResetExpectedSsrcs(1); 1819 EXPECT_EQ(kEventSignaled, observer.Wait()) 1820 << "Timed out waiting for single RTP packet."; 1821 1822 // Reconfigure back to use all streams. 1823 send_stream_->ReconfigureVideoEncoder(encoder_config_); 1824 observer.ResetExpectedSsrcs(kNumSsrcs); 1825 EXPECT_EQ(kEventSignaled, observer.Wait()) 1826 << "Timed out waiting for all SSRCs to send packets."; 1827 1828 // Reconfigure down to one stream. 1829 send_stream_->ReconfigureVideoEncoder(one_stream); 1830 observer.ResetExpectedSsrcs(1); 1831 EXPECT_EQ(kEventSignaled, observer.Wait()) 1832 << "Timed out waiting for single RTP packet."; 1833 1834 // Reconfigure back to use all streams. 1835 send_stream_->ReconfigureVideoEncoder(encoder_config_); 1836 observer.ResetExpectedSsrcs(kNumSsrcs); 1837 EXPECT_EQ(kEventSignaled, observer.Wait()) 1838 << "Timed out waiting for all SSRCs to send packets."; 1839 } 1840 1841 observer.StopSending(); 1842 1843 Stop(); 1844 DestroyStreams(); 1845 } 1846 1847 TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpState) { 1848 TestRtpStatePreservation(false); 1849 } 1850 1851 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) { 1852 TestRtpStatePreservation(true); 1853 } 1854 1855 TEST_F(EndToEndTest, RespectsNetworkState) { 1856 // TODO(pbos): Remove accepted downtime packets etc. when signaling network 1857 // down blocks until no more packets will be sent. 1858 1859 // Pacer will send from its packet list and then send required padding before 1860 // checking paused_ again. This should be enough for one round of pacing, 1861 // otherwise increase. 1862 static const int kNumAcceptedDowntimeRtp = 5; 1863 // A single RTCP may be in the pipeline. 1864 static const int kNumAcceptedDowntimeRtcp = 1; 1865 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { 1866 public: 1867 NetworkStateTest() 1868 : EndToEndTest(kDefaultTimeoutMs), 1869 FakeEncoder(Clock::GetRealTimeClock()), 1870 test_crit_(CriticalSectionWrapper::CreateCriticalSection()), 1871 encoded_frames_(EventWrapper::Create()), 1872 sender_packets_(EventWrapper::Create()), 1873 receiver_packets_(EventWrapper::Create()), 1874 sender_state_(Call::kNetworkUp), 1875 down_sender_rtp_(0), 1876 down_sender_rtcp_(0), 1877 receiver_state_(Call::kNetworkUp), 1878 down_receiver_rtcp_(0), 1879 down_frames_(0) {} 1880 1881 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1882 CriticalSectionScoped lock(test_crit_.get()); 1883 if (sender_state_ == Call::kNetworkDown) { 1884 ++down_sender_rtp_; 1885 EXPECT_LE(down_sender_rtp_, kNumAcceptedDowntimeRtp) 1886 << "RTP sent during sender-side downtime."; 1887 if (down_sender_rtp_> kNumAcceptedDowntimeRtp) 1888 sender_packets_->Set(); 1889 } else { 1890 sender_packets_->Set(); 1891 } 1892 return SEND_PACKET; 1893 } 1894 1895 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 1896 CriticalSectionScoped lock(test_crit_.get()); 1897 if (sender_state_ == Call::kNetworkDown) { 1898 ++down_sender_rtcp_; 1899 EXPECT_LE(down_sender_rtcp_, kNumAcceptedDowntimeRtcp) 1900 << "RTCP sent during sender-side downtime."; 1901 if (down_sender_rtcp_ > kNumAcceptedDowntimeRtcp) 1902 sender_packets_->Set(); 1903 } else { 1904 sender_packets_->Set(); 1905 } 1906 return SEND_PACKET; 1907 } 1908 1909 virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE { 1910 ADD_FAILURE() << "Unexpected receiver RTP, should not be sending."; 1911 return SEND_PACKET; 1912 } 1913 1914 virtual Action OnReceiveRtcp(const uint8_t* packet, 1915 size_t length) OVERRIDE { 1916 CriticalSectionScoped lock(test_crit_.get()); 1917 if (receiver_state_ == Call::kNetworkDown) { 1918 ++down_receiver_rtcp_; 1919 EXPECT_LE(down_receiver_rtcp_, kNumAcceptedDowntimeRtcp) 1920 << "RTCP sent during receiver-side downtime."; 1921 if (down_receiver_rtcp_ > kNumAcceptedDowntimeRtcp) 1922 receiver_packets_->Set(); 1923 } else { 1924 receiver_packets_->Set(); 1925 } 1926 return SEND_PACKET; 1927 } 1928 1929 virtual void OnCallsCreated(Call* sender_call, 1930 Call* receiver_call) OVERRIDE { 1931 sender_call_ = sender_call; 1932 receiver_call_ = receiver_call; 1933 } 1934 1935 virtual void ModifyConfigs( 1936 VideoSendStream::Config* send_config, 1937 std::vector<VideoReceiveStream::Config>* receive_configs, 1938 VideoEncoderConfig* encoder_config) OVERRIDE { 1939 send_config->encoder_settings.encoder = this; 1940 } 1941 1942 virtual void PerformTest() OVERRIDE { 1943 EXPECT_EQ(kEventSignaled, encoded_frames_->Wait(kDefaultTimeoutMs)) 1944 << "No frames received by the encoder."; 1945 EXPECT_EQ(kEventSignaled, sender_packets_->Wait(kDefaultTimeoutMs)) 1946 << "Timed out waiting for send-side packets."; 1947 EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs)) 1948 << "Timed out waiting for receiver-side packets."; 1949 1950 // Sender-side network down. 1951 sender_call_->SignalNetworkState(Call::kNetworkDown); 1952 { 1953 CriticalSectionScoped lock(test_crit_.get()); 1954 sender_packets_->Reset(); // Earlier packets should not count. 1955 sender_state_ = Call::kNetworkDown; 1956 } 1957 EXPECT_EQ(kEventTimeout, sender_packets_->Wait(kSilenceTimeoutMs)) 1958 << "Packets sent during sender-network downtime."; 1959 EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs)) 1960 << "Timed out waiting for receiver-side packets."; 1961 // Receiver-side network down. 1962 receiver_call_->SignalNetworkState(Call::kNetworkDown); 1963 { 1964 CriticalSectionScoped lock(test_crit_.get()); 1965 receiver_packets_->Reset(); // Earlier packets should not count. 1966 receiver_state_ = Call::kNetworkDown; 1967 } 1968 EXPECT_EQ(kEventTimeout, receiver_packets_->Wait(kSilenceTimeoutMs)) 1969 << "Packets sent during receiver-network downtime."; 1970 1971 // Network back up again for both. 1972 { 1973 CriticalSectionScoped lock(test_crit_.get()); 1974 sender_packets_->Reset(); // Earlier packets should not count. 1975 receiver_packets_->Reset(); // Earlier packets should not count. 1976 sender_state_ = receiver_state_ = Call::kNetworkUp; 1977 } 1978 sender_call_->SignalNetworkState(Call::kNetworkUp); 1979 receiver_call_->SignalNetworkState(Call::kNetworkUp); 1980 EXPECT_EQ(kEventSignaled, sender_packets_->Wait(kDefaultTimeoutMs)) 1981 << "Timed out waiting for send-side packets."; 1982 EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs)) 1983 << "Timed out waiting for receiver-side packets."; 1984 } 1985 1986 virtual int32_t Encode(const I420VideoFrame& input_image, 1987 const CodecSpecificInfo* codec_specific_info, 1988 const std::vector<VideoFrameType>* frame_types) 1989 OVERRIDE { 1990 { 1991 CriticalSectionScoped lock(test_crit_.get()); 1992 if (sender_state_ == Call::kNetworkDown) { 1993 ++down_frames_; 1994 EXPECT_LE(down_frames_, 1) 1995 << "Encoding more than one frame while network is down."; 1996 if (down_frames_ > 1) 1997 encoded_frames_->Set(); 1998 } else { 1999 encoded_frames_->Set(); 2000 } 2001 } 2002 return test::FakeEncoder::Encode( 2003 input_image, codec_specific_info, frame_types); 2004 } 2005 2006 private: 2007 const scoped_ptr<CriticalSectionWrapper> test_crit_; 2008 scoped_ptr<EventWrapper> encoded_frames_; 2009 scoped_ptr<EventWrapper> sender_packets_; 2010 scoped_ptr<EventWrapper> receiver_packets_; 2011 Call* sender_call_; 2012 Call* receiver_call_; 2013 Call::NetworkState sender_state_ GUARDED_BY(test_crit_); 2014 int down_sender_rtp_ GUARDED_BY(test_crit_); 2015 int down_sender_rtcp_ GUARDED_BY(test_crit_); 2016 Call::NetworkState receiver_state_ GUARDED_BY(test_crit_); 2017 int down_receiver_rtcp_ GUARDED_BY(test_crit_); 2018 int down_frames_ GUARDED_BY(test_crit_); 2019 } test; 2020 2021 RunBaseTest(&test); 2022 } 2023 2024 TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) { 2025 class UnusedEncoder : public test::FakeEncoder { 2026 public: 2027 UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {} 2028 virtual int32_t Encode(const I420VideoFrame& input_image, 2029 const CodecSpecificInfo* codec_specific_info, 2030 const std::vector<VideoFrameType>* frame_types) 2031 OVERRIDE { 2032 ADD_FAILURE() << "Unexpected frame encode."; 2033 return test::FakeEncoder::Encode( 2034 input_image, codec_specific_info, frame_types); 2035 } 2036 }; 2037 2038 UnusedTransport transport; 2039 CreateSenderCall(Call::Config(&transport)); 2040 sender_call_->SignalNetworkState(Call::kNetworkDown); 2041 2042 CreateSendConfig(1); 2043 UnusedEncoder unused_encoder; 2044 send_config_.encoder_settings.encoder = &unused_encoder; 2045 CreateStreams(); 2046 CreateFrameGeneratorCapturer(); 2047 2048 Start(); 2049 SleepMs(kSilenceTimeoutMs); 2050 Stop(); 2051 2052 DestroyStreams(); 2053 } 2054 2055 TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) { 2056 test::DirectTransport sender_transport; 2057 CreateSenderCall(Call::Config(&sender_transport)); 2058 UnusedTransport transport; 2059 CreateReceiverCall(Call::Config(&transport)); 2060 sender_transport.SetReceiver(receiver_call_->Receiver()); 2061 2062 receiver_call_->SignalNetworkState(Call::kNetworkDown); 2063 2064 CreateSendConfig(1); 2065 CreateMatchingReceiveConfigs(); 2066 CreateStreams(); 2067 CreateFrameGeneratorCapturer(); 2068 2069 Start(); 2070 SleepMs(kSilenceTimeoutMs); 2071 Stop(); 2072 2073 sender_transport.StopSending(); 2074 2075 DestroyStreams(); 2076 } 2077 } // namespace webrtc 2078
