Add SetCodecSettings method for configuring VideoCodec settings.

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;
 
-// 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";
+// 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) {}
 
-// Codec and network settings.
-struct CodecParams {
-  VideoCodecType codec_type;
   bool hw_codec;
   bool use_single_core;
-
-  int width;
-  int height;
-
-  int num_temporal_layers;
   int key_frame_interval;
-  bool error_concealment_on;
-  bool denoising_on;
-  bool frame_dropper_on;
-  bool spatial_resize_on;
-  bool resilience_on;
-
   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;
 };
 
@@ skipping 64 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, VideoCodecType codec_type) {
+  void CreateEncoderAndDecoder(bool hw_codec) {
     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.
-      switch (codec_type) {
+      switch (config_.codec_settings->codecType) {
         case kVideoCodecH264:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kH264CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecH264));
           break;
         case kVideoCodecVP8:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kVp8CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP8));
           break;
         case kVideoCodecVP9:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kVp9CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP9));
           break;
         default:
           RTC_NOTREACHED();
           break;
       }
 #elif defined(WEBRTC_IOS)
-      ASSERT_EQ(kVideoCodecH264, codec_type)
+      ASSERT_EQ(kVideoCodecH264, config_.codec_settings->codecType)
           << "iOS HW codecs only support H264.";
       encoder_.reset(new H264VideoToolboxEncoder(
           cricket::VideoCodec(cricket::kH264CodecName)));
       decoder_.reset(new H264VideoToolboxDecoder());
 #else
       RTC_NOTREACHED() << "Only support HW codecs on Android and iOS.";
 #endif
 #endif  // WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED
       RTC_CHECK(encoder_) << "HW encoder not successfully created.";
       RTC_CHECK(decoder_) << "HW decoder not successfully created.";
       return;
     }
 
     // SW codecs.
-    switch (codec_type) {
+    switch (config_.codec_settings->codecType) {
       case kVideoCodecH264:
         encoder_.reset(
             H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName)));
         decoder_.reset(H264Decoder::Create());
         break;
       case kVideoCodecVP8:
         encoder_.reset(VP8Encoder::Create());
         decoder_.reset(VP8Decoder::Create());
         break;
       case kVideoCodecVP9:
         encoder_.reset(VP9Encoder::Create());
         decoder_.reset(VP9Decoder::Create());
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
   }
 
-  void SetUpCodecConfig(const CodecParams& process,
+  void SetUpCodecConfig(const ProcessParams& process,
                         const VisualizationParams* visualization_params) {
-    CreateEncoderAndDecoder(process.hw_codec, process.codec_type);
+    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, process.width, process.height);
+        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 =
-        packet_loss_probability_;
-
-    // Configure codec settings.
-    VideoCodingModule::Codec(process.codec_type, &codec_settings_);
-    config_.codec_settings = &codec_settings_;
-    config_.codec_settings->startBitrate = start_bitrate_;
-    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 =
-            process.frame_dropper_on;
-        config_.codec_settings->H264()->keyFrameInterval =
-            kBaseKeyFrameInterval;
-        break;
-      case kVideoCodecVP8:
-        config_.codec_settings->VP8()->errorConcealmentOn =
-            process.error_concealment_on;
-        config_.codec_settings->VP8()->denoisingOn = process.denoising_on;
-        config_.codec_settings->VP8()->numberOfTemporalLayers =
-            num_temporal_layers_;
-        config_.codec_settings->VP8()->frameDroppingOn =
-            process.frame_dropper_on;
-        config_.codec_settings->VP8()->automaticResizeOn =
-            process.spatial_resize_on;
-        config_.codec_settings->VP8()->keyFrameInterval = kBaseKeyFrameInterval;
-        config_.codec_settings->VP8()->resilience =
-            process.resilience_on ? kResilientStream : kResilienceOff;
-        break;
-      case kVideoCodecVP9:
-        config_.codec_settings->VP9()->denoisingOn = process.denoising_on;
-        config_.codec_settings->VP9()->numberOfTemporalLayers =
-            num_temporal_layers_;
-        config_.codec_settings->VP9()->frameDroppingOn =
-            process.frame_dropper_on;
-        config_.codec_settings->VP9()->automaticResizeOn =
-            process.spatial_resize_on;
-        config_.codec_settings->VP9()->keyFrameInterval = kBaseKeyFrameInterval;
-        config_.codec_settings->VP9()->resilienceOn = process.resilience_on;
-        break;
-      default:
-        RTC_NOTREACHED();
-        break;
-    }
+        process.packet_loss_probability;
 
     // 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 +
-          "_cd-" + CodecTypeToPayloadName(process.codec_type).value_or("") +
+          "_cd-" + CodecTypeToPayloadName(
+              config_.codec_settings->codecType).value_or("") +
           "_hw-" + std::to_string(process.hw_codec) +
           "_fr-" + std::to_string(start_frame_rate_) +
-          "_br-" + std::to_string(static_cast<int>(start_bitrate_));
+          "_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());
       }
       if (visualization_params->save_encoded_ivf) {
         rtc::File post_encode_file =
             rtc::File::Create(output_filename_base + "_encoded.ivf");
@@ skipping 158 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 CodecParams& process, int frame_number) {
-    if (!process.hw_codec && (process.codec_type == kVideoCodecVP8 ||
-      process.codec_type == kVideoCodecVP9)) {
+  void VerifyQpParser(const ProcessParams& process, int frame_number) {
+    if (!process.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;
+    } else if (codec_settings->codecType == kVideoCodecVP9) {
+      return codec_settings->VP9().numberOfTemporalLayers;
+    } else {
+      return 1;
+    }
+  }
+
   // Temporal layer index corresponding to frame number, for up to 3 layers.
   int TemporalLayerIndexForFrame(int frame_number) {
     int tl_idx = -1;
     switch (num_temporal_layers_) {
       case 1:
         tl_idx = 0;
         break;
       case 2:
         // temporal layer 0:  0     2     4 ...
         // temporal layer 1:     1     3
@@ skipping 40 matching lines @@
     }
   }
 
   // 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,
-                              CodecParams process,
+                              ProcessParams process,
                               RateControlThresholds* rc_thresholds,
                               const VisualizationParams* visualization_params) {
     // Codec/config settings.
-    start_bitrate_ = rate_profile.target_bit_rate[0];
+    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];
-    packet_loss_probability_ = process.packet_loss_probability;
-    num_temporal_layers_ = process.num_temporal_layers;
     SetUpCodecConfig(process, 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_);
 
@@ skipping 95 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 SetCodecParams(CodecParams* process_settings,
-                             VideoCodecType codec_type,
-                             bool hw_codec,
-                             bool use_single_core,
-                             float packet_loss_probability,
-                             int key_frame_interval,
-                             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,
-                             const std::string& filename,
-                             bool verbose_logging,
-                             bool batch_mode) {
-    process_settings->codec_type = codec_type;
-    process_settings->hw_codec = hw_codec;
-    process_settings->use_single_core = use_single_core;
-    process_settings->packet_loss_probability = packet_loss_probability;
-    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->resilience_on = resilience_on;
-    process_settings->width = width;
-    process_settings->height = height;
-    process_settings->filename = filename;
-    process_settings->verbose_logging = verbose_logging;
-    process_settings->batch_mode = batch_mode;
-  }
-
-  static void SetCodecParams(CodecParams* process_settings,
-                             VideoCodecType codec_type,
-                             bool hw_codec,
-                             bool use_single_core,
-                             float packet_loss_probability,
-                             int key_frame_interval,
-                             int num_temporal_layers,
-                             bool error_concealment_on,
-                             bool denoising_on,
-                             bool frame_dropper_on,
-                             bool spatial_resize_on,
-                             bool resilience_on) {
-    SetCodecParams(process_settings, codec_type, hw_codec, use_single_core,
-                   packet_loss_probability, key_frame_interval,
-                   num_temporal_layers, error_concealment_on, denoising_on,
-                   frame_dropper_on, spatial_resize_on, resilience_on,
-                   kCifWidth, kCifHeight, kFilenameForemanCif,
-                   false /* verbose_logging */, false /* 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,
+                               int height) {
+    VideoCodingModule::Codec(codec_type, codec_settings);
+    config->codec_settings = codec_settings;
+    config->codec_settings->width = width;
+    config->codec_settings->height = height;
+    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 =
+            error_concealment_on;
+        config->codec_settings->VP8()->denoisingOn = denoising_on;
+        config->codec_settings->VP8()->numberOfTemporalLayers =
+            num_temporal_layers;
+        config->codec_settings->VP8()->frameDroppingOn = frame_dropper_on;
+        config->codec_settings->VP8()->automaticResizeOn = spatial_resize_on;
+        config->codec_settings->VP8()->keyFrameInterval = kBaseKeyFrameInterval;
+        config->codec_settings->VP8()->resilience =
+            resilience_on ? kResilientStream : kResilienceOff;
+        break;
+      case kVideoCodecVP9:
+        config->codec_settings->VP9()->denoisingOn = denoising_on;
+        config->codec_settings->VP9()->numberOfTemporalLayers =
+            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;
@@ skipping 67 matching lines @@
   float encoding_bitrate_total_;
   float perc_encoding_rate_mismatch_;
   int num_frames_to_hit_target_;
   bool encoding_rate_within_target_;
   int bit_rate_;
   int frame_rate_;
   float target_size_key_frame_initial_;
   float target_size_key_frame_;
   float sum_key_frame_size_mismatch_;
   int num_key_frames_;
-  float start_bitrate_;
   int start_frame_rate_;
 
   // Codec and network settings.
-  float packet_loss_probability_;
   int num_temporal_layers_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_