Step #3: Add flag for correctness mode in VideoProcessor integration tests.

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.
  */
 
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_
 
 #include <math.h>
 
+#include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 
 #if defined(WEBRTC_ANDROID)
 #include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h"
 #include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
 #include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
 #elif defined(WEBRTC_IOS)
 #include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_decoder.h"
@@ skipping 60 matching lines @@
   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.
+// Thresholds for the quality metrics. Defaults are maximally minimal.
 struct QualityThresholds {
-  double min_avg_psnr;
-  double min_min_psnr;
-  double min_avg_ssim;
-  double 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;
 };
 
 // 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;
 };
 
 // Thresholds for the rate control metrics. The rate mismatch thresholds are
 // defined as percentages. |max_time_hit_target| is defined as number of frames,
 // after a rate update is made to the encoder, for the encoder to reach within
 // |kPercTargetvsActualMismatch| of new target rate. The thresholds are defined
 // for each rate update sequence.
 struct RateControlThresholds {
   int max_num_dropped_frames;
   int max_key_frame_size_mismatch;
   int max_delta_frame_size_mismatch;
   int max_encoding_rate_mismatch;
   int max_time_hit_target;
-  int num_spatial_resizes;
-  int num_key_frames;
+  int num_spatial_resizes;  // Set to -1 to disable check.
+  int num_key_frames;       // Set to -1 to disable check.
 };
 
 // Should video files be saved persistently to disk for post-run visualization?
 struct VisualizationParams {
   bool save_source_y4m;
   bool save_encoded_ivf;
   bool save_decoded_y4m;
 };
 
 #if !defined(WEBRTC_IOS)
@@ skipping 330 matching lines @@
           encoding_bitrate_[i], perc_frame_size_mismatch,
           perc_encoding_rate_mismatch, num_frames_per_update_[i]);
       EXPECT_LE(perc_frame_size_mismatch,
                 rc_expected.max_delta_frame_size_mismatch);
       EXPECT_LE(perc_encoding_rate_mismatch,
                 rc_expected.max_encoding_rate_mismatch);
     }
     printf("\n");
     EXPECT_LE(num_frames_to_hit_target_, rc_expected.max_time_hit_target);
     EXPECT_LE(num_dropped_frames, rc_expected.max_num_dropped_frames);
-    EXPECT_EQ(rc_expected.num_spatial_resizes, num_resize_actions);
-    EXPECT_EQ(rc_expected.num_key_frames, num_key_frames_);
+    if (rc_expected.num_spatial_resizes >= 0) {
+      EXPECT_EQ(rc_expected.num_spatial_resizes, num_resize_actions);
+    }
+    if (rc_expected.num_key_frames >= 0) {
+      EXPECT_EQ(rc_expected.num_key_frames, num_key_frames_);
+    }
   }
 
   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);
   }
@@ skipping 45 matching lines @@
       }
       frame_rate_layer_[i] =
           frame_rate_ / static_cast<float>(1 << (num_temporal_layers_ - 1));
     }
     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,
                               CodecParams process,
                               RateControlThresholds* rc_thresholds,
                               const VisualizationParams* visualization_params) {
     // Codec/config settings.
     start_bitrate_ = 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;
@@ skipping 254 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_