VideoProcessorIntegrationTest: mini-fixes in preparation for task queue CL.

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 155 matching lines @@
         // TODO(brandtr): Generalize so that we support multiple profiles here.
         encoder_ = encoder_factory_->CreateVideoEncoder(
             cricket::VideoCodec(cricket::kH264CodecName));
         decoder_ = decoder_factory_->CreateVideoDecoder(kVideoCodecH264);
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
 
-    RTC_CHECK(encoder_) << "Encoder not successfully created.";
-    RTC_CHECK(decoder_) << "Decoder not successfully created.";
+    EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
+    EXPECT_TRUE(decoder_) << "Decoder not successfully created.";
   }
 
   void DestroyEncoderAndDecoder() {
     encoder_factory_->DestroyVideoEncoder(encoder_);
     decoder_factory_->DestroyVideoDecoder(decoder_);
   }
 
   void SetUpObjects(const VisualizationParams* visualization_params,
                     const int initial_bitrate_kbps,
                     const int initial_framerate_fps) {
     CreateEncoderAndDecoder();
 
     // Create file objects for quality analysis.
     analysis_frame_reader_.reset(new YuvFrameReaderImpl(
         config_.input_filename, config_.codec_settings.width,
         config_.codec_settings.height));
     analysis_frame_writer_.reset(new YuvFrameWriterImpl(
         config_.output_filename, config_.codec_settings.width,
         config_.codec_settings.height));
-    RTC_CHECK(analysis_frame_reader_->Init());
-    RTC_CHECK(analysis_frame_writer_->Init());
+    EXPECT_TRUE(analysis_frame_reader_->Init());
+    EXPECT_TRUE(analysis_frame_writer_->Init());
 
     if (visualization_params) {
       const std::string codec_name =
           CodecTypeToPayloadName(config_.codec_settings.codecType)
               .value_or("unknown");
       const std::string implementation_type = config_.hw_codec ? "hw" : "sw";
       // clang-format off
       const std::string output_filename_base =
           OutputPath() + config_.filename + "-" +
           codec_name + "-" + implementation_type + "-" +
           std::to_string(initial_bitrate_kbps);
       // clang-format on
       if (visualization_params->save_encoded_ivf) {
         rtc::File post_encode_file =
-            rtc::File::Create(output_filename_base + "_encoded.ivf");
+            rtc::File::Create(output_filename_base + ".ivf");
         encoded_frame_writer_ =
             IvfFileWriter::Wrap(std::move(post_encode_file), 0);
       }
       if (visualization_params->save_decoded_y4m) {
         decoded_frame_writer_.reset(new Y4mFrameWriterImpl(
-            output_filename_base + "_decoded.y4m", config_.codec_settings.width,
+            output_filename_base + ".y4m", config_.codec_settings.width,
             config_.codec_settings.height, initial_framerate_fps));
-        RTC_CHECK(decoded_frame_writer_->Init());
+        EXPECT_TRUE(decoded_frame_writer_->Init());
       }
     }
 
     packet_manipulator_.reset(new PacketManipulatorImpl(
         &packet_reader_, config_.networking_config, config_.verbose));
     processor_ = rtc::MakeUnique<VideoProcessor>(
         encoder_, decoder_, analysis_frame_reader_.get(),
         analysis_frame_writer_.get(), packet_manipulator_.get(), config_,
         &stats_, encoded_frame_writer_.get(), decoded_frame_writer_.get());
     processor_->Init();
   }
 
   // Reset quantities after each encoder update, update the target per-frame
   // bandwidth.
   void ResetRateControlMetrics(int num_frames_to_hit_target) {
     const int num_temporal_layers =
         NumberOfTemporalLayers(config_.codec_settings);
     for (int i = 0; i < num_temporal_layers; i++) {
       num_frames_per_update_[i] = 0;
       sum_frame_size_mismatch_[i] = 0.0f;
       sum_encoded_frame_size_[i] = 0.0f;
       encoding_bitrate_[i] = 0.0f;
       // Update layer per-frame-bandwidth.
-      per_frame_bandwidth_[i] = static_cast<float>(bit_rate_layer_[i]) /
-                                static_cast<float>(frame_rate_layer_[i]);
+      per_frame_bandwidth_[i] = static_cast<float>(bitrate_layer_[i]) /
+                                static_cast<float>(framerate_layer_[i]);
     }
     // Set maximum size of key frames, following setting in the VP8 wrapper.
-    float max_key_size = kScaleKeyFrameSize * kOptimalBufferSize * frame_rate_;
+    float max_key_size = kScaleKeyFrameSize * kOptimalBufferSize * framerate_;
     // We don't know exact target size of the key frames (except for first one),
     // but the minimum in libvpx is ~|3 * per_frame_bandwidth| and maximum is
     // set by |max_key_size_ * per_frame_bandwidth|. Take middle point/average
     // as reference for mismatch. Note key frames always correspond to base
     // layer frame in this test.
     target_size_key_frame_ = 0.5 * (3 + max_key_size) * per_frame_bandwidth_[0];
     num_frames_total_ = 0;
     sum_encoded_frame_size_total_ = 0.0f;
     encoding_bitrate_total_ = 0.0f;
     perc_encoding_rate_mismatch_ = 0.0f;
@@ skipping 24 matching lines @@
       float target_size = (frame_number == 0) ? target_size_key_frame_initial_
                                               : target_size_key_frame_;
       sum_key_frame_size_mismatch_ +=
           fabs(encoded_size_kbits - target_size) / target_size;
       num_key_frames_ += 1;
     }
     sum_encoded_frame_size_[tl_idx] += encoded_size_kbits;
     // Encoding bit rate per temporal layer: from the start of the update/run
     // to the current frame.
     encoding_bitrate_[tl_idx] = sum_encoded_frame_size_[tl_idx] *
-                                frame_rate_layer_[tl_idx] /
+                                framerate_layer_[tl_idx] /
                                 num_frames_per_update_[tl_idx];
     // Total encoding rate: from the start of the update/run to current frame.
     sum_encoded_frame_size_total_ += encoded_size_kbits;
     encoding_bitrate_total_ =
-        sum_encoded_frame_size_total_ * frame_rate_ / num_frames_total_;
+        sum_encoded_frame_size_total_ * framerate_ / num_frames_total_;
     perc_encoding_rate_mismatch_ =
-        100 * fabs(encoding_bitrate_total_ - bit_rate_) / bit_rate_;
+        100 * fabs(encoding_bitrate_total_ - bitrate_kbps_) / bitrate_kbps_;
     if (perc_encoding_rate_mismatch_ < kPercTargetvsActualMismatch &&
         !encoding_rate_within_target_) {
       num_frames_to_hit_target_ = num_frames_total_;
       encoding_rate_within_target_ = true;
     }
   }
 
   // Verify expected behavior of rate control and print out data.
-  void VerifyRateControlMetrics(int update_index,
+  void VerifyRateControlMetrics(int rate_update_index,
                                 const RateControlThresholds& rc_expected) {
     int num_dropped_frames = processor_->NumberDroppedFrames();
     int num_resize_actions = processor_->NumberSpatialResizes();
     printf(
         "Rate update #%d:\n"
         " Target bitrate         : %d\n"
         " Encoded bitrate        : %f\n"
         " Frame rate             : %d\n",
-        update_index, bit_rate_, encoding_bitrate_total_, frame_rate_);
+        rate_update_index, bitrate_kbps_, encoding_bitrate_total_, framerate_);
     printf(
         " # processed frames     : %d\n"
         " # frames to convergence: %d\n"
         " # dropped frames       : %d\n"
         " # spatial resizes      : %d\n",
         num_frames_total_, num_frames_to_hit_target_, num_dropped_frames,
         num_resize_actions);
+
     EXPECT_LE(perc_encoding_rate_mismatch_,
               rc_expected.max_encoding_rate_mismatch);
     if (num_key_frames_ > 0) {
       int perc_key_frame_size_mismatch =
           100 * sum_key_frame_size_mismatch_ / num_key_frames_;
       printf(
           " # key frames           : %d\n"
           " Key frame rate mismatch: %d\n",
           num_key_frames_, perc_key_frame_size_mismatch);
       EXPECT_LE(perc_key_frame_size_mismatch,
                 rc_expected.max_key_frame_size_mismatch);
     }
+
     const int num_temporal_layers =
         NumberOfTemporalLayers(config_.codec_settings);
     for (int i = 0; i < num_temporal_layers; i++) {
-      printf(" Temporal layer #%d:\n", i);
       int perc_frame_size_mismatch =
           100 * sum_frame_size_mismatch_[i] / num_frames_per_update_[i];
       int perc_encoding_rate_mismatch =
-          100 * fabs(encoding_bitrate_[i] - bit_rate_layer_[i]) /
-          bit_rate_layer_[i];
+          100 * fabs(encoding_bitrate_[i] - bitrate_layer_[i]) /
+          bitrate_layer_[i];
       printf(
+          " Temporal layer #%d:\n"
           "  Target layer bitrate                : %f\n"
           "  Layer frame rate                    : %f\n"
           "  Layer per frame bandwidth           : %f\n"
           "  Layer encoding bitrate              : %f\n"
           "  Layer percent frame size mismatch   : %d\n"
           "  Layer percent encoding rate mismatch: %d\n"
-          "  # frame processed per layer         : %d\n",
-          bit_rate_layer_[i], frame_rate_layer_[i], per_frame_bandwidth_[i],
+          "  # frames processed per layer        : %d\n",
+          i, bitrate_layer_[i], framerate_layer_[i], per_frame_bandwidth_[i],
           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);
     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 QualityMetricsResult& psnr_result,
-                     const QualityMetricsResult& ssim_result,
-                     const QualityThresholds& quality_thresholds) {
+  static void VerifyQuality(const QualityMetricsResult& psnr_result,
+                            const 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(int frame_number) {
     if (!config_.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) {
+  static 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.
@@ skipping 33 matching lines @@
   void SetTemporalLayerRates() {
     const int num_temporal_layers =
         NumberOfTemporalLayers(config_.codec_settings);
     RTC_DCHECK_LE(num_temporal_layers, kMaxNumTemporalLayers);
     for (int i = 0; i < num_temporal_layers; i++) {
       float bit_rate_ratio = kVp8LayerRateAlloction[num_temporal_layers - 1][i];
       if (i > 0) {
         float bit_rate_delta_ratio =
             kVp8LayerRateAlloction[num_temporal_layers - 1][i] -
             kVp8LayerRateAlloction[num_temporal_layers - 1][i - 1];
-        bit_rate_layer_[i] = bit_rate_ * bit_rate_delta_ratio;
+        bitrate_layer_[i] = bitrate_kbps_ * bit_rate_delta_ratio;
       } else {
-        bit_rate_layer_[i] = bit_rate_ * bit_rate_ratio;
+        bitrate_layer_[i] = bitrate_kbps_ * bit_rate_ratio;
       }
-      frame_rate_layer_[i] =
-          frame_rate_ / static_cast<float>(1 << (num_temporal_layers - 1));
+      framerate_layer_[i] =
+          framerate_ / static_cast<float>(1 << (num_temporal_layers - 1));
     }
     if (num_temporal_layers == 3) {
-      frame_rate_layer_[2] = frame_rate_ / 2.0f;
+      framerate_layer_[2] = framerate_ / 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(const QualityThresholds& quality_thresholds,
                               const RateProfile& rate_profile,
                               RateControlThresholds* rc_thresholds,
                               const VisualizationParams* visualization_params) {
     config_.codec_settings.startBitrate = rate_profile.target_bit_rate[0];
     SetUpObjects(visualization_params, rate_profile.target_bit_rate[0],
                  rate_profile.input_frame_rate[0]);
 
     // Set initial rates.
-    bit_rate_ = rate_profile.target_bit_rate[0];
-    frame_rate_ = rate_profile.input_frame_rate[0];
+    bitrate_kbps_ = rate_profile.target_bit_rate[0];
+    framerate_ = 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_);
+        0.5 * kInitialBufferSize * bitrate_layer_[0];
+    processor_->SetRates(bitrate_kbps_, framerate_);
 
     // Process each frame, up to |num_frames|.
     int frame_number = 0;
     int update_index = 0;
     int num_frames = rate_profile.num_frames;
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
 
     if (config_.batch_mode) {
       // In batch mode, we calculate the metrics for all frames after all frames
@@ skipping 31 matching lines @@
         ++frame_number;
 
         // If we hit another/next update, verify stats for current state and
         // update layers and codec with new rates.
         if (frame_number ==
             rate_profile.frame_index_rate_update[update_index + 1]) {
           VerifyRateControlMetrics(update_index, rc_thresholds[update_index]);
 
           // Update layer rates and the codec with new rates.
           ++update_index;
-          bit_rate_ = rate_profile.target_bit_rate[update_index];
-          frame_rate_ = rate_profile.input_frame_rate[update_index];
+          bitrate_kbps_ = rate_profile.target_bit_rate[update_index];
+          framerate_ = rate_profile.input_frame_rate[update_index];
           SetTemporalLayerRates();
           ResetRateControlMetrics(
               rate_profile.frame_index_rate_update[update_index + 1]);
-          processor_->SetRates(bit_rate_, frame_rate_);
+          processor_->SetRates(bitrate_kbps_, framerate_);
         }
       }
       // TODO(brandtr): Refactor "frame number accounting" so we don't have to
       // call ProcessFrame one extra time here.
       processor_->ProcessFrame(frame_number);
     }
 
     // Verify rate control metrics for all frames (if in batch mode), or for all
     // frames since the last rate update (if not in batch mode).
     VerifyRateControlMetrics(update_index, rc_thresholds[update_index]);
@@ skipping 96 matching lines @@
       default:
         RTC_NOTREACHED();
         break;
     }
 
     config->frame_length_in_bytes =
         CalcBufferSize(VideoType::kI420, width, height);
   }
 
   static void SetRateProfile(RateProfile* rate_profile,
-                             int update_index,
-                             int bit_rate,
-                             int frame_rate,
+                             int rate_update_index,
+                             int bitrate_kbps,
+                             int framerate_fps,
                              int frame_index_rate_update) {
-    rate_profile->target_bit_rate[update_index] = bit_rate;
-    rate_profile->input_frame_rate[update_index] = frame_rate;
-    rate_profile->frame_index_rate_update[update_index] =
+    rate_profile->target_bit_rate[rate_update_index] = bitrate_kbps;
+    rate_profile->input_frame_rate[rate_update_index] = framerate_fps;
+    rate_profile->frame_index_rate_update[rate_update_index] =
         frame_index_rate_update;
   }
 
   static void SetRateControlThresholds(RateControlThresholds* rc_thresholds,
                                        int update_index,
                                        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,
@@ skipping 29 matching lines @@
   std::unique_ptr<PacketManipulator> packet_manipulator_;
   Stats stats_;
   std::unique_ptr<VideoProcessor> processor_;
 
   // Quantities defined/updated for every encoder rate update.
   int num_frames_per_update_[kMaxNumTemporalLayers];
   float sum_frame_size_mismatch_[kMaxNumTemporalLayers];
   float sum_encoded_frame_size_[kMaxNumTemporalLayers];
   float encoding_bitrate_[kMaxNumTemporalLayers];
   float per_frame_bandwidth_[kMaxNumTemporalLayers];
-  float bit_rate_layer_[kMaxNumTemporalLayers];
-  float frame_rate_layer_[kMaxNumTemporalLayers];
+  float bitrate_layer_[kMaxNumTemporalLayers];
+  float framerate_layer_[kMaxNumTemporalLayers];
   int num_frames_total_;
   float sum_encoded_frame_size_total_;
   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_;
+  int bitrate_kbps_;
+  int framerate_;
   float target_size_key_frame_initial_;
   float target_size_key_frame_;
   float sum_key_frame_size_mismatch_;
   int num_key_frames_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_