Make use_single_core option configurable in VideoProcessorIntegrationTests.

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

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 45 matching lines @@
 
 // Default sequence is foreman (CIF): may be better to use VGA for resize test.
 const int kCifWidth = 352;
 const int kCifHeight = 288;
 const char kFilenameForemanCif[] = "foreman_cif";
 
 // Codec and network settings.
 struct CodecConfigPars {
   VideoCodecType codec_type;
   bool hw_codec;
+  bool use_single_core;
   float packet_loss;
   int num_temporal_layers;
   int key_frame_interval;
   bool error_concealment_on;
   bool denoising_on;
   bool frame_dropper_on;
   bool spatial_resize_on;
   int width;
   int height;
   std::string filename;
@@ skipping 59 matching lines @@
     InitializeAndroidObjects();
 
     external_encoder_factory_.reset(
         new webrtc_jni::MediaCodecVideoEncoderFactory());
     external_decoder_factory_.reset(
         new webrtc_jni::MediaCodecVideoDecoderFactory());
 #endif
   }
   virtual ~VideoProcessorIntegrationTest() = default;
 
-  void SetUpCodecConfig(const std::string& filename,
-                        int width,
-                        int height,
-                        bool verbose_logging) {
+  void SetUpCodecConfig(const CodecConfigPars& process) {
     if (hw_codec_) {
 #if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
 #if defined(WEBRTC_ANDROID)
       // In general, external codecs should be destroyed by the factories that
       // allocated them. For the particular case of the Android
       // MediaCodecVideo{En,De}coderFactory's, however, it turns out that it is
       // fine for the std::unique_ptr to destroy the owned codec directly.
       if (codec_type_ == kVideoCodecH264) {
         encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
             cricket::VideoCodec(cricket::kH264CodecName)));
@@ skipping 33 matching lines @@
         decoder_.reset(VP8Decoder::Create());
       } else if (codec_type_ == kVideoCodecVP9) {
         encoder_.reset(VP9Encoder::Create());
         decoder_.reset(VP9Decoder::Create());
       }
     }
 
     VideoCodingModule::Codec(codec_type_, &codec_settings_);
 
     // Configure input filename.
-    config_.input_filename = test::ResourcePath(filename, "yuv");
-    if (verbose_logging)
-      printf("Filename: %s\n", filename.c_str());
+    config_.input_filename = test::ResourcePath(process.filename, "yuv");
+    if (process.verbose_logging)
+      printf("Filename: %s\n", process.filename.c_str());
     // Generate an output filename in a safe way.
     config_.output_filename = test::TempFilename(
         test::OutputPath(), "videoprocessor_integrationtest");
-    config_.frame_length_in_bytes = CalcBufferSize(kI420, width, height);
-    config_.verbose = verbose_logging;
-    // Only allow encoder/decoder to use single core, for predictability.
-    config_.use_single_core = true;
+    config_.frame_length_in_bytes =
+        CalcBufferSize(kI420, process.width, process.height);
+    config_.verbose = process.verbose_logging;
+    config_.use_single_core = process.use_single_core;
     // Key frame interval and packet loss are set for each test.
     config_.keyframe_interval = key_frame_interval_;
     config_.networking_config.packet_loss_probability = packet_loss_;
 
     // Configure codec settings.
     config_.codec_settings = &codec_settings_;
     config_.codec_settings->startBitrate = start_bitrate_;
-    config_.codec_settings->width = width;
-    config_.codec_settings->height = height;
+    config_.codec_settings->width = process.width;
+    config_.codec_settings->height = process.height;
 
     // These features may be set depending on the test.
     switch (config_.codec_settings->codecType) {
       case kVideoCodecH264:
         config_.codec_settings->H264()->frameDroppingOn = frame_dropper_on_;
         config_.codec_settings->H264()->keyFrameInterval =
             kBaseKeyFrameInterval;
         break;
       case kVideoCodecVP8:
         config_.codec_settings->VP8()->errorConcealmentOn =
@@ skipping 220 matching lines @@
     codec_type_ = process.codec_type;
     hw_codec_ = process.hw_codec;
     start_bitrate_ = rate_profile.target_bit_rate[0];
     packet_loss_ = process.packet_loss;
     key_frame_interval_ = process.key_frame_interval;
     num_temporal_layers_ = process.num_temporal_layers;
     error_concealment_on_ = process.error_concealment_on;
     denoising_on_ = process.denoising_on;
     frame_dropper_on_ = process.frame_dropper_on;
     spatial_resize_on_ = process.spatial_resize_on;
-    SetUpCodecConfig(process.filename, process.width, process.height,
-                     process.verbose_logging);
+    SetUpCodecConfig(process);
     // Update the layers and the codec with the initial rates.
     bit_rate_ = rate_profile.target_bit_rate[0];
     frame_rate_ = rate_profile.input_frame_rate[0];
     SetLayerRates();
     // Set the initial target size for key frame.
     target_size_key_frame_initial_ =
         0.5 * kInitialBufferSize * bit_rate_layer_[0];
     processor_->SetRates(bit_rate_, frame_rate_);
 
     // Process each frame, up to |num_frames|.
@@ skipping 83 matching lines @@
                                  int frame_index_rate_update) {
     rate_profile->target_bit_rate[update_index] = bit_rate;
     rate_profile->input_frame_rate[update_index] = frame_rate;
     rate_profile->frame_index_rate_update[update_index] =
         frame_index_rate_update;
   }
 
   static void SetCodecParameters(CodecConfigPars* process_settings,
                                  VideoCodecType codec_type,
                                  bool hw_codec,
+                                 bool use_single_core,
                                  float packet_loss,
                                  int key_frame_interval,
                                  int num_temporal_layers,
                                  bool error_concealment_on,
                                  bool denoising_on,
                                  bool frame_dropper_on,
                                  bool spatial_resize_on,
                                  int width,
                                  int height,
                                  const std::string& filename,
                                  bool verbose_logging) {
     process_settings->codec_type = codec_type;
     process_settings->hw_codec = hw_codec;
+    process_settings->use_single_core = use_single_core;
     process_settings->packet_loss = packet_loss;
     process_settings->key_frame_interval = key_frame_interval;
     process_settings->num_temporal_layers = num_temporal_layers,
     process_settings->error_concealment_on = error_concealment_on;
     process_settings->denoising_on = denoising_on;
     process_settings->frame_dropper_on = frame_dropper_on;
     process_settings->spatial_resize_on = spatial_resize_on;
     process_settings->width = width;
     process_settings->height = height;
     process_settings->filename = filename;
     process_settings->verbose_logging = verbose_logging;
   }
 
   static void SetCodecParameters(CodecConfigPars* process_settings,
                                  VideoCodecType codec_type,
                                  bool hw_codec,
+                                 bool use_single_core,
                                  float packet_loss,
                                  int key_frame_interval,
                                  int num_temporal_layers,
                                  bool error_concealment_on,
                                  bool denoising_on,
                                  bool frame_dropper_on,
                                  bool spatial_resize_on) {
-    SetCodecParameters(process_settings, codec_type, hw_codec, packet_loss,
-                       key_frame_interval, num_temporal_layers,
+    SetCodecParameters(process_settings, codec_type, hw_codec, use_single_core,
+                       packet_loss, key_frame_interval, num_temporal_layers,
                        error_concealment_on, denoising_on, frame_dropper_on,
                        spatial_resize_on, kCifWidth, kCifHeight,
                        kFilenameForemanCif, false /* verbose_logging */);
   }
 
   static void SetQualityMetrics(QualityMetrics* quality_metrics,
                                 double minimum_avg_psnr,
                                 double minimum_min_psnr,
                                 double minimum_avg_ssim,
                                 double minimum_min_ssim) {
@@ skipping 72 matching lines @@
   bool error_concealment_on_;
   bool denoising_on_;
   bool frame_dropper_on_;
   bool spatial_resize_on_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_