Style fixes: VideoProcessor and corresponding integration test.

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 <memory>
 #include <string>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/test/packet_manipulator.h"
 #include "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/test/gtest.h"
@@ skipping 61 matching lines @@
   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;
 };
 
 #if !defined(WEBRTC_IOS)
-const int kNbrFramesShort = 100;  // Some tests are run for shorter sequence.
+const int kNumFramesShort = 100;
 #endif
-const int kNbrFramesLong = 299;
+const int kNumFramesLong = 299;
 
 // Parameters from VP8 wrapper, which control target size of key frames.
 const float kInitialBufferSize = 0.5f;
 const float kOptimalBufferSize = 0.6f;
 const float kScaleKeyFrameSize = 0.5f;
 
 // Integration test for video processor. Encodes+decodes a clip and
 // writes it to the output directory. After completion, quality metrics
 // (PSNR and SSIM) and rate control metrics are computed to verify that the
 // quality and encoder response is acceptable. The rate control tests allow us
 // to verify the behavior for changing bitrate, changing frame rate, frame
 // dropping/spatial resize, and temporal layers. The limits for the rate
 // control metrics are set to be fairly conservative, so failure should only
 // happen when some significant regression or breakdown occurs.
 class VideoProcessorIntegrationTest : public testing::Test {
  protected:
-  std::unique_ptr<VideoEncoder> encoder_;
-  std::unique_ptr<VideoDecoder> decoder_;
-  std::unique_ptr<test::FrameReader> frame_reader_;
-  std::unique_ptr<test::FrameWriter> frame_writer_;
-  test::PacketReader packet_reader_;
-  std::unique_ptr<test::PacketManipulator> packet_manipulator_;
-  test::Stats stats_;
-  test::TestConfig config_;
-  VideoCodec codec_settings_;
-  std::unique_ptr<test::VideoProcessor> processor_;
-  TemporalLayersFactory tl_factory_;
-
-  // Quantities defined/updated for every encoder rate update.
-  // Some quantities defined per temporal layer (at most 3 layers in this test).
-  int num_frames_per_update_[3];
-  float sum_frame_size_mismatch_[3];
-  float sum_encoded_frame_size_[3];
-  float encoding_bitrate_[3];
-  float per_frame_bandwidth_[3];
-  float bit_rate_layer_[3];
-  float frame_rate_layer_[3];
-  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 layer_;
-  float target_size_key_frame_initial_;
-  float target_size_key_frame_;
-  float sum_key_frame_size_mismatch_;
-  int num_key_frames_;
-  float start_bitrate_;
-
-  // Codec and network settings.
-  VideoCodecType codec_type_;
-  float packet_loss_;
-  int num_temporal_layers_;
-  int key_frame_interval_;
-  bool error_concealment_on_;
-  bool denoising_on_;
-  bool frame_dropper_on_;
-  bool spatial_resize_on_;
-
   VideoProcessorIntegrationTest() {}
   virtual ~VideoProcessorIntegrationTest() {}
 
   void SetUpCodecConfig(const std::string& filename,
                         int width,
                         int height,
                         bool verbose_logging) {
     if (codec_type_ == kVideoCodecH264) {
       encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
       decoder_.reset(H264Decoder::Create());
@@ skipping 48 matching lines @@
         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;
         break;
       default:
-        assert(false);
+        RTC_NOTREACHED();
         break;
     }
     frame_reader_.reset(new test::FrameReaderImpl(
         config_.input_filename, config_.codec_settings->width,
         config_.codec_settings->height));
     frame_writer_.reset(new test::FrameWriterImpl(
         config_.output_filename, config_.frame_length_in_bytes));
-    ASSERT_TRUE(frame_reader_->Init());
-    ASSERT_TRUE(frame_writer_->Init());
+    RTC_CHECK(frame_reader_->Init());
+    RTC_CHECK(frame_writer_->Init());
 
     packet_manipulator_.reset(new test::PacketManipulatorImpl(
         &packet_reader_, config_.networking_config, config_.verbose));
     processor_.reset(new test::VideoProcessorImpl(
         encoder_.get(), decoder_.get(), frame_reader_.get(),
         frame_writer_.get(), packet_manipulator_.get(), config_, &stats_));
-    ASSERT_TRUE(processor_->Init());
+    RTC_CHECK(processor_->Init());
   }
 
   // Reset quantities after each encoder update, update the target
   // per-frame bandwidth.
   void ResetRateControlMetrics(int num_frames) {
     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;
@@ skipping 134 matching lines @@
       // layer 1:        2            6
       // layer 2:     1      3     5      7
       if (frame_number % 4 == 0) {
         layer_ = 0;
       } else if ((frame_number + 2) % 4 == 0) {
         layer_ = 1;
       } else if ((frame_number + 1) % 2 == 0) {
         layer_ = 2;
       }
     } else {
-      assert(false);  // Only up to 3 layers.
+      RTC_NOTREACHED() << "Max 3 layers are supported.";
     }
   }
 
   // Set the bitrate and frame rate per layer, for up to 3 layers.
   void SetLayerRates() {
-    assert(num_temporal_layers_ <= 3);
+    RTC_DCHECK_LE(num_temporal_layers_, 3);
     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;
       } else {
         bit_rate_layer_[i] = bit_rate_ * bit_rate_ratio;
@@ skipping 24 matching lines @@
     SetUpCodecConfig(process.filename, process.width, process.height,
                      process.verbose_logging);
     // Update the layers and the codec with the initial rates.
     bit_rate_ = rate_profile.target_bit_rate[0];
     frame_rate_ = rate_profile.input_frame_rate[0];
     SetLayerRates();
     // 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_);
+
     // Process each frame, up to |num_frames|.
     int num_frames = rate_profile.num_frames;
     int update_index = 0;
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
     int frame_number = 0;
     FrameType frame_type = kVideoFrameDelta;
     while (processor_->ProcessFrame(frame_number) &&
            frame_number < num_frames) {
       // Get the layer index for the frame |frame_number|.
@@ skipping 35 matching lines @@
                       rc_metrics[update_index].max_time_hit_target,
                       rc_metrics[update_index].max_num_dropped_frames,
                       rc_metrics[update_index].num_spatial_resizes,
                       rc_metrics[update_index].num_key_frames);
     EXPECT_EQ(num_frames, frame_number);
     EXPECT_EQ(num_frames + 1, static_cast<int>(stats_.stats_.size()));
 
     // Release encoder and decoder to make sure they have finished processing:
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Release());
+
     // Close the files before we start using them for SSIM/PSNR calculations.
     frame_reader_->Close();
     frame_writer_->Close();
 
     // TODO(marpan): should compute these quality metrics per SetRates update.
     test::QualityMetricsResult psnr_result, ssim_result;
     EXPECT_EQ(0, test::I420MetricsFromFiles(config_.input_filename.c_str(),
                                             config_.output_filename.c_str(),
                                             config_.codec_settings->width,
                                             config_.codec_settings->height,
@@ skipping 89 matching lines @@
     rc_metrics[update_index].max_key_frame_size_mismatch =
         max_key_frame_size_mismatch;
     rc_metrics[update_index].max_delta_frame_size_mismatch =
         max_delta_frame_size_mismatch;
     rc_metrics[update_index].max_encoding_rate_mismatch =
         max_encoding_rate_mismatch;
     rc_metrics[update_index].max_time_hit_target = max_time_hit_target;
     rc_metrics[update_index].num_spatial_resizes = num_spatial_resizes;
     rc_metrics[update_index].num_key_frames = num_key_frames;
   }
+
+  std::unique_ptr<VideoEncoder> encoder_;
+  std::unique_ptr<VideoDecoder> decoder_;
+  std::unique_ptr<test::FrameReader> frame_reader_;
+  std::unique_ptr<test::FrameWriter> frame_writer_;
+  test::PacketReader packet_reader_;
+  std::unique_ptr<test::PacketManipulator> packet_manipulator_;
+  test::Stats stats_;
+  test::TestConfig config_;
+  VideoCodec codec_settings_;
+  std::unique_ptr<test::VideoProcessor> processor_;
+  TemporalLayersFactory tl_factory_;
+
+  // Quantities defined/updated for every encoder rate update.
+  // Some quantities defined per temporal layer (at most 3 layers in this test).
+  int num_frames_per_update_[3];
+  float sum_frame_size_mismatch_[3];
+  float sum_encoded_frame_size_[3];
+  float encoding_bitrate_[3];
+  float per_frame_bandwidth_[3];
+  float bit_rate_layer_[3];
+  float frame_rate_layer_[3];
+  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 layer_;
+  float target_size_key_frame_initial_;
+  float target_size_key_frame_;
+  float sum_key_frame_size_mismatch_;
+  int num_key_frames_;
+  float start_bitrate_;
+
+  // Codec and network settings.
+  VideoCodecType codec_type_;
+  float packet_loss_;
+  int num_temporal_layers_;
+  int key_frame_interval_;
+  bool error_concealment_on_;
+  bool denoising_on_;
+  bool frame_dropper_on_;
+  bool spatial_resize_on_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_