Remove ProcessParams struct.

webrtc/modules/video_coding/codecs/test/videoprocessor.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 42 matching lines @@
   std::string name;
 
   // More detailed description of the test. This is purely metadata and does
   // not affect the test.
   std::string description;
 
   // Number of this test. Useful if multiple runs of the same test with
   // different configurations shall be managed.
   int test_number = 0;
 
+  // Plain name of YUV file to process without file extension.
+  std::string filename;
+
   // File to process. This must be a video file in the YUV format.
   std::string input_filename;
 
   // File to write to during processing for the test. Will be a video file
   // in the YUV format.
   std::string output_filename;
 
   // Path to the directory where encoded files will be put
   // (absolute or relative to the executable).
   std::string output_dir = "out";
 
   // Configurations related to networking.
   NetworkingConfig networking_config;
 
   // Decides how the packet loss simulations shall exclude certain frames
   // from packet loss.
   ExcludeFrameTypes exclude_frame_types = kExcludeOnlyFirstKeyFrame;
 
-  // The length of a single frame of the input video file. This value is
-  // calculated out of the width and height according to the video format
-  // specification. Must be set before processing.
+  // The length of a single frame of the input video file. Calculated out of the
+  // width and height according to the video format specification (i.e. YUV).
   size_t frame_length_in_bytes = 0;
 
   // Force the encoder and decoder to use a single core for processing.
   // Using a single core is necessary to get a deterministic behavior for the
   // encoded frames - using multiple cores will produce different encoded frames
   // since multiple cores are competing to consume the byte budget for each
   // frame in parallel.
   // If set to false, the maximum number of available cores will be used.
   bool use_single_core = false;
 
-  // If set to a value >0 this setting forces the encoder to create a keyframe
-  // every Nth frame. Note that the encoder may create a keyframe in other
-  // locations in addition to the interval that is set using this parameter.
-  // Forcing key frames may also affect encoder planning optimizations in
-  // a negative way, since it will suddenly be forced to produce an expensive
-  // key frame.
+  // If > 0: forces the encoder to create a keyframe every Nth frame.
+  // Note that the encoder may create a keyframe in other locations in addition
+  // to this setting. Forcing key frames may also affect encoder planning
+  // optimizations in a negative way, since it will suddenly be forced to
+  // produce an expensive key frame.
   int keyframe_interval = 0;
 
   // The codec settings to use for the test (target bitrate, video size,
   // framerate and so on). This struct must be created and filled in using
   // the VideoCodingModule::Codec() method.
   webrtc::VideoCodec* codec_settings = nullptr;
 
   // If printing of information to stdout shall be performed during processing.
   bool verbose = true;
+
+  // If HW or SW codec should be used.
+  bool hw_codec = false;
+
+  // 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 = false;
 };
 
 // Handles encoding/decoding of video using the VideoEncoder/VideoDecoder
 // interfaces. This is done in a sequential manner in order to be able to
 // measure times properly.
 // The class processes a frame at the time for the configured input file.
 // It maintains state of where in the source input file the processing is at.
 //
 // Regarding packet loss: Note that keyframes are excluded (first or all
 // depending on the ExcludeFrameTypes setting). This is because if key frames
@@ skipping 208 matching lines @@
   // Statistics.
   Stats* stats_;
   int num_dropped_frames_;
   int num_spatial_resizes_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_