Add ability to instantiate VideoEncoderSoftwareFallback in VP tests.

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc

 /*
  *  Copyright (c) 2017 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 "webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h"
 
 #include <utility>
 
 #if defined(WEBRTC_ANDROID)
 #include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h"
 #include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
 #include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
 #elif defined(WEBRTC_IOS)
 #include "webrtc/modules/video_coding/codecs/test/objc_codec_h264_test.h"
 #endif
 
 #include "webrtc/media/engine/internaldecoderfactory.h"
 #include "webrtc/media/engine/internalencoderfactory.h"
+#include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/event.h"
 #include "webrtc/rtc_base/file.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/testsupport/fileutils.h"
@@ skipping 47 matching lines @@
                                                      VideoCodecType codec_type,
                                                      int num_temporal_layers,
                                                      bool error_concealment_on,
                                                      bool denoising_on,
                                                      bool frame_dropper_on,
                                                      bool spatial_resize_on,
                                                      bool resilience_on,
                                                      int width,
                                                      int height) {
   webrtc::test::CodecSettings(codec_type, &config->codec_settings);
+
+  // TODO(brandtr): Move the setting of |width| and |height| to the tests, and
+  // DCHECK that they are set before initializing the codec instead.
   config->codec_settings.width = width;
   config->codec_settings.height = height;
+
   switch (config->codec_settings.codecType) {
     case kVideoCodecVP8:
       config->codec_settings.VP8()->resilience =
           resilience_on ? kResilientStream : kResilienceOff;
       config->codec_settings.VP8()->numberOfTemporalLayers =
           num_temporal_layers;
       config->codec_settings.VP8()->denoisingOn = denoising_on;
       config->codec_settings.VP8()->errorConcealmentOn = error_concealment_on;
       config->codec_settings.VP8()->automaticResizeOn = spatial_resize_on;
       config->codec_settings.VP8()->frameDroppingOn = frame_dropper_on;
@@ skipping 75 matching lines @@
 
   // Process all frames.
   int frame_number = 0;
   const int num_frames = rate_profile.num_frames;
   RTC_DCHECK_GE(num_frames, 1);
   while (frame_number < num_frames) {
     // In order to not overwhelm the OpenMAX buffers in the Android
     // MediaCodec API, we roughly pace the frames here. The downside
     // of this is that the encode run will be done in real-time.
     // TODO(brandtr): Investigate if this is needed on iOS.
-    if (config_.hw_codec) {
+    if (config_.hw_encoder || config_.hw_decoder) {
       SleepMs(rtc::kNumMillisecsPerSec /
               rate_profile.input_frame_rate[rate_update_index]);
     }
 
     task_queue.PostTask([this] { processor_->ProcessFrame(); });
     ++frame_number;
 
     if (frame_number ==
         rate_profile.frame_index_rate_update[rate_update_index + 1]) {
       ++rate_update_index;
 
       task_queue.PostTask([this, &rate_profile, rate_update_index] {
         processor_->SetRates(rate_profile.target_bit_rate[rate_update_index],
                              rate_profile.input_frame_rate[rate_update_index]);
       });
     }
   }
 
   // Give the VideoProcessor pipeline some time to process the last frame,
   // and then release the codecs.
-  if (config_.hw_codec) {
+  if (config_.hw_encoder || config_.hw_decoder) {
     SleepMs(1 * rtc::kNumMillisecsPerSec);
   }
   ReleaseAndCloseObjects(&task_queue);
 
   // Calculate and print rate control statistics.
   rate_update_index = 0;
   frame_number = 0;
   ResetRateControlMetrics(rate_update_index, rate_profile);
   std::vector<int> num_dropped_frames;
   std::vector<int> num_resize_actions;
@@ skipping 41 matching lines @@
          psnr_result.min, ssim_result.average, ssim_result.min);
   printf("\n");
 
   // Remove analysis file.
   if (remove(config_.output_filename.c_str()) < 0) {
     fprintf(stderr, "Failed to remove temporary file!\n");
   }
 }
 
 void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
-  if (config_.hw_codec) {
+  std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
+  if (config_.hw_encoder) {
 #if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
 #if defined(WEBRTC_ANDROID)
-    encoder_factory_.reset(new jni::MediaCodecVideoEncoderFactory());
+    encoder_factory.reset(new jni::MediaCodecVideoEncoderFactory());
+#elif defined(WEBRTC_IOS)
+    EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
+        << "iOS HW codecs only support H264.";
+    encoder_factory = CreateObjCEncoderFactory();
+#else
+    RTC_NOTREACHED() << "Only support HW encoder on Android and iOS.";
+#endif
+#endif  // WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED
+  } else {
+    encoder_factory.reset(new cricket::InternalEncoderFactory());
+  }
+
+  if (config_.hw_decoder) {
+#if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
+#if defined(WEBRTC_ANDROID)
     decoder_factory_.reset(new jni::MediaCodecVideoDecoderFactory());
 #elif defined(WEBRTC_IOS)
     EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
         << "iOS HW codecs only support H264.";
-    encoder_factory_ = CreateObjCEncoderFactory();
     decoder_factory_ = CreateObjCDecoderFactory();
 #else
-    RTC_NOTREACHED() << "Only support HW codecs on Android and iOS.";
+    RTC_NOTREACHED() << "Only support HW decoder on Android and iOS.";
 #endif
 #endif  // WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED
   } else {
-    // SW codecs.
-    encoder_factory_.reset(new cricket::InternalEncoderFactory());
     decoder_factory_.reset(new cricket::InternalDecoderFactory());
   }
 
+  cricket::VideoCodec encoder_codec;
   switch (config_.codec_settings.codecType) {
     case kVideoCodecVP8:
-      encoder_ = encoder_factory_->CreateVideoEncoder(
-          cricket::VideoCodec(cricket::kVp8CodecName));
+      encoder_codec = cricket::VideoCodec(cricket::kVp8CodecName);
+      encoder_.reset(encoder_factory->CreateVideoEncoder(encoder_codec));
       decoder_ = decoder_factory_->CreateVideoDecoder(kVideoCodecVP8);
       break;
     case kVideoCodecVP9:
-      encoder_ = encoder_factory_->CreateVideoEncoder(
-          cricket::VideoCodec(cricket::kVp9CodecName));
+      encoder_codec = cricket::VideoCodec(cricket::kVp9CodecName);
+      encoder_.reset(encoder_factory->CreateVideoEncoder(encoder_codec));
       decoder_ = decoder_factory_->CreateVideoDecoder(kVideoCodecVP9);
       break;
     case kVideoCodecH264:
       // TODO(brandtr): Generalize so that we support multiple profiles here.
-      encoder_ = encoder_factory_->CreateVideoEncoder(
-          cricket::VideoCodec(cricket::kH264CodecName));
+      encoder_codec = cricket::VideoCodec(cricket::kH264CodecName);
+      encoder_.reset(encoder_factory->CreateVideoEncoder(encoder_codec));
       decoder_ = decoder_factory_->CreateVideoDecoder(kVideoCodecH264);
       break;
     default:
       RTC_NOTREACHED();
       break;
   }
 
+  if (config_.sw_fallback_encoder) {
+    encoder_ = rtc::MakeUnique<VideoEncoderSoftwareFallbackWrapper>(
+        encoder_codec, std::move(encoder_));
+  }
+
   EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
   EXPECT_TRUE(decoder_) << "Decoder not successfully created.";
 }
 
 void VideoProcessorIntegrationTest::DestroyEncoderAndDecoder() {
-  encoder_factory_->DestroyVideoEncoder(encoder_);
+  encoder_.reset();
   decoder_factory_->DestroyVideoDecoder(decoder_);
 }
 
 void VideoProcessorIntegrationTest::SetUpAndInitObjects(
     rtc::TaskQueue* task_queue,
     const int initial_bitrate_kbps,
     const int initial_framerate_fps,
     const VisualizationParams* visualization_params) {
   CreateEncoderAndDecoder();
 
   // Create file objects for quality analysis.
   analysis_frame_reader_.reset(new YuvFrameReaderImpl(
       config_.input_filename, config_.codec_settings.width,
       config_.codec_settings.height));
   analysis_frame_writer_.reset(new YuvFrameWriterImpl(
       config_.output_filename, config_.codec_settings.width,
       config_.codec_settings.height));
   EXPECT_TRUE(analysis_frame_reader_->Init());
   EXPECT_TRUE(analysis_frame_writer_->Init());
 
   if (visualization_params) {
     const std::string codec_name =
         CodecTypeToPayloadString(config_.codec_settings.codecType);
-    const std::string implementation_type = config_.hw_codec ? "hw" : "sw";
+    const std::string implementation_type = config_.hw_encoder ? "hw" : "sw";
     // clang-format off
     const std::string output_filename_base =
         OutputPath() + config_.filename + "-" +
         codec_name + "-" + implementation_type + "-" +
         std::to_string(initial_bitrate_kbps);
     // clang-format on
     if (visualization_params->save_encoded_ivf) {
       rtc::File post_encode_file =
           rtc::File::Create(output_filename_base + ".ivf");
       encoded_frame_writer_ =
           IvfFileWriter::Wrap(std::move(post_encode_file), 0);
     }
     if (visualization_params->save_decoded_y4m) {
       decoded_frame_writer_.reset(new Y4mFrameWriterImpl(
           output_filename_base + ".y4m", config_.codec_settings.width,
           config_.codec_settings.height, initial_framerate_fps));
       EXPECT_TRUE(decoded_frame_writer_->Init());
     }
   }
 
   packet_manipulator_.reset(new PacketManipulatorImpl(
       &packet_reader_, config_.networking_config, config_.verbose));
 
   config_.codec_settings.minBitrate = 0;
   config_.codec_settings.startBitrate = initial_bitrate_kbps;
   config_.codec_settings.maxFramerate = initial_framerate_fps;
 
   rtc::Event sync_event(false, false);
   task_queue->PostTask([this, &sync_event]() {
+    // TODO(brandtr): std::move |encoder_| and |decoder_| into the
+    // VideoProcessor when we are able to store |decoder_| in a
+    // std::unique_ptr. That is, when https://codereview.webrtc.org/3009973002
+    // has been relanded.
     processor_ = rtc::MakeUnique<VideoProcessor>(
-        encoder_, decoder_, analysis_frame_reader_.get(),
+        encoder_.get(), decoder_, analysis_frame_reader_.get(),
         analysis_frame_writer_.get(), packet_manipulator_.get(), config_,
         &stats_, encoded_frame_writer_.get(), decoded_frame_writer_.get());
     processor_->Init();
     sync_event.Set();
   });
   sync_event.Wait(rtc::Event::kForever);
 }
 
 void VideoProcessorIntegrationTest::ReleaseAndCloseObjects(
     rtc::TaskQueue* task_queue) {
@@ skipping 235 matching lines @@
   perc_encoding_rate_mismatch_ = 0.0f;
   num_frames_to_hit_target_ =
       rate_profile.frame_index_rate_update[rate_update_index + 1];
   encoding_rate_within_target_ = false;
   sum_key_frame_size_mismatch_ = 0.0;
   num_key_frames_ = 0;
 }
 
 }  // namespace test
 }  // namespace webrtc