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 <algorithm> // max 11 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 #include "webrtc/call.h" 15 #include "webrtc/common_video/interface/i420_video_frame.h" 16 #include "webrtc/common_video/interface/native_handle.h" 17 #include "webrtc/common_video/interface/texture_video_frame.h" 18 #include "webrtc/frame_callback.h" 19 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" 20 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" 21 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" 23 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" 24 #include "webrtc/system_wrappers/interface/event_wrapper.h" 25 #include "webrtc/system_wrappers/interface/ref_count.h" 26 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 27 #include "webrtc/system_wrappers/interface/scoped_vector.h" 28 #include "webrtc/system_wrappers/interface/sleep.h" 29 #include "webrtc/system_wrappers/interface/thread_wrapper.h" 30 #include "webrtc/system_wrappers/interface/logging.h" 31 #include "webrtc/test/call_test.h" 32 #include "webrtc/test/configurable_frame_size_encoder.h" 33 #include "webrtc/test/null_transport.h" 34 #include "webrtc/test/testsupport/perf_test.h" 35 #include "webrtc/video/transport_adapter.h" 36 #include "webrtc/video_send_stream.h" 37 38 namespace webrtc { 39 40 enum VideoFormat { kGeneric, kVP8, }; 41 42 void ExpectEqualFrames(const I420VideoFrame& frame1, 43 const I420VideoFrame& frame2); 44 void ExpectEqualTextureFrames(const I420VideoFrame& frame1, 45 const I420VideoFrame& frame2); 46 void ExpectEqualBufferFrames(const I420VideoFrame& frame1, 47 const I420VideoFrame& frame2); 48 void ExpectEqualFramesVector(const std::vector<I420VideoFrame*>& frames1, 49 const std::vector<I420VideoFrame*>& frames2); 50 I420VideoFrame* CreateI420VideoFrame(int width, int height, uint8_t data); 51 52 class FakeNativeHandle : public NativeHandle { 53 public: 54 FakeNativeHandle() {} 55 virtual ~FakeNativeHandle() {} 56 virtual void* GetHandle() { return NULL; } 57 }; 58 59 class VideoSendStreamTest : public test::CallTest { 60 protected: 61 void TestNackRetransmission(uint32_t retransmit_ssrc, 62 uint8_t retransmit_payload_type); 63 void TestPacketFragmentationSize(VideoFormat format, bool with_fec); 64 }; 65 66 TEST_F(VideoSendStreamTest, CanStartStartedStream) { 67 test::NullTransport transport; 68 Call::Config call_config(&transport); 69 CreateSenderCall(call_config); 70 71 CreateSendConfig(1); 72 CreateStreams(); 73 send_stream_->Start(); 74 send_stream_->Start(); 75 DestroyStreams(); 76 } 77 78 TEST_F(VideoSendStreamTest, CanStopStoppedStream) { 79 test::NullTransport transport; 80 Call::Config call_config(&transport); 81 CreateSenderCall(call_config); 82 83 CreateSendConfig(1); 84 CreateStreams(); 85 send_stream_->Stop(); 86 send_stream_->Stop(); 87 DestroyStreams(); 88 } 89 90 TEST_F(VideoSendStreamTest, SupportsCName) { 91 static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo="; 92 class CNameObserver : public test::SendTest { 93 public: 94 CNameObserver() : SendTest(kDefaultTimeoutMs) {} 95 96 private: 97 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 98 RTCPUtility::RTCPParserV2 parser(packet, length, true); 99 EXPECT_TRUE(parser.IsValid()); 100 101 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 102 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 103 if (packet_type == RTCPUtility::kRtcpSdesChunkCode) { 104 EXPECT_EQ(parser.Packet().CName.CName, kCName); 105 observation_complete_->Set(); 106 } 107 108 packet_type = parser.Iterate(); 109 } 110 111 return SEND_PACKET; 112 } 113 114 virtual void ModifyConfigs( 115 VideoSendStream::Config* send_config, 116 std::vector<VideoReceiveStream::Config>* receive_configs, 117 VideoEncoderConfig* encoder_config) OVERRIDE { 118 send_config->rtp.c_name = kCName; 119 } 120 121 virtual void PerformTest() OVERRIDE { 122 EXPECT_EQ(kEventSignaled, Wait()) 123 << "Timed out while waiting for RTCP with CNAME."; 124 } 125 } test; 126 127 RunBaseTest(&test); 128 } 129 130 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { 131 static const uint8_t kAbsSendTimeExtensionId = 13; 132 class AbsoluteSendTimeObserver : public test::SendTest { 133 public: 134 AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) { 135 EXPECT_TRUE(parser_->RegisterRtpHeaderExtension( 136 kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId)); 137 } 138 139 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 140 RTPHeader header; 141 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 142 143 EXPECT_FALSE(header.extension.hasTransmissionTimeOffset); 144 EXPECT_TRUE(header.extension.hasAbsoluteSendTime); 145 EXPECT_EQ(header.extension.transmissionTimeOffset, 0); 146 EXPECT_GT(header.extension.absoluteSendTime, 0u); 147 observation_complete_->Set(); 148 149 return SEND_PACKET; 150 } 151 152 virtual void ModifyConfigs( 153 VideoSendStream::Config* send_config, 154 std::vector<VideoReceiveStream::Config>* receive_configs, 155 VideoEncoderConfig* encoder_config) OVERRIDE { 156 send_config->rtp.extensions.push_back( 157 RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); 158 } 159 160 virtual void PerformTest() OVERRIDE { 161 EXPECT_EQ(kEventSignaled, Wait()) 162 << "Timed out while waiting for single RTP packet."; 163 } 164 } test; 165 166 RunBaseTest(&test); 167 } 168 169 TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) { 170 static const uint8_t kTOffsetExtensionId = 13; 171 class TransmissionTimeOffsetObserver : public test::SendTest { 172 public: 173 TransmissionTimeOffsetObserver() 174 : SendTest(kDefaultTimeoutMs), encoder_(Clock::GetRealTimeClock()) { 175 EXPECT_TRUE(parser_->RegisterRtpHeaderExtension( 176 kRtpExtensionTransmissionTimeOffset, kTOffsetExtensionId)); 177 } 178 179 private: 180 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 181 RTPHeader header; 182 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 183 184 EXPECT_TRUE(header.extension.hasTransmissionTimeOffset); 185 EXPECT_FALSE(header.extension.hasAbsoluteSendTime); 186 EXPECT_GT(header.extension.transmissionTimeOffset, 0); 187 EXPECT_EQ(header.extension.absoluteSendTime, 0u); 188 observation_complete_->Set(); 189 190 return SEND_PACKET; 191 } 192 193 virtual void ModifyConfigs( 194 VideoSendStream::Config* send_config, 195 std::vector<VideoReceiveStream::Config>* receive_configs, 196 VideoEncoderConfig* encoder_config) OVERRIDE { 197 send_config->encoder_settings.encoder = &encoder_; 198 send_config->rtp.extensions.push_back( 199 RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId)); 200 } 201 202 virtual void PerformTest() OVERRIDE { 203 EXPECT_EQ(kEventSignaled, Wait()) 204 << "Timed out while waiting single RTP packet."; 205 } 206 207 class DelayedEncoder : public test::FakeEncoder { 208 public: 209 explicit DelayedEncoder(Clock* clock) : test::FakeEncoder(clock) {} 210 virtual int32_t Encode( 211 const I420VideoFrame& input_image, 212 const CodecSpecificInfo* codec_specific_info, 213 const std::vector<VideoFrameType>* frame_types) OVERRIDE { 214 // A delay needs to be introduced to assure that we get a timestamp 215 // offset. 216 SleepMs(5); 217 return FakeEncoder::Encode( 218 input_image, codec_specific_info, frame_types); 219 } 220 }; 221 222 DelayedEncoder encoder_; 223 } test; 224 225 RunBaseTest(&test); 226 } 227 228 class FakeReceiveStatistics : public NullReceiveStatistics { 229 public: 230 FakeReceiveStatistics(uint32_t send_ssrc, 231 uint32_t last_sequence_number, 232 uint32_t cumulative_lost, 233 uint8_t fraction_lost) 234 : lossy_stats_(new LossyStatistician(last_sequence_number, 235 cumulative_lost, 236 fraction_lost)) { 237 stats_map_[send_ssrc] = lossy_stats_.get(); 238 } 239 240 virtual StatisticianMap GetActiveStatisticians() const OVERRIDE { 241 return stats_map_; 242 } 243 244 virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE { 245 return lossy_stats_.get(); 246 } 247 248 private: 249 class LossyStatistician : public StreamStatistician { 250 public: 251 LossyStatistician(uint32_t extended_max_sequence_number, 252 uint32_t cumulative_lost, 253 uint8_t fraction_lost) { 254 stats_.fraction_lost = fraction_lost; 255 stats_.cumulative_lost = cumulative_lost; 256 stats_.extended_max_sequence_number = extended_max_sequence_number; 257 } 258 virtual bool GetStatistics(RtcpStatistics* statistics, 259 bool reset) OVERRIDE { 260 *statistics = stats_; 261 return true; 262 } 263 virtual void GetDataCounters(uint32_t* bytes_received, 264 uint32_t* packets_received) const OVERRIDE { 265 *bytes_received = 0; 266 *packets_received = 0; 267 } 268 virtual uint32_t BitrateReceived() const OVERRIDE { return 0; } 269 virtual void ResetStatistics() OVERRIDE {} 270 virtual bool IsRetransmitOfOldPacket(const RTPHeader& header, 271 int min_rtt) const OVERRIDE { 272 return false; 273 } 274 275 virtual bool IsPacketInOrder(uint16_t sequence_number) const OVERRIDE { 276 return true; 277 } 278 279 RtcpStatistics stats_; 280 }; 281 282 scoped_ptr<LossyStatistician> lossy_stats_; 283 StatisticianMap stats_map_; 284 }; 285 286 TEST_F(VideoSendStreamTest, SwapsI420VideoFrames) { 287 static const size_t kWidth = 320; 288 static const size_t kHeight = 240; 289 290 test::NullTransport transport; 291 Call::Config call_config(&transport); 292 CreateSenderCall(call_config); 293 294 CreateSendConfig(1); 295 CreateStreams(); 296 send_stream_->Start(); 297 298 I420VideoFrame frame; 299 frame.CreateEmptyFrame( 300 kWidth, kHeight, kWidth, (kWidth + 1) / 2, (kWidth + 1) / 2); 301 uint8_t* old_y_buffer = frame.buffer(kYPlane); 302 303 send_stream_->Input()->SwapFrame(&frame); 304 305 EXPECT_NE(frame.buffer(kYPlane), old_y_buffer); 306 307 DestroyStreams(); 308 } 309 310 TEST_F(VideoSendStreamTest, SupportsFec) { 311 class FecObserver : public test::SendTest { 312 public: 313 FecObserver() 314 : SendTest(kDefaultTimeoutMs), 315 transport_adapter_(SendTransport()), 316 send_count_(0), 317 received_media_(false), 318 received_fec_(false) { 319 transport_adapter_.Enable(); 320 } 321 322 private: 323 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 324 RTPHeader header; 325 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 326 327 // Send lossy receive reports to trigger FEC enabling. 328 if (send_count_++ % 2 != 0) { 329 // Receive statistics reporting having lost 50% of the packets. 330 FakeReceiveStatistics lossy_receive_stats( 331 kSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127); 332 RTCPSender rtcp_sender( 333 0, false, Clock::GetRealTimeClock(), &lossy_receive_stats); 334 EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_)); 335 336 rtcp_sender.SetRTCPStatus(kRtcpNonCompound); 337 rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]); 338 339 RTCPSender::FeedbackState feedback_state; 340 341 EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr)); 342 } 343 344 EXPECT_EQ(kRedPayloadType, header.payloadType); 345 346 uint8_t encapsulated_payload_type = packet[header.headerLength]; 347 348 if (encapsulated_payload_type == kUlpfecPayloadType) { 349 received_fec_ = true; 350 } else { 351 received_media_ = true; 352 } 353 354 if (received_media_ && received_fec_) 355 observation_complete_->Set(); 356 357 return SEND_PACKET; 358 } 359 360 virtual void ModifyConfigs( 361 VideoSendStream::Config* send_config, 362 std::vector<VideoReceiveStream::Config>* receive_configs, 363 VideoEncoderConfig* encoder_config) OVERRIDE { 364 send_config->rtp.fec.red_payload_type = kRedPayloadType; 365 send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; 366 } 367 368 virtual void PerformTest() OVERRIDE { 369 EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets."; 370 } 371 372 internal::TransportAdapter transport_adapter_; 373 int send_count_; 374 bool received_media_; 375 bool received_fec_; 376 } test; 377 378 RunBaseTest(&test); 379 } 380 381 void VideoSendStreamTest::TestNackRetransmission( 382 uint32_t retransmit_ssrc, 383 uint8_t retransmit_payload_type) { 384 class NackObserver : public test::SendTest { 385 public: 386 explicit NackObserver(uint32_t retransmit_ssrc, 387 uint8_t retransmit_payload_type) 388 : SendTest(kDefaultTimeoutMs), 389 transport_adapter_(SendTransport()), 390 send_count_(0), 391 retransmit_ssrc_(retransmit_ssrc), 392 retransmit_payload_type_(retransmit_payload_type), 393 nacked_sequence_number_(-1) { 394 transport_adapter_.Enable(); 395 } 396 397 private: 398 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 399 RTPHeader header; 400 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 401 402 // Nack second packet after receiving the third one. 403 if (++send_count_ == 3) { 404 uint16_t nack_sequence_number = header.sequenceNumber - 1; 405 nacked_sequence_number_ = nack_sequence_number; 406 NullReceiveStatistics null_stats; 407 RTCPSender rtcp_sender( 408 0, false, Clock::GetRealTimeClock(), &null_stats); 409 EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_)); 410 411 rtcp_sender.SetRTCPStatus(kRtcpNonCompound); 412 rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]); 413 414 RTCPSender::FeedbackState feedback_state; 415 416 EXPECT_EQ(0, 417 rtcp_sender.SendRTCP( 418 feedback_state, kRtcpNack, 1, &nack_sequence_number)); 419 } 420 421 uint16_t sequence_number = header.sequenceNumber; 422 423 if (header.ssrc == retransmit_ssrc_ && 424 retransmit_ssrc_ != kSendSsrcs[0]) { 425 // Not kSendSsrcs[0], assume correct RTX packet. Extract sequence 426 // number. 427 const uint8_t* rtx_header = packet + header.headerLength; 428 sequence_number = (rtx_header[0] << 8) + rtx_header[1]; 429 } 430 431 if (sequence_number == nacked_sequence_number_) { 432 EXPECT_EQ(retransmit_ssrc_, header.ssrc); 433 EXPECT_EQ(retransmit_payload_type_, header.payloadType); 434 observation_complete_->Set(); 435 } 436 437 return SEND_PACKET; 438 } 439 440 virtual void ModifyConfigs( 441 VideoSendStream::Config* send_config, 442 std::vector<VideoReceiveStream::Config>* receive_configs, 443 VideoEncoderConfig* encoder_config) OVERRIDE { 444 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 445 send_config->rtp.rtx.payload_type = retransmit_payload_type_; 446 if (retransmit_ssrc_ != kSendSsrcs[0]) 447 send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_); 448 } 449 450 virtual void PerformTest() OVERRIDE { 451 EXPECT_EQ(kEventSignaled, Wait()) 452 << "Timed out while waiting for NACK retransmission."; 453 } 454 455 internal::TransportAdapter transport_adapter_; 456 int send_count_; 457 uint32_t retransmit_ssrc_; 458 uint8_t retransmit_payload_type_; 459 int nacked_sequence_number_; 460 } test(retransmit_ssrc, retransmit_payload_type); 461 462 RunBaseTest(&test); 463 } 464 465 TEST_F(VideoSendStreamTest, RetransmitsNack) { 466 // Normal NACKs should use the send SSRC. 467 TestNackRetransmission(kSendSsrcs[0], kFakeSendPayloadType); 468 } 469 470 TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) { 471 // NACKs over RTX should use a separate SSRC. 472 TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType); 473 } 474 475 void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, 476 bool with_fec) { 477 // Use a fake encoder to output a frame of every size in the range [90, 290], 478 // for each size making sure that the exact number of payload bytes received 479 // is correct and that packets are fragmented to respect max packet size. 480 static const uint32_t kMaxPacketSize = 128; 481 static const uint32_t start = 90; 482 static const uint32_t stop = 290; 483 484 // Observer that verifies that the expected number of packets and bytes 485 // arrive for each frame size, from start_size to stop_size. 486 class FrameFragmentationTest : public test::SendTest, 487 public EncodedFrameObserver { 488 public: 489 FrameFragmentationTest(uint32_t max_packet_size, 490 uint32_t start_size, 491 uint32_t stop_size, 492 bool test_generic_packetization, 493 bool use_fec) 494 : SendTest(kLongTimeoutMs), 495 transport_adapter_(SendTransport()), 496 encoder_(stop), 497 max_packet_size_(max_packet_size), 498 stop_size_(stop_size), 499 test_generic_packetization_(test_generic_packetization), 500 use_fec_(use_fec), 501 packet_count_(0), 502 accumulated_size_(0), 503 accumulated_payload_(0), 504 fec_packet_received_(false), 505 current_size_rtp_(start_size), 506 current_size_frame_(start_size) { 507 // Fragmentation required, this test doesn't make sense without it. 508 encoder_.SetFrameSize(start); 509 assert(stop_size > max_packet_size); 510 transport_adapter_.Enable(); 511 } 512 513 private: 514 virtual Action OnSendRtp(const uint8_t* packet, size_t size) OVERRIDE { 515 uint32_t length = static_cast<int>(size); 516 RTPHeader header; 517 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 518 519 EXPECT_LE(length, max_packet_size_); 520 521 if (use_fec_) { 522 uint8_t payload_type = packet[header.headerLength]; 523 bool is_fec = header.payloadType == kRedPayloadType && 524 payload_type == kUlpfecPayloadType; 525 if (is_fec) { 526 fec_packet_received_ = true; 527 return SEND_PACKET; 528 } 529 } 530 531 accumulated_size_ += length; 532 533 if (use_fec_) 534 TriggerLossReport(header); 535 536 if (test_generic_packetization_) { 537 uint32_t overhead = header.headerLength + header.paddingLength + 538 (1 /* Generic header */); 539 if (use_fec_) 540 overhead += 1; // RED for FEC header. 541 accumulated_payload_ += length - overhead; 542 } 543 544 // Marker bit set indicates last packet of a frame. 545 if (header.markerBit) { 546 if (use_fec_ && accumulated_payload_ == current_size_rtp_ - 1) { 547 // With FEC enabled, frame size is incremented asynchronously, so 548 // "old" frames one byte too small may arrive. Accept, but don't 549 // increase expected frame size. 550 accumulated_size_ = 0; 551 accumulated_payload_ = 0; 552 return SEND_PACKET; 553 } 554 555 EXPECT_GE(accumulated_size_, current_size_rtp_); 556 if (test_generic_packetization_) { 557 EXPECT_EQ(current_size_rtp_, accumulated_payload_); 558 } 559 560 // Last packet of frame; reset counters. 561 accumulated_size_ = 0; 562 accumulated_payload_ = 0; 563 if (current_size_rtp_ == stop_size_) { 564 // Done! (Don't increase size again, might arrive more @ stop_size). 565 observation_complete_->Set(); 566 } else { 567 // Increase next expected frame size. If testing with FEC, make sure 568 // a FEC packet has been received for this frame size before 569 // proceeding, to make sure that redundancy packets don't exceed 570 // size limit. 571 if (!use_fec_) { 572 ++current_size_rtp_; 573 } else if (fec_packet_received_) { 574 fec_packet_received_ = false; 575 ++current_size_rtp_; 576 ++current_size_frame_; 577 } 578 } 579 } 580 581 return SEND_PACKET; 582 } 583 584 void TriggerLossReport(const RTPHeader& header) { 585 // Send lossy receive reports to trigger FEC enabling. 586 if (packet_count_++ % 2 != 0) { 587 // Receive statistics reporting having lost 50% of the packets. 588 FakeReceiveStatistics lossy_receive_stats( 589 kSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127); 590 RTCPSender rtcp_sender( 591 0, false, Clock::GetRealTimeClock(), &lossy_receive_stats); 592 EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_)); 593 594 rtcp_sender.SetRTCPStatus(kRtcpNonCompound); 595 rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]); 596 597 RTCPSender::FeedbackState feedback_state; 598 599 EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr)); 600 } 601 } 602 603 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { 604 // Increase frame size for next encoded frame, in the context of the 605 // encoder thread. 606 if (!use_fec_ && 607 current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) { 608 ++current_size_frame_; 609 } 610 encoder_.SetFrameSize(current_size_frame_.Value()); 611 } 612 613 virtual void ModifyConfigs( 614 VideoSendStream::Config* send_config, 615 std::vector<VideoReceiveStream::Config>* receive_configs, 616 VideoEncoderConfig* encoder_config) OVERRIDE { 617 if (use_fec_) { 618 send_config->rtp.fec.red_payload_type = kRedPayloadType; 619 send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; 620 } 621 622 if (!test_generic_packetization_) 623 send_config->encoder_settings.payload_name = "VP8"; 624 625 send_config->encoder_settings.encoder = &encoder_; 626 send_config->rtp.max_packet_size = kMaxPacketSize; 627 send_config->post_encode_callback = this; 628 629 // Add an extension header, to make the RTP header larger than the base 630 // length of 12 bytes. 631 static const uint8_t kAbsSendTimeExtensionId = 13; 632 send_config->rtp.extensions.push_back( 633 RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); 634 } 635 636 virtual void PerformTest() OVERRIDE { 637 EXPECT_EQ(kEventSignaled, Wait()) 638 << "Timed out while observing incoming RTP packets."; 639 } 640 641 internal::TransportAdapter transport_adapter_; 642 test::ConfigurableFrameSizeEncoder encoder_; 643 644 const uint32_t max_packet_size_; 645 const uint32_t stop_size_; 646 const bool test_generic_packetization_; 647 const bool use_fec_; 648 649 uint32_t packet_count_; 650 uint32_t accumulated_size_; 651 uint32_t accumulated_payload_; 652 bool fec_packet_received_; 653 654 uint32_t current_size_rtp_; 655 Atomic32 current_size_frame_; 656 }; 657 658 // Don't auto increment if FEC is used; continue sending frame size until 659 // a FEC packet has been received. 660 FrameFragmentationTest test( 661 kMaxPacketSize, start, stop, format == kGeneric, with_fec); 662 663 RunBaseTest(&test); 664 } 665 666 // TODO(sprang): Is there any way of speeding up these tests? 667 TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) { 668 TestPacketFragmentationSize(kGeneric, false); 669 } 670 671 TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) { 672 TestPacketFragmentationSize(kGeneric, true); 673 } 674 675 TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) { 676 TestPacketFragmentationSize(kVP8, false); 677 } 678 679 TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) { 680 TestPacketFragmentationSize(kVP8, true); 681 } 682 683 // The test will go through a number of phases. 684 // 1. Start sending packets. 685 // 2. As soon as the RTP stream has been detected, signal a low REMB value to 686 // suspend the stream. 687 // 3. Wait until |kSuspendTimeFrames| have been captured without seeing any RTP 688 // packets. 689 // 4. Signal a high REMB and then wait for the RTP stream to start again. 690 // When the stream is detected again, and the stats show that the stream 691 // is no longer suspended, the test ends. 692 TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { 693 static const int kSuspendTimeFrames = 60; // Suspend for 2 seconds @ 30 fps. 694 695 class RembObserver : public test::SendTest, public I420FrameCallback { 696 public: 697 RembObserver() 698 : SendTest(kDefaultTimeoutMs), 699 transport_adapter_(&transport_), 700 clock_(Clock::GetRealTimeClock()), 701 crit_(CriticalSectionWrapper::CreateCriticalSection()), 702 test_state_(kBeforeSuspend), 703 rtp_count_(0), 704 last_sequence_number_(0), 705 suspended_frame_count_(0), 706 low_remb_bps_(0), 707 high_remb_bps_(0) { 708 transport_adapter_.Enable(); 709 } 710 711 private: 712 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 713 // Receive statistics reporting having lost 0% of the packets. 714 // This is needed for the send-side bitrate controller to work properly. 715 CriticalSectionScoped lock(crit_.get()); 716 SendRtcpFeedback(0); // REMB is only sent if value is > 0. 717 return SEND_PACKET; 718 } 719 720 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 721 CriticalSectionScoped lock(crit_.get()); 722 ++rtp_count_; 723 RTPHeader header; 724 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 725 last_sequence_number_ = header.sequenceNumber; 726 727 if (test_state_ == kBeforeSuspend) { 728 // The stream has started. Try to suspend it. 729 SendRtcpFeedback(low_remb_bps_); 730 test_state_ = kDuringSuspend; 731 } else if (test_state_ == kDuringSuspend) { 732 if (header.paddingLength == 0) { 733 // Received non-padding packet during suspension period. Reset the 734 // counter. 735 suspended_frame_count_ = 0; 736 } 737 } else if (test_state_ == kWaitingForPacket) { 738 if (header.paddingLength == 0) { 739 // Non-padding packet observed. Test is almost complete. Will just 740 // have to wait for the stats to change. 741 test_state_ = kWaitingForStats; 742 } 743 } else if (test_state_ == kWaitingForStats) { 744 VideoSendStream::Stats stats = stream_->GetStats(); 745 if (stats.suspended == false) { 746 // Stats flipped to false. Test is complete. 747 observation_complete_->Set(); 748 } 749 } 750 751 return SEND_PACKET; 752 } 753 754 // This method implements the I420FrameCallback. 755 void FrameCallback(I420VideoFrame* video_frame) OVERRIDE { 756 CriticalSectionScoped lock(crit_.get()); 757 if (test_state_ == kDuringSuspend && 758 ++suspended_frame_count_ > kSuspendTimeFrames) { 759 VideoSendStream::Stats stats = stream_->GetStats(); 760 EXPECT_TRUE(stats.suspended); 761 SendRtcpFeedback(high_remb_bps_); 762 test_state_ = kWaitingForPacket; 763 } 764 } 765 766 void set_low_remb_bps(int value) { 767 CriticalSectionScoped lock(crit_.get()); 768 low_remb_bps_ = value; 769 } 770 771 void set_high_remb_bps(int value) { 772 CriticalSectionScoped lock(crit_.get()); 773 high_remb_bps_ = value; 774 } 775 776 virtual void SetReceivers( 777 PacketReceiver* send_transport_receiver, 778 PacketReceiver* receive_transport_receiver) OVERRIDE { 779 transport_.SetReceiver(send_transport_receiver); 780 } 781 782 virtual void OnStreamsCreated( 783 VideoSendStream* send_stream, 784 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 785 stream_ = send_stream; 786 } 787 788 virtual void ModifyConfigs( 789 VideoSendStream::Config* send_config, 790 std::vector<VideoReceiveStream::Config>* receive_configs, 791 VideoEncoderConfig* encoder_config) OVERRIDE { 792 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; 793 send_config->pre_encode_callback = this; 794 send_config->suspend_below_min_bitrate = true; 795 int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps; 796 set_low_remb_bps(min_bitrate_bps - 10000); 797 int threshold_window = std::max(min_bitrate_bps / 10, 10000); 798 ASSERT_GT(encoder_config->streams[0].max_bitrate_bps, 799 min_bitrate_bps + threshold_window + 5000); 800 set_high_remb_bps(min_bitrate_bps + threshold_window + 5000); 801 } 802 803 virtual void PerformTest() OVERRIDE { 804 EXPECT_EQ(kEventSignaled, Wait()) 805 << "Timed out during suspend-below-min-bitrate test."; 806 transport_.StopSending(); 807 } 808 809 enum TestState { 810 kBeforeSuspend, 811 kDuringSuspend, 812 kWaitingForPacket, 813 kWaitingForStats 814 }; 815 816 virtual void SendRtcpFeedback(int remb_value) 817 EXCLUSIVE_LOCKS_REQUIRED(crit_) { 818 FakeReceiveStatistics receive_stats( 819 kSendSsrcs[0], last_sequence_number_, rtp_count_, 0); 820 RTCPSender rtcp_sender(0, false, clock_, &receive_stats); 821 EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_)); 822 823 rtcp_sender.SetRTCPStatus(kRtcpNonCompound); 824 rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]); 825 if (remb_value > 0) { 826 rtcp_sender.SetREMBStatus(true); 827 rtcp_sender.SetREMBData(remb_value, 0, NULL); 828 } 829 RTCPSender::FeedbackState feedback_state; 830 EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr)); 831 } 832 833 internal::TransportAdapter transport_adapter_; 834 test::DirectTransport transport_; 835 Clock* const clock_; 836 VideoSendStream* stream_; 837 838 const scoped_ptr<CriticalSectionWrapper> crit_; 839 TestState test_state_ GUARDED_BY(crit_); 840 int rtp_count_ GUARDED_BY(crit_); 841 int last_sequence_number_ GUARDED_BY(crit_); 842 int suspended_frame_count_ GUARDED_BY(crit_); 843 int low_remb_bps_ GUARDED_BY(crit_); 844 int high_remb_bps_ GUARDED_BY(crit_); 845 } test; 846 847 RunBaseTest(&test); 848 } 849 850 TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) { 851 class NoPaddingWhenVideoIsMuted : public test::SendTest { 852 public: 853 NoPaddingWhenVideoIsMuted() 854 : SendTest(kDefaultTimeoutMs), 855 clock_(Clock::GetRealTimeClock()), 856 transport_adapter_(ReceiveTransport()), 857 crit_(CriticalSectionWrapper::CreateCriticalSection()), 858 last_packet_time_ms_(-1), 859 capturer_(NULL) { 860 transport_adapter_.Enable(); 861 } 862 863 private: 864 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 865 CriticalSectionScoped lock(crit_.get()); 866 last_packet_time_ms_ = clock_->TimeInMilliseconds(); 867 capturer_->Stop(); 868 return SEND_PACKET; 869 } 870 871 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 872 CriticalSectionScoped lock(crit_.get()); 873 const int kVideoMutedThresholdMs = 10000; 874 if (last_packet_time_ms_ > 0 && 875 clock_->TimeInMilliseconds() - last_packet_time_ms_ > 876 kVideoMutedThresholdMs) 877 observation_complete_->Set(); 878 // Receive statistics reporting having lost 50% of the packets. 879 FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0); 880 RTCPSender rtcp_sender( 881 0, false, Clock::GetRealTimeClock(), &receive_stats); 882 EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_)); 883 884 rtcp_sender.SetRTCPStatus(kRtcpNonCompound); 885 rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]); 886 887 RTCPSender::FeedbackState feedback_state; 888 889 EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr)); 890 return SEND_PACKET; 891 } 892 893 virtual void SetReceivers( 894 PacketReceiver* send_transport_receiver, 895 PacketReceiver* receive_transport_receiver) OVERRIDE { 896 RtpRtcpObserver::SetReceivers(send_transport_receiver, 897 send_transport_receiver); 898 } 899 900 virtual size_t GetNumStreams() const OVERRIDE { return 3; } 901 902 virtual void OnFrameGeneratorCapturerCreated( 903 test::FrameGeneratorCapturer* frame_generator_capturer) { 904 CriticalSectionScoped lock(crit_.get()); 905 capturer_ = frame_generator_capturer; 906 } 907 908 virtual void PerformTest() OVERRIDE { 909 EXPECT_EQ(kEventSignaled, Wait()) 910 << "Timed out while waiting for RTP packets to stop being sent."; 911 } 912 913 Clock* const clock_; 914 internal::TransportAdapter transport_adapter_; 915 const scoped_ptr<CriticalSectionWrapper> crit_; 916 int64_t last_packet_time_ms_ GUARDED_BY(crit_); 917 test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_); 918 } test; 919 920 RunBaseTest(&test); 921 } 922 923 TEST_F(VideoSendStreamTest, ProducesStats) { 924 class ProducesStats : public test::SendTest { 925 public: 926 ProducesStats() 927 : SendTest(kDefaultTimeoutMs), 928 stream_(NULL), 929 event_(EventWrapper::Create()) {} 930 931 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 932 event_->Set(); 933 934 return SEND_PACKET; 935 } 936 937 private: 938 bool WaitForFilledStats() { 939 Clock* clock = Clock::GetRealTimeClock(); 940 int64_t now = clock->TimeInMilliseconds(); 941 int64_t stop_time = now + kDefaultTimeoutMs; 942 while (now < stop_time) { 943 int64_t time_left = stop_time - now; 944 if (time_left > 0 && event_->Wait(time_left) == kEventSignaled && 945 CheckStats()) { 946 return true; 947 } 948 now = clock->TimeInMilliseconds(); 949 } 950 return false; 951 } 952 953 bool CheckStats() { 954 VideoSendStream::Stats stats = stream_->GetStats(); 955 // Check that all applicable data sources have been used. 956 if (stats.input_frame_rate > 0 && stats.encode_frame_rate > 0 957 && !stats.substreams.empty()) { 958 uint32_t ssrc = stats.substreams.begin()->first; 959 EXPECT_NE( 960 config_.rtp.ssrcs.end(), 961 std::find( 962 config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end(), ssrc)); 963 // Check for data populated by various sources. RTCP excluded as this 964 // data is received from remote side. Tested in call tests instead. 965 const StreamStats& entry = stats.substreams[ssrc]; 966 if (entry.key_frames > 0u && entry.bitrate_bps > 0 && 967 entry.rtp_stats.packets > 0u && entry.avg_delay_ms > 0 && 968 entry.max_delay_ms > 0) { 969 return true; 970 } 971 } 972 return false; 973 } 974 975 void SetConfig(const VideoSendStream::Config& config) { config_ = config; } 976 977 virtual void ModifyConfigs( 978 VideoSendStream::Config* send_config, 979 std::vector<VideoReceiveStream::Config>* receive_configs, 980 VideoEncoderConfig* encoder_config) OVERRIDE { 981 SetConfig(*send_config); 982 } 983 984 virtual void OnStreamsCreated( 985 VideoSendStream* send_stream, 986 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 987 stream_ = send_stream; 988 } 989 990 virtual void PerformTest() OVERRIDE { 991 EXPECT_TRUE(WaitForFilledStats()) 992 << "Timed out waiting for filled statistics."; 993 } 994 995 VideoSendStream* stream_; 996 VideoSendStream::Config config_; 997 scoped_ptr<EventWrapper> event_; 998 } test; 999 1000 RunBaseTest(&test); 1001 } 1002 1003 // This test first observes "high" bitrate use at which point it sends a REMB to 1004 // indicate that it should be lowered significantly. The test then observes that 1005 // the bitrate observed is sinking well below the min-transmit-bitrate threshold 1006 // to verify that the min-transmit bitrate respects incoming REMB. 1007 // 1008 // Note that the test starts at "high" bitrate and does not ramp up to "higher" 1009 // bitrate since no receiver block or remb is sent in the initial phase. 1010 TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { 1011 static const int kMinTransmitBitrateBps = 400000; 1012 static const int kHighBitrateBps = 150000; 1013 static const int kRembBitrateBps = 80000; 1014 static const int kRembRespectedBitrateBps = 100000; 1015 class BitrateObserver : public test::SendTest, public PacketReceiver { 1016 public: 1017 BitrateObserver() 1018 : SendTest(kDefaultTimeoutMs), 1019 feedback_transport_(ReceiveTransport()), 1020 bitrate_capped_(false) { 1021 RtpRtcp::Configuration config; 1022 feedback_transport_.Enable(); 1023 config.outgoing_transport = &feedback_transport_; 1024 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config)); 1025 rtp_rtcp_->SetREMBStatus(true); 1026 rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound); 1027 } 1028 1029 virtual void OnStreamsCreated( 1030 VideoSendStream* send_stream, 1031 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1032 stream_ = send_stream; 1033 } 1034 1035 private: 1036 virtual DeliveryStatus DeliverPacket(const uint8_t* packet, 1037 size_t length) OVERRIDE { 1038 if (RtpHeaderParser::IsRtcp(packet, length)) 1039 return DELIVERY_OK; 1040 1041 RTPHeader header; 1042 if (!parser_->Parse(packet, length, &header)) 1043 return DELIVERY_PACKET_ERROR; 1044 assert(stream_ != NULL); 1045 VideoSendStream::Stats stats = stream_->GetStats(); 1046 if (!stats.substreams.empty()) { 1047 EXPECT_EQ(1u, stats.substreams.size()); 1048 int bitrate_bps = stats.substreams.begin()->second.bitrate_bps; 1049 test::PrintResult( 1050 "bitrate_stats_", 1051 "min_transmit_bitrate_low_remb", 1052 "bitrate_bps", 1053 static_cast<size_t>(bitrate_bps), 1054 "bps", 1055 false); 1056 if (bitrate_bps > kHighBitrateBps) { 1057 rtp_rtcp_->SetREMBData(kRembBitrateBps, 1, &header.ssrc); 1058 rtp_rtcp_->Process(); 1059 bitrate_capped_ = true; 1060 } else if (bitrate_capped_ && 1061 bitrate_bps < kRembRespectedBitrateBps) { 1062 observation_complete_->Set(); 1063 } 1064 } 1065 return DELIVERY_OK; 1066 } 1067 1068 virtual void SetReceivers( 1069 PacketReceiver* send_transport_receiver, 1070 PacketReceiver* receive_transport_receiver) OVERRIDE { 1071 RtpRtcpObserver::SetReceivers(this, send_transport_receiver); 1072 } 1073 1074 virtual void ModifyConfigs( 1075 VideoSendStream::Config* send_config, 1076 std::vector<VideoReceiveStream::Config>* receive_configs, 1077 VideoEncoderConfig* encoder_config) OVERRIDE { 1078 send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps; 1079 } 1080 1081 virtual void PerformTest() OVERRIDE { 1082 EXPECT_EQ(kEventSignaled, Wait()) 1083 << "Timeout while waiting for low bitrate stats after REMB."; 1084 } 1085 1086 scoped_ptr<RtpRtcp> rtp_rtcp_; 1087 internal::TransportAdapter feedback_transport_; 1088 VideoSendStream* stream_; 1089 bool bitrate_capped_; 1090 } test; 1091 1092 RunBaseTest(&test); 1093 } 1094 1095 TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) { 1096 class FrameObserver : public I420FrameCallback { 1097 public: 1098 FrameObserver() : output_frame_event_(EventWrapper::Create()) {} 1099 1100 void FrameCallback(I420VideoFrame* video_frame) OVERRIDE { 1101 // Clone the frame because the caller owns it. 1102 output_frames_.push_back(video_frame->CloneFrame()); 1103 output_frame_event_->Set(); 1104 } 1105 1106 void WaitOutputFrame() { 1107 const unsigned long kWaitFrameTimeoutMs = 3000; 1108 EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(kWaitFrameTimeoutMs)) 1109 << "Timeout while waiting for output frames."; 1110 } 1111 1112 const std::vector<I420VideoFrame*>& output_frames() const { 1113 return output_frames_.get(); 1114 } 1115 1116 private: 1117 // Delivered output frames. 1118 ScopedVector<I420VideoFrame> output_frames_; 1119 1120 // Indicate an output frame has arrived. 1121 scoped_ptr<EventWrapper> output_frame_event_; 1122 }; 1123 1124 // Initialize send stream. 1125 test::NullTransport transport; 1126 CreateSenderCall(Call::Config(&transport)); 1127 1128 CreateSendConfig(1); 1129 FrameObserver observer; 1130 send_config_.pre_encode_callback = &observer; 1131 CreateStreams(); 1132 1133 // Prepare five input frames. Send I420VideoFrame and TextureVideoFrame 1134 // alternatively. 1135 ScopedVector<I420VideoFrame> input_frames; 1136 int width = static_cast<int>(encoder_config_.streams[0].width); 1137 int height = static_cast<int>(encoder_config_.streams[0].height); 1138 webrtc::RefCountImpl<FakeNativeHandle>* handle1 = 1139 new webrtc::RefCountImpl<FakeNativeHandle>(); 1140 webrtc::RefCountImpl<FakeNativeHandle>* handle2 = 1141 new webrtc::RefCountImpl<FakeNativeHandle>(); 1142 webrtc::RefCountImpl<FakeNativeHandle>* handle3 = 1143 new webrtc::RefCountImpl<FakeNativeHandle>(); 1144 input_frames.push_back(new TextureVideoFrame(handle1, width, height, 1, 1)); 1145 input_frames.push_back(new TextureVideoFrame(handle2, width, height, 2, 2)); 1146 input_frames.push_back(CreateI420VideoFrame(width, height, 1)); 1147 input_frames.push_back(CreateI420VideoFrame(width, height, 2)); 1148 input_frames.push_back(new TextureVideoFrame(handle3, width, height, 3, 3)); 1149 1150 send_stream_->Start(); 1151 for (size_t i = 0; i < input_frames.size(); i++) { 1152 // Make a copy of the input frame because the buffer will be swapped. 1153 scoped_ptr<I420VideoFrame> frame(input_frames[i]->CloneFrame()); 1154 send_stream_->Input()->SwapFrame(frame.get()); 1155 // Do not send the next frame too fast, so the frame dropper won't drop it. 1156 if (i < input_frames.size() - 1) 1157 SleepMs(1000 / encoder_config_.streams[0].max_framerate); 1158 // Wait until the output frame is received before sending the next input 1159 // frame. Or the previous input frame may be replaced without delivering. 1160 observer.WaitOutputFrame(); 1161 } 1162 send_stream_->Stop(); 1163 1164 // Test if the input and output frames are the same. render_time_ms and 1165 // timestamp are not compared because capturer sets those values. 1166 ExpectEqualFramesVector(input_frames.get(), observer.output_frames()); 1167 1168 DestroyStreams(); 1169 } 1170 1171 void ExpectEqualFrames(const I420VideoFrame& frame1, 1172 const I420VideoFrame& frame2) { 1173 if (frame1.native_handle() != NULL || frame2.native_handle() != NULL) 1174 ExpectEqualTextureFrames(frame1, frame2); 1175 else 1176 ExpectEqualBufferFrames(frame1, frame2); 1177 } 1178 1179 void ExpectEqualTextureFrames(const I420VideoFrame& frame1, 1180 const I420VideoFrame& frame2) { 1181 EXPECT_EQ(frame1.native_handle(), frame2.native_handle()); 1182 EXPECT_EQ(frame1.width(), frame2.width()); 1183 EXPECT_EQ(frame1.height(), frame2.height()); 1184 } 1185 1186 void ExpectEqualBufferFrames(const I420VideoFrame& frame1, 1187 const I420VideoFrame& frame2) { 1188 EXPECT_EQ(frame1.width(), frame2.width()); 1189 EXPECT_EQ(frame1.height(), frame2.height()); 1190 EXPECT_EQ(frame1.stride(kYPlane), frame2.stride(kYPlane)); 1191 EXPECT_EQ(frame1.stride(kUPlane), frame2.stride(kUPlane)); 1192 EXPECT_EQ(frame1.stride(kVPlane), frame2.stride(kVPlane)); 1193 EXPECT_EQ(frame1.ntp_time_ms(), frame2.ntp_time_ms()); 1194 ASSERT_EQ(frame1.allocated_size(kYPlane), frame2.allocated_size(kYPlane)); 1195 EXPECT_EQ(0, 1196 memcmp(frame1.buffer(kYPlane), 1197 frame2.buffer(kYPlane), 1198 frame1.allocated_size(kYPlane))); 1199 ASSERT_EQ(frame1.allocated_size(kUPlane), frame2.allocated_size(kUPlane)); 1200 EXPECT_EQ(0, 1201 memcmp(frame1.buffer(kUPlane), 1202 frame2.buffer(kUPlane), 1203 frame1.allocated_size(kUPlane))); 1204 ASSERT_EQ(frame1.allocated_size(kVPlane), frame2.allocated_size(kVPlane)); 1205 EXPECT_EQ(0, 1206 memcmp(frame1.buffer(kVPlane), 1207 frame2.buffer(kVPlane), 1208 frame1.allocated_size(kVPlane))); 1209 } 1210 1211 void ExpectEqualFramesVector(const std::vector<I420VideoFrame*>& frames1, 1212 const std::vector<I420VideoFrame*>& frames2) { 1213 EXPECT_EQ(frames1.size(), frames2.size()); 1214 for (size_t i = 0; i < std::min(frames1.size(), frames2.size()); ++i) 1215 ExpectEqualFrames(*frames1[i], *frames2[i]); 1216 } 1217 1218 I420VideoFrame* CreateI420VideoFrame(int width, int height, uint8_t data) { 1219 I420VideoFrame* frame = new I420VideoFrame(); 1220 const int kSizeY = width * height * 2; 1221 const int kSizeUV = width * height; 1222 scoped_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]); 1223 memset(buffer.get(), data, kSizeY); 1224 frame->CreateFrame(kSizeY, 1225 buffer.get(), 1226 kSizeUV, 1227 buffer.get(), 1228 kSizeUV, 1229 buffer.get(), 1230 width, 1231 height, 1232 width, 1233 width / 2, 1234 width / 2); 1235 frame->set_timestamp(data); 1236 frame->set_ntp_time_ms(data); 1237 frame->set_render_time_ms(data); 1238 return frame; 1239 } 1240 1241 TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { 1242 class EncoderStateObserver : public test::SendTest, public VideoEncoder { 1243 public: 1244 EncoderStateObserver() 1245 : SendTest(kDefaultTimeoutMs), 1246 crit_(CriticalSectionWrapper::CreateCriticalSection()), 1247 initialized_(false), 1248 callback_registered_(false), 1249 num_releases_(0), 1250 released_(false) {} 1251 1252 bool IsReleased() { 1253 CriticalSectionScoped lock(crit_.get()); 1254 return released_; 1255 } 1256 1257 bool IsReadyForEncode() { 1258 CriticalSectionScoped lock(crit_.get()); 1259 return initialized_ && callback_registered_; 1260 } 1261 1262 size_t num_releases() { 1263 CriticalSectionScoped lock(crit_.get()); 1264 return num_releases_; 1265 } 1266 1267 private: 1268 virtual int32_t InitEncode(const VideoCodec* codecSettings, 1269 int32_t numberOfCores, 1270 uint32_t maxPayloadSize) OVERRIDE { 1271 CriticalSectionScoped lock(crit_.get()); 1272 EXPECT_FALSE(initialized_); 1273 initialized_ = true; 1274 released_ = false; 1275 return 0; 1276 } 1277 1278 virtual int32_t Encode( 1279 const I420VideoFrame& inputImage, 1280 const CodecSpecificInfo* codecSpecificInfo, 1281 const std::vector<VideoFrameType>* frame_types) OVERRIDE { 1282 EXPECT_TRUE(IsReadyForEncode()); 1283 1284 observation_complete_->Set(); 1285 return 0; 1286 } 1287 1288 virtual int32_t RegisterEncodeCompleteCallback( 1289 EncodedImageCallback* callback) OVERRIDE { 1290 CriticalSectionScoped lock(crit_.get()); 1291 EXPECT_TRUE(initialized_); 1292 callback_registered_ = true; 1293 return 0; 1294 } 1295 1296 virtual int32_t Release() OVERRIDE { 1297 CriticalSectionScoped lock(crit_.get()); 1298 EXPECT_TRUE(IsReadyForEncode()); 1299 EXPECT_FALSE(released_); 1300 initialized_ = false; 1301 callback_registered_ = false; 1302 released_ = true; 1303 ++num_releases_; 1304 return 0; 1305 } 1306 1307 virtual int32_t SetChannelParameters(uint32_t packetLoss, 1308 int rtt) OVERRIDE { 1309 EXPECT_TRUE(IsReadyForEncode()); 1310 return 0; 1311 } 1312 1313 virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) OVERRIDE { 1314 EXPECT_TRUE(IsReadyForEncode()); 1315 return 0; 1316 } 1317 1318 virtual void OnStreamsCreated( 1319 VideoSendStream* send_stream, 1320 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1321 // Encoder initialization should be done in stream construction before 1322 // starting. 1323 EXPECT_TRUE(IsReadyForEncode()); 1324 stream_ = send_stream; 1325 } 1326 1327 virtual void ModifyConfigs( 1328 VideoSendStream::Config* send_config, 1329 std::vector<VideoReceiveStream::Config>* receive_configs, 1330 VideoEncoderConfig* encoder_config) OVERRIDE { 1331 send_config->encoder_settings.encoder = this; 1332 encoder_config_ = *encoder_config; 1333 } 1334 1335 virtual void PerformTest() OVERRIDE { 1336 EXPECT_EQ(kEventSignaled, Wait()) 1337 << "Timed out while waiting for Encode."; 1338 EXPECT_EQ(0u, num_releases()); 1339 stream_->ReconfigureVideoEncoder(encoder_config_); 1340 EXPECT_EQ(0u, num_releases()); 1341 stream_->Stop(); 1342 // Encoder should not be released before destroying the VideoSendStream. 1343 EXPECT_FALSE(IsReleased()); 1344 EXPECT_TRUE(IsReadyForEncode()); 1345 stream_->Start(); 1346 // Sanity check, make sure we still encode frames with this encoder. 1347 EXPECT_EQ(kEventSignaled, Wait()) 1348 << "Timed out while waiting for Encode."; 1349 } 1350 1351 scoped_ptr<CriticalSectionWrapper> crit_; 1352 VideoSendStream* stream_; 1353 bool initialized_ GUARDED_BY(crit_); 1354 bool callback_registered_ GUARDED_BY(crit_); 1355 size_t num_releases_ GUARDED_BY(crit_); 1356 bool released_ GUARDED_BY(crit_); 1357 VideoEncoderConfig encoder_config_; 1358 } test_encoder; 1359 1360 RunBaseTest(&test_encoder); 1361 1362 EXPECT_TRUE(test_encoder.IsReleased()); 1363 EXPECT_EQ(1u, test_encoder.num_releases()); 1364 } 1365 1366 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { 1367 class VideoCodecConfigObserver : public test::SendTest, 1368 public test::FakeEncoder { 1369 public: 1370 VideoCodecConfigObserver() 1371 : SendTest(kDefaultTimeoutMs), 1372 FakeEncoder(Clock::GetRealTimeClock()), 1373 num_initializations_(0) {} 1374 1375 private: 1376 virtual void ModifyConfigs( 1377 VideoSendStream::Config* send_config, 1378 std::vector<VideoReceiveStream::Config>* receive_configs, 1379 VideoEncoderConfig* encoder_config) OVERRIDE { 1380 send_config->encoder_settings.encoder = this; 1381 encoder_config_ = *encoder_config; 1382 } 1383 1384 virtual void OnStreamsCreated( 1385 VideoSendStream* send_stream, 1386 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1387 stream_ = send_stream; 1388 } 1389 1390 virtual int32_t InitEncode(const VideoCodec* config, 1391 int32_t number_of_cores, 1392 uint32_t max_payload_size) OVERRIDE { 1393 if (num_initializations_ == 0) { 1394 // Verify default values. 1395 EXPECT_EQ(kRealtimeVideo, config->mode); 1396 } else { 1397 // Verify that changed values are propagated. 1398 EXPECT_EQ(kScreensharing, config->mode); 1399 } 1400 ++num_initializations_; 1401 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); 1402 } 1403 1404 virtual void PerformTest() OVERRIDE { 1405 EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; 1406 1407 encoder_config_.content_type = VideoEncoderConfig::kScreenshare; 1408 stream_->ReconfigureVideoEncoder(encoder_config_); 1409 EXPECT_EQ(2u, num_initializations_) 1410 << "ReconfigureVideoEncoder did not reinitialize the encoder with " 1411 "new encoder settings."; 1412 } 1413 1414 size_t num_initializations_; 1415 VideoSendStream* stream_; 1416 VideoEncoderConfig encoder_config_; 1417 } test; 1418 1419 RunBaseTest(&test); 1420 } 1421 1422 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { 1423 static const size_t kNumberOfTemporalLayers = 4; 1424 class VideoCodecConfigObserver : public test::SendTest, 1425 public test::FakeEncoder { 1426 public: 1427 VideoCodecConfigObserver() 1428 : SendTest(kDefaultTimeoutMs), 1429 FakeEncoder(Clock::GetRealTimeClock()), 1430 num_initializations_(0) { 1431 memset(&vp8_settings_, 0, sizeof(vp8_settings_)); 1432 } 1433 1434 private: 1435 virtual void ModifyConfigs( 1436 VideoSendStream::Config* send_config, 1437 std::vector<VideoReceiveStream::Config>* receive_configs, 1438 VideoEncoderConfig* encoder_config) OVERRIDE { 1439 send_config->encoder_settings.encoder = this; 1440 send_config->encoder_settings.payload_name = "VP8"; 1441 1442 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { 1443 encoder_config->streams[i].temporal_layers.resize( 1444 kNumberOfTemporalLayers); 1445 } 1446 1447 encoder_config->encoder_specific_settings = &vp8_settings_; 1448 encoder_config_ = *encoder_config; 1449 } 1450 1451 virtual void OnStreamsCreated( 1452 VideoSendStream* send_stream, 1453 const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE { 1454 stream_ = send_stream; 1455 } 1456 1457 virtual int32_t InitEncode(const VideoCodec* config, 1458 int32_t number_of_cores, 1459 uint32_t max_payload_size) OVERRIDE { 1460 EXPECT_EQ(kVideoCodecVP8, config->codecType); 1461 1462 // Check that the number of temporal layers has propagated properly to 1463 // VideoCodec. 1464 EXPECT_EQ(kNumberOfTemporalLayers, 1465 config->codecSpecific.VP8.numberOfTemporalLayers); 1466 1467 for (unsigned char i = 0; i < config->numberOfSimulcastStreams; ++i) { 1468 EXPECT_EQ(kNumberOfTemporalLayers, 1469 config->simulcastStream[i].numberOfTemporalLayers); 1470 } 1471 1472 // Set expected temporal layers as they should have been set when 1473 // reconfiguring the encoder and not match the set config. 1474 vp8_settings_.numberOfTemporalLayers = kNumberOfTemporalLayers; 1475 EXPECT_EQ(0, 1476 memcmp(&config->codecSpecific.VP8, 1477 &vp8_settings_, 1478 sizeof(vp8_settings_))); 1479 ++num_initializations_; 1480 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); 1481 } 1482 1483 virtual void PerformTest() OVERRIDE { 1484 EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; 1485 1486 vp8_settings_.denoisingOn = true; 1487 stream_->ReconfigureVideoEncoder(encoder_config_); 1488 EXPECT_EQ(2u, num_initializations_) 1489 << "ReconfigureVideoEncoder did not reinitialize the encoder with " 1490 "new encoder settings."; 1491 } 1492 1493 int32_t Encode(const I420VideoFrame& input_image, 1494 const CodecSpecificInfo* codec_specific_info, 1495 const std::vector<VideoFrameType>* frame_types) OVERRIDE { 1496 // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8. 1497 return 0; 1498 } 1499 1500 VideoCodecVP8 vp8_settings_; 1501 size_t num_initializations_; 1502 VideoSendStream* stream_; 1503 VideoEncoderConfig encoder_config_; 1504 } test; 1505 1506 RunBaseTest(&test); 1507 } 1508 1509 TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) { 1510 class RtcpByeTest : public test::SendTest { 1511 public: 1512 RtcpByeTest() : SendTest(kDefaultTimeoutMs), media_bytes_sent_(0) {} 1513 1514 private: 1515 virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { 1516 RTPHeader header; 1517 EXPECT_TRUE(parser_->Parse(packet, length, &header)); 1518 media_bytes_sent_ += length - header.headerLength - header.paddingLength; 1519 return SEND_PACKET; 1520 } 1521 1522 virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { 1523 RTCPUtility::RTCPParserV2 parser(packet, length, true); 1524 EXPECT_TRUE(parser.IsValid()); 1525 1526 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); 1527 uint32_t sender_octet_count = 0; 1528 while (packet_type != RTCPUtility::kRtcpNotValidCode) { 1529 if (packet_type == RTCPUtility::kRtcpSrCode) { 1530 sender_octet_count = parser.Packet().SR.SenderOctetCount; 1531 EXPECT_EQ(sender_octet_count, media_bytes_sent_); 1532 if (sender_octet_count > 0) 1533 observation_complete_->Set(); 1534 } 1535 1536 packet_type = parser.Iterate(); 1537 } 1538 1539 return SEND_PACKET; 1540 } 1541 1542 virtual void PerformTest() OVERRIDE { 1543 EXPECT_EQ(kEventSignaled, Wait()) 1544 << "Timed out while waiting for RTCP sender report."; 1545 } 1546 1547 size_t media_bytes_sent_; 1548 } test; 1549 1550 RunBaseTest(&test); 1551 } 1552 1553 } // namespace webrtc 1554
