Make error resilience configurable through VideoCodecVP9 resilience setting.

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 63 matching lines @@
 
   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.
@@ skipping 181 matching lines @@
         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;
     }
 
     // Create file objects for quality analysis.
     analysis_frame_reader_.reset(new test::YuvFrameReaderImpl(
         config_.input_filename, config_.codec_settings->width,
         config_.codec_settings->height));
@@ skipping 384 matching lines @@
                              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 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, kCifWidth, kCifHeight,
-                   kFilenameForemanCif, false /* verbose_logging */,
-                   false /* batch_mode */);
+                   frame_dropper_on, spatial_resize_on, resilience_on,
+                   kCifWidth, kCifHeight, kFilenameForemanCif,
+                   false /* verbose_logging */, false /* batch_mode */);
   }
 
   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 79 matching lines @@
 
   // 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_