Add multithreaded fake encoder and corresponding FlexFEC VideoSendStreamTest.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>  // max
@@ skipping 338 matching lines @@
   std::unique_ptr<LossyStatistician> lossy_stats_;
   StatisticianMap stats_map_;
 };
 
 class UlpfecObserver : public test::EndToEndTest {
  public:
   UlpfecObserver(bool header_extensions_enabled,
                  bool use_nack,
                  bool expect_red,
                  bool expect_ulpfec,
-                 const std::string& codec)
+                 const std::string& codec,
+                 VideoEncoder* encoder)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
+        encoder_(encoder),
         payload_name_(codec),
         use_nack_(use_nack),
         expect_red_(expect_red),
         expect_ulpfec_(expect_ulpfec),
         sent_media_(false),
         sent_ulpfec_(false),
-        header_extensions_enabled_(header_extensions_enabled) {
-    if (codec == "H264") {
-      encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
-    } else if (codec == "VP8") {
-      encoder_.reset(VP8Encoder::Create());
-    } else if (codec == "VP9") {
-      encoder_.reset(VP9Encoder::Create());
-    } else {
-      RTC_NOTREACHED();
-    }
-  }
+        header_extensions_enabled_(header_extensions_enabled) {}
 
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
     int encapsulated_payload_type = -1;
     if (header.payloadType == VideoSendStreamTest::kRedPayloadType) {
       EXPECT_TRUE(expect_red_);
       encapsulated_payload_type = static_cast<int>(packet[header.headerLength]);
@@ skipping 67 matching lines @@
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     transport_adapter_.reset(
         new internal::TransportAdapter(send_config->send_transport));
     transport_adapter_->Enable();
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
           (*receive_configs)[0].rtp.nack.rtp_history_ms =
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
-    send_config->encoder_settings.encoder = encoder_.get();
+    send_config->encoder_settings.encoder = encoder_;
     send_config->encoder_settings.payload_name = payload_name_;
     send_config->rtp.ulpfec.red_payload_type =
         VideoSendStreamTest::kRedPayloadType;
     send_config->rtp.ulpfec.ulpfec_payload_type =
         VideoSendStreamTest::kUlpfecPayloadType;
     if (header_extensions_enabled_) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        test::kTransportSequenceNumberExtensionId));
     }
     (*receive_configs)[0].rtp.ulpfec.red_payload_type =
         send_config->rtp.ulpfec.red_payload_type;
     (*receive_configs)[0].rtp.ulpfec.ulpfec_payload_type =
         send_config->rtp.ulpfec.ulpfec_payload_type;
   }
 
   void PerformTest() override {
     EXPECT_TRUE(Wait()) << "Timed out waiting for ULPFEC and/or media packets.";
   }
 
   std::unique_ptr<internal::TransportAdapter> transport_adapter_;
-  std::unique_ptr<VideoEncoder> encoder_;
-  const std::string payload_name_;
+  VideoEncoder* const encoder_;
+  std::string payload_name_;
   const bool use_nack_;
   const bool expect_red_;
   const bool expect_ulpfec_;
   bool sent_media_;
   bool sent_ulpfec_;
   bool header_extensions_enabled_;
   RTPHeader prev_header_;
 };
 
 TEST_F(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
-  UlpfecObserver test(true, false, true, true, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  UlpfecObserver test(true, false, true, true, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
-  UlpfecObserver test(false, false, true, true, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  UlpfecObserver test(false, false, true, true, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 // The FEC scheme used is not efficient for H264, so we should not use RED/FEC
 // since we'll still have to re-request FEC packets, effectively wasting
 // bandwidth since the receiver has to wait for FEC retransmissions to determine
 // that the received state is actually decodable.
 TEST_F(VideoSendStreamTest, DoesNotUtilizeUlpfecForH264WithNackEnabled) {
-  UlpfecObserver test(false, true, true, false, "H264");
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::FakeH264Encoder(Clock::GetRealTimeClock()));
+  UlpfecObserver test(false, true, true, false, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
 // Without retransmissions FEC for H264 is fine.
 TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForH264WithoutNackEnabled) {
-  UlpfecObserver test(false, false, true, true, "H264");
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::FakeH264Encoder(Clock::GetRealTimeClock()));
+  UlpfecObserver test(false, false, true, true, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp8WithNackEnabled) {
-  UlpfecObserver test(false, true, true, true, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  UlpfecObserver test(false, true, true, true, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp9WithNackEnabled) {
-  UlpfecObserver test(false, true, true, true, "VP9");
+  std::unique_ptr<VideoEncoder> encoder(VP9Encoder::Create());
+  UlpfecObserver test(false, true, true, true, "VP9", encoder.get());
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithMultiThreadedH264) {
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::MultiThreadedFakeH264Encoder(Clock::GetRealTimeClock()));
+  UlpfecObserver test(false, false, true, true, "H264", encoder.get());
+  RunBaseTest(&test);
+}
+
 // TODO(brandtr): Move these FlexFEC tests when we have created
 // FlexfecSendStream.
 class FlexfecObserver : public test::EndToEndTest {
  public:
   FlexfecObserver(bool header_extensions_enabled,
                   bool use_nack,
-                  const std::string& codec)
+                  const std::string& codec,
+                  VideoEncoder* encoder)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
+        encoder_(encoder),
         payload_name_(codec),
         use_nack_(use_nack),
         sent_media_(false),
         sent_flexfec_(false),
-        header_extensions_enabled_(header_extensions_enabled) {
-    if (codec == "H264") {
-      encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
-    } else if (codec == "VP8") {
-      encoder_.reset(VP8Encoder::Create());
-    } else if (codec == "VP9") {
-      encoder_.reset(VP9Encoder::Create());
-    } else {
-      RTC_NOTREACHED();
-    }
-  }
+        header_extensions_enabled_(header_extensions_enabled) {}
 
   size_t GetNumFlexfecStreams() const override { return 1; }
 
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
     if (header.payloadType == VideoSendStreamTest::kFlexfecPayloadType) {
       EXPECT_EQ(VideoSendStreamTest::kFlexfecSendSsrc, header.ssrc);
@@ skipping 34 matching lines @@
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     transport_adapter_.reset(
         new internal::TransportAdapter(send_config->send_transport));
     transport_adapter_->Enable();
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
           (*receive_configs)[0].rtp.nack.rtp_history_ms =
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
-    send_config->encoder_settings.encoder = encoder_.get();
+    send_config->encoder_settings.encoder = encoder_;
     send_config->encoder_settings.payload_name = payload_name_;
     if (header_extensions_enabled_) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTimestampOffsetUri, test::kTOffsetExtensionId));
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        test::kTransportSequenceNumberExtensionId));
     }
   }
 
   void PerformTest() override {
     EXPECT_TRUE(Wait())
         << "Timed out waiting for FlexFEC and/or media packets.";
   }
 
   std::unique_ptr<internal::TransportAdapter> transport_adapter_;
-  std::unique_ptr<VideoEncoder> encoder_;
-  const std::string payload_name_;
+  VideoEncoder* const encoder_;
+  std::string payload_name_;
   const bool use_nack_;
   bool sent_media_;
   bool sent_flexfec_;
   bool header_extensions_enabled_;
 };
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecVp8) {
-  FlexfecObserver test(false, false, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  FlexfecObserver test(false, false, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp8) {
-  FlexfecObserver test(false, true, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  FlexfecObserver test(false, true, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
-  FlexfecObserver test(true, false, "VP8");
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  FlexfecObserver test(true, false, "VP8", encoder.get());
   RunBaseTest(&test);
 }
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(VideoSendStreamTest, SupportsFlexfecVp9) {
-  FlexfecObserver test(false, false, "VP9");
+  std::unique_ptr<VideoEncoder> encoder(VP9Encoder::Create());
+  FlexfecObserver test(false, false, "VP9", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp9) {
-  FlexfecObserver test(false, true, "VP9");
+  std::unique_ptr<VideoEncoder> encoder(VP9Encoder::Create());
+  FlexfecObserver test(false, true, "VP9", encoder.get());
   RunBaseTest(&test);
 }
 #endif  // defined(RTC_DISABLE_VP9)
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecH264) {
-  FlexfecObserver test(false, false, "H264");
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::FakeH264Encoder(Clock::GetRealTimeClock()));
+  FlexfecObserver test(false, false, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackH264) {
-  FlexfecObserver test(false, true, "H264");
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::FakeH264Encoder(Clock::GetRealTimeClock()));
+  FlexfecObserver test(false, true, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithMultiThreadedH264) {
+  std::unique_ptr<VideoEncoder> encoder(
+      new test::MultiThreadedFakeH264Encoder(Clock::GetRealTimeClock()));
+  FlexfecObserver test(false, false, "H264", encoder.get());
+  RunBaseTest(&test);
+}
+
 void VideoSendStreamTest::TestNackRetransmission(
     uint32_t retransmit_ssrc,
     uint8_t retransmit_payload_type) {
   class NackObserver : public test::SendTest {
    public:
     explicit NackObserver(uint32_t retransmit_ssrc,
                           uint8_t retransmit_payload_type)
         : SendTest(kDefaultTimeoutMs),
           send_count_(0),
           retransmit_ssrc_(retransmit_ssrc),
@@ skipping 2523 matching lines @@
    private:
     Call* call_;
     rtc::CriticalSection crit_;
     uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc