Add SetCodecSettings method for configuring VideoCodec settings.

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 34 matching lines @@
 };
 
 // Returns a string representation of the enum value.
 const char* ExcludeFrameTypesToStr(ExcludeFrameTypes e);
 
 // Test configuration for a test run.
 struct TestConfig {
   TestConfig();
   ~TestConfig();
 
-  // Name of the test. This is purely metadata and does not affect
-  // the test in any way.
+  // Name of the test. This is purely metadata and does not affect the test.
   std::string name;
 
   // More detailed description of the test. This is purely metadata and does
-  // not affect the test in any way.
+  // 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;
+  int test_number = 0;
 
-  // File to process for the test. This must be a video file in the YUV format.
+  // 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). Default: "out".
-  std::string output_dir;
+  // (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. Default: kExcludeOnlyFirstKeyFrame.
-  ExcludeFrameTypes exclude_frame_types;
+  // 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.
-  size_t frame_length_in_bytes;
+  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.
-  // Default: false.
-  bool use_single_core;
+  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.
-  // Default: 0.
-  int keyframe_interval;
+  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;
+  webrtc::VideoCodec* codec_settings = nullptr;
 
   // If printing of information to stdout shall be performed during processing.
-  bool verbose;
+  bool verbose = true;
 };
 
 // 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
 // would be altered, all the following delta frames would be pretty much
 // worthless. VP8 has an error-resilience feature that makes it able to handle
 // packet loss in key non-first keyframes, which is why only the first is
 // excluded by default.
 // Packet loss in such important frames is handled on a higher level in the
 // Video Engine, where signaling would request a retransmit of the lost packets,
 // since they're so important.
 //
 // Note this class is not thread safe in any way and is meant for simple testing
 // purposes.
 class VideoProcessor {
  public:
   virtual ~VideoProcessor() {}
 
   // Sets up callbacks and initializes the encoder and decoder.
   virtual void Init() = 0;
 
   // Processes a single frame. Returns true as long as there's more frames
   // available in the source clip.
-  // Frame number must be an integer >= 0.
+  // |frame_number| must be an integer >= 0.
   virtual bool ProcessFrame(int frame_number) = 0;
 
-  // Updates the encoder with the target bit rate and the frame rate.
+  // Updates the encoder with the target |bit_rate| and the |frame_rate|.
   virtual void SetRates(int bit_rate, int frame_rate) = 0;
 
   // Return the size of the encoded frame in bytes. Dropped frames by the
   // encoder are regarded as zero size.
   virtual size_t EncodedFrameSize(int frame_number) = 0;
 
   // Return the encoded frame type (key or delta).
   virtual FrameType EncodedFrameType(int frame_number) = 0;
 
   // Return the qp used by encoder.
@@ skipping 175 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_