Remove ProcessParams struct.

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 43 matching lines @@
 // Maximum number of rate updates (i.e., calls to encoder to change bitrate
 // and/or frame rate) for the current tests.
 const int kMaxNumRateUpdates = 3;
 
 // Maximum number of temporal layers to use in tests.
 const int kMaxNumTemporalLayers = 3;
 
 const int kPercTargetvsActualMismatch = 20;
 const int kBaseKeyFrameInterval = 3000;
 
-// Process and network settings.
-struct ProcessParams {
-  ProcessParams(bool hw_codec,
-                bool use_single_core,
-                float packet_loss_probability,
-                int key_frame_interval,
-                std::string filename,
-                bool verbose_logging,
-                bool batch_mode)
-      : hw_codec(hw_codec),
-        use_single_core(use_single_core),
-        key_frame_interval(key_frame_interval),
-        packet_loss_probability(packet_loss_probability),
-        filename(filename),
-        verbose_logging(verbose_logging),
-        batch_mode(batch_mode) {}
-
-  bool hw_codec;
-  bool use_single_core;
-  int key_frame_interval;
-  float packet_loss_probability;  // [0.0, 1.0].
-  std::string filename;
-  bool verbose_logging;
-
-  // In batch mode, the VideoProcessor is fed all the frames for processing
-  // before any metrics are calculated. This is useful for pipelining HW codecs,
-  // for which some calculated metrics otherwise would be incorrect. The
-  // downside with batch mode is that mid-test rate allocation is not supported.
-  bool batch_mode;
-};
-
 // Thresholds for the quality metrics. Defaults are maximally minimal.
 struct QualityThresholds {
+  QualityThresholds() {}
+  QualityThresholds(double min_avg_psnr,
+                    double min_min_psnr,
+                    double min_avg_ssim,
+                    double min_min_ssim)
+      : min_avg_psnr(min_avg_psnr),
+        min_min_psnr(min_min_psnr),
+        min_avg_ssim(min_avg_ssim),
+        min_min_ssim(min_min_ssim) {}
   double min_avg_psnr = std::numeric_limits<double>::min();
   double min_min_psnr = std::numeric_limits<double>::min();
-  double min_avg_ssim = 0;
-  double min_min_ssim = 0;
+  double min_avg_ssim = 0.0;
+  double min_min_ssim = 0.0;
 };
 
 // The sequence of bit rate and frame rate changes for the encoder, the frame
 // number where the changes are made, and the total number of frames for the
 // test.
 struct RateProfile {
   int target_bit_rate[kMaxNumRateUpdates];
   int input_frame_rate[kMaxNumRateUpdates];
   int frame_index_rate_update[kMaxNumRateUpdates + 1];
   int num_frames;
@@ skipping 48 matching lines @@
     InitializeAndroidObjects();
 
     external_encoder_factory_.reset(
         new webrtc_jni::MediaCodecVideoEncoderFactory());
     external_decoder_factory_.reset(
         new webrtc_jni::MediaCodecVideoDecoderFactory());
 #endif
   }
   virtual ~VideoProcessorIntegrationTest() = default;
 
-  void CreateEncoderAndDecoder(bool hw_codec) {
-    if (hw_codec) {
+  void CreateEncoderAndDecoder() {
+    if (config_.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.
       switch (config_.codec_settings->codecType) {
         case kVideoCodecH264:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kH264CodecName)));
@@ skipping 45 matching lines @@
       case kVideoCodecVP9:
         encoder_.reset(VP9Encoder::Create());
         decoder_.reset(VP9Decoder::Create());
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
   }
 
-  void SetUpCodecConfig(const ProcessParams& process,
-                        const VisualizationParams* visualization_params) {
-    CreateEncoderAndDecoder(process.hw_codec);
-
-    // Configure input filename.
-    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(VideoType::kI420, config_.codec_settings->width,
-                       config_.codec_settings->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 = process.key_frame_interval;
-    config_.networking_config.packet_loss_probability =
-        process.packet_loss_probability;
+  void SetUpObjects(const VisualizationParams* visualization_params) {
+    CreateEncoderAndDecoder();
 
     // Create file objects for quality analysis.
     analysis_frame_reader_.reset(new test::YuvFrameReaderImpl(
         config_.input_filename, config_.codec_settings->width,
         config_.codec_settings->height));
     analysis_frame_writer_.reset(new test::YuvFrameWriterImpl(
         config_.output_filename, config_.codec_settings->width,
         config_.codec_settings->height));
     RTC_CHECK(analysis_frame_reader_->Init());
     RTC_CHECK(analysis_frame_writer_->Init());
 
     if (visualization_params) {
       // clang-format off
       const std::string output_filename_base =
-          test::OutputPath() + process.filename +
+          test::OutputPath() + config_.filename +
           "_cd-" + CodecTypeToPayloadName(
               config_.codec_settings->codecType).value_or("") +
-          "_hw-" + std::to_string(process.hw_codec) +
+          "_hw-" + std::to_string(config_.hw_codec) +
           "_fr-" + std::to_string(start_frame_rate_) +
           "_br-" + std::to_string(
               static_cast<int>(config_.codec_settings->startBitrate));
       // clang-format on
       if (visualization_params->save_source_y4m) {
         source_frame_writer_.reset(new test::Y4mFrameWriterImpl(
             output_filename_base + "_source.y4m", config_.codec_settings->width,
             config_.codec_settings->height, start_frame_rate_));
         RTC_CHECK(source_frame_writer_->Init());
       }
@@ skipping 15 matching lines @@
     packet_manipulator_.reset(new test::PacketManipulatorImpl(
         &packet_reader_, config_.networking_config, config_.verbose));
     processor_.reset(new test::VideoProcessorImpl(
         encoder_.get(), decoder_.get(), analysis_frame_reader_.get(),
         analysis_frame_writer_.get(), packet_manipulator_.get(), config_,
         &stats_, source_frame_writer_.get(), encoded_frame_writer_.get(),
         decoded_frame_writer_.get()));
     processor_->Init();
   }
 
-  // Reset quantities after each encoder update, update the target
-  // per-frame bandwidth.
+  // Reset quantities after each encoder update, update the target per-frame
+  // bandwidth.
   void ResetRateControlMetrics(int num_frames_to_hit_target) {
     for (int i = 0; i < num_temporal_layers_; i++) {
       num_frames_per_update_[i] = 0;
       sum_frame_size_mismatch_[i] = 0.0f;
       sum_encoded_frame_size_[i] = 0.0f;
       encoding_bitrate_[i] = 0.0f;
       // Update layer per-frame-bandwidth.
       per_frame_bandwidth_[i] = static_cast<float>(bit_rate_layer_[i]) /
                                 static_cast<float>(frame_rate_layer_[i]);
     }
     // Set maximum size of key frames, following setting in the VP8 wrapper.
     float max_key_size = kScaleKeyFrameSize * kOptimalBufferSize * frame_rate_;
     // We don't know exact target size of the key frames (except for first one),
     // but the minimum in libvpx is ~|3 * per_frame_bandwidth| and maximum is
-    // set by |max_key_size_  * per_frame_bandwidth|. Take middle point/average
+    // set by |max_key_size_ * per_frame_bandwidth|. Take middle point/average
     // as reference for mismatch. Note key frames always correspond to base
     // layer frame in this test.
     target_size_key_frame_ = 0.5 * (3 + max_key_size) * per_frame_bandwidth_[0];
     num_frames_total_ = 0;
     sum_encoded_frame_size_total_ = 0.0f;
     encoding_bitrate_total_ = 0.0f;
     perc_encoding_rate_mismatch_ = 0.0f;
     num_frames_to_hit_target_ = num_frames_to_hit_target;
     encoding_rate_within_target_ = false;
     sum_key_frame_size_mismatch_ = 0.0;
@@ skipping 109 matching lines @@
 
   void VerifyQuality(const test::QualityMetricsResult& psnr_result,
                      const test::QualityMetricsResult& ssim_result,
                      const QualityThresholds& quality_thresholds) {
     EXPECT_GT(psnr_result.average, quality_thresholds.min_avg_psnr);
     EXPECT_GT(psnr_result.min, quality_thresholds.min_min_psnr);
     EXPECT_GT(ssim_result.average, quality_thresholds.min_avg_ssim);
     EXPECT_GT(ssim_result.min, quality_thresholds.min_min_ssim);
   }
 
-  void VerifyQpParser(const ProcessParams& process, int frame_number) {
-    if (!process.hw_codec &&
+  void VerifyQpParser(int frame_number) {
+    if (!config_.hw_codec &&
         (config_.codec_settings->codecType == kVideoCodecVP8 ||
          config_.codec_settings->codecType == kVideoCodecVP9)) {
       EXPECT_EQ(processor_->GetQpFromEncoder(frame_number),
                 processor_->GetQpFromBitstream(frame_number));
     }
   }
 
   int NumberOfTemporalLayers(const VideoCodec* codec_settings) {
     if (codec_settings->codecType == kVideoCodecVP8) {
       return codec_settings->VP8().numberOfTemporalLayers;
@@ skipping 55 matching lines @@
     if (num_temporal_layers_ == 3) {
       frame_rate_layer_[2] = frame_rate_ / 2.0f;
     }
   }
 
   // Processes all frames in the clip and verifies the result.
   // TODO(brandtr): Change the second last argument to be a
   // const std::vector<RateControlThresholds>&, so we can ensure that the user
   // does not expect us to do mid-clip rate updates when we are not able to,
   // e.g., when we are operating in batch mode.
-  void ProcessFramesAndVerify(QualityThresholds quality_thresholds,
-                              RateProfile rate_profile,
-                              ProcessParams process,
+  void ProcessFramesAndVerify(const QualityThresholds& quality_thresholds,
+                              const RateProfile& rate_profile,
                               RateControlThresholds* rc_thresholds,
                               const VisualizationParams* visualization_params) {
     // Codec/config settings.
     RTC_CHECK(config_.codec_settings);
     num_temporal_layers_ = NumberOfTemporalLayers(config_.codec_settings);
     config_.codec_settings->startBitrate = rate_profile.target_bit_rate[0];
     start_frame_rate_ = rate_profile.input_frame_rate[0];
-    SetUpCodecConfig(process, visualization_params);
+    SetUpObjects(visualization_params);
     // Update the temporal layers and the codec with the initial rates.
     bit_rate_ = rate_profile.target_bit_rate[0];
     frame_rate_ = rate_profile.input_frame_rate[0];
     SetTemporalLayerRates();
     // 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|.
     int frame_number = 0;
     int update_index = 0;
     int num_frames = rate_profile.num_frames;
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
 
-    if (process.batch_mode) {
+    if (config_.batch_mode) {
       // In batch mode, we calculate the metrics for all frames after all frames
       // have been sent for encoding.
 
       // TODO(brandtr): Refactor "frame number accounting" so we don't have to
       // call ProcessFrame num_frames+1 times here.
       for (frame_number = 0; frame_number <= num_frames; ++frame_number) {
         EXPECT_TRUE(processor_->ProcessFrame(frame_number));
       }
 
       for (frame_number = 0; frame_number < num_frames; ++frame_number) {
         ++num_frames_per_update_[TemporalLayerIndexForFrame(frame_number)];
         ++num_frames_total_;
         UpdateRateControlMetrics(frame_number);
       }
     } else {
       // In online mode, we calculate the metrics for a given frame right after
       // it has been sent for encoding.
 
-      if (process.hw_codec) {
+      if (config_.hw_codec) {
         LOG(LS_WARNING) << "HW codecs should mostly be run in batch mode, "
                            "since they may be pipelining.";
       }
 
       while (frame_number < num_frames) {
         EXPECT_TRUE(processor_->ProcessFrame(frame_number));
-        VerifyQpParser(process, frame_number);
+        VerifyQpParser(frame_number);
         ++num_frames_per_update_[TemporalLayerIndexForFrame(frame_number)];
         ++num_frames_total_;
         UpdateRateControlMetrics(frame_number);
 
         ++frame_number;
 
         // If we hit another/next update, verify stats for current state and
         // update layers and codec with new rates.
         if (frame_number ==
             rate_profile.frame_index_rate_update[update_index + 1]) {
@@ skipping 51 matching lines @@
            ssim_result.min);
     VerifyQuality(psnr_result, ssim_result, quality_thresholds);
     stats_.PrintSummary();
 
     // Remove analysis file.
     if (remove(config_.output_filename.c_str()) < 0) {
       fprintf(stderr, "Failed to remove temporary file!\n");
     }
   }
 
+  static void SetProcessParams(test::TestConfig* config,
+                               bool hw_codec,
+                               bool use_single_core,
+                               float packet_loss_probability,
+                               int key_frame_interval,
+                               std::string filename,
+                               bool verbose_logging,
+                               bool batch_mode) {
+    // Configure input filename.
+    config->filename = filename;
+    config->input_filename = test::ResourcePath(filename, "yuv");
+    // Generate an output filename in a safe way.
+    config->output_filename = test::TempFilename(
+        test::OutputPath(), "videoprocessor_integrationtest");
+    config->hw_codec = hw_codec;
+    config->use_single_core = use_single_core;
+    config->keyframe_interval = key_frame_interval;
+    config->networking_config.packet_loss_probability = packet_loss_probability;
+    config->verbose = verbose_logging;
+    config->batch_mode = batch_mode;
+  }
+
   static void SetCodecSettings(test::TestConfig* config,
                                VideoCodec* codec_settings,
                                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,
@@ skipping 26 matching lines @@
             num_temporal_layers;
         config->codec_settings->VP9()->frameDroppingOn = frame_dropper_on;
         config->codec_settings->VP9()->automaticResizeOn = spatial_resize_on;
         config->codec_settings->VP9()->keyFrameInterval = kBaseKeyFrameInterval;
         config->codec_settings->VP9()->resilienceOn = resilience_on;
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
-  }
 
-  static void SetQualityThresholds(QualityThresholds* quality_thresholds,
-                                   double min_avg_psnr,
-                                   double min_min_psnr,
-                                   double min_avg_ssim,
-                                   double min_min_ssim) {
-    quality_thresholds->min_avg_psnr = min_avg_psnr;
-    quality_thresholds->min_min_psnr = min_min_psnr;
-    quality_thresholds->min_avg_ssim = min_avg_ssim;
-    quality_thresholds->min_min_ssim = min_min_ssim;
+    config->frame_length_in_bytes =
+        CalcBufferSize(VideoType::kI420, width, height);
   }
 
   static void SetRateProfile(RateProfile* rate_profile,
                              int update_index,
                              int bit_rate,
                              int frame_rate,
                              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] =
@@ skipping 66 matching lines @@
   int start_frame_rate_;
 
   // Codec and network settings.
   int num_temporal_layers_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_