Use std::unique_ptr in VideoProcessorIntegrationTest.

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc

 /*
  *  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.
  */
 
 #include <math.h>
 
+#include <memory>
+
 #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"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/frame_reader.h"
 #include "webrtc/test/testsupport/frame_writer.h"
 #include "webrtc/test/testsupport/metrics/video_metrics.h"
 #include "webrtc/test/testsupport/packet_reader.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-
+namespace {
 // 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;
 
 const int kPercTargetvsActualMismatch = 20;
 const int kBaseKeyFrameInterval = 3000;
 
 // Codec and network settings.
 struct CodecConfigPars {
   VideoCodecType codec_type;
@@ skipping 45 matching lines @@
 #if !defined(WEBRTC_IOS)
 const int kNbrFramesShort = 100;  // Some tests are run for shorter sequence.
 #endif
 const int kNbrFramesLong = 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;
 
+void SetRateProfilePars(RateProfile* rate_profile,
+                        int update_index,
+                        int bit_rate,
+                        int frame_rate,
+                        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] = frame_index_rate_update;
+}
+
+void SetCodecParameters(CodecConfigPars* process_settings,
+                        VideoCodecType codec_type,
+                        float packet_loss,
+                        int key_frame_interval,
+                        int num_temporal_layers,
+                        bool error_concealment_on,
+                        bool denoising_on,
+                        bool frame_dropper_on,
+                        bool spatial_resize_on) {
+  process_settings->codec_type = codec_type;
+  process_settings->packet_loss = packet_loss;
+  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;
+}
+
+void SetQualityMetrics(QualityMetrics* quality_metrics,
+                       double minimum_avg_psnr,
+                       double minimum_min_psnr,
+                       double minimum_avg_ssim,
+                       double minimum_min_ssim) {
+  quality_metrics->minimum_avg_psnr = minimum_avg_psnr;
+  quality_metrics->minimum_min_psnr = minimum_min_psnr;
+  quality_metrics->minimum_avg_ssim = minimum_avg_ssim;
+  quality_metrics->minimum_min_ssim = minimum_min_ssim;
+}
+
+void SetRateControlMetrics(RateControlMetrics* rc_metrics,
+                           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,
+                           int num_spatial_resizes,
+                           int num_key_frames) {
+  rc_metrics[update_index].max_num_dropped_frames = max_num_dropped_frames;
+  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;
+}
+}  // namespace
+
 // 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:
-  VideoEncoder* encoder_;
-  VideoDecoder* decoder_;
-  webrtc::test::FrameReader* frame_reader_;
-  webrtc::test::FrameWriter* frame_writer_;
-  webrtc::test::PacketReader packet_reader_;
-  webrtc::test::PacketManipulator* packet_manipulator_;
-  webrtc::test::Stats stats_;
-  webrtc::test::TestConfig config_;
+  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_;
-  webrtc::test::VideoProcessor* processor_;
+  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];
@@ skipping 21 matching lines @@
   bool error_concealment_on_;
   bool denoising_on_;
   bool frame_dropper_on_;
   bool spatial_resize_on_;
 
   VideoProcessorIntegrationTest() {}
   virtual ~VideoProcessorIntegrationTest() {}
 
   void SetUpCodecConfig() {
     if (codec_type_ == kVideoCodecH264) {
-      encoder_ = H264Encoder::Create(cricket::VideoCodec("H264"));
-      decoder_ = H264Decoder::Create();
+      encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
+      decoder_.reset(H264Decoder::Create());
       VideoCodingModule::Codec(kVideoCodecH264, &codec_settings_);
     } else if (codec_type_ == kVideoCodecVP8) {
-      encoder_ = VP8Encoder::Create();
-      decoder_ = VP8Decoder::Create();
+      encoder_.reset(VP8Encoder::Create());
+      decoder_.reset(VP8Decoder::Create());
       VideoCodingModule::Codec(kVideoCodecVP8, &codec_settings_);
     } else if (codec_type_ == kVideoCodecVP9) {
-      encoder_ = VP9Encoder::Create();
-      decoder_ = VP9Decoder::Create();
+      encoder_.reset(VP9Encoder::Create());
+      decoder_.reset(VP9Decoder::Create());
       VideoCodingModule::Codec(kVideoCodecVP9, &codec_settings_);
     }
 
     // CIF is currently used for all tests below.
     // Setup the TestConfig struct for processing of a clip in CIF resolution.
     config_.input_filename = webrtc::test::ResourcePath("foreman_cif", "yuv");
 
     // Generate an output filename in a safe way.
     config_.output_filename = webrtc::test::TempFilename(
         webrtc::test::OutputPath(), "videoprocessor_integrationtest");
@@ skipping 34 matching lines @@
         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);
         break;
     }
-    frame_reader_ = new webrtc::test::FrameReaderImpl(
+    frame_reader_.reset(new test::FrameReaderImpl(
         config_.input_filename, config_.codec_settings->width,
-        config_.codec_settings->height);
-    frame_writer_ = new webrtc::test::FrameWriterImpl(
-        config_.output_filename, config_.frame_length_in_bytes);
+        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());
 
-    packet_manipulator_ = new webrtc::test::PacketManipulatorImpl(
-        &packet_reader_, config_.networking_config, config_.verbose);
-    processor_ = new webrtc::test::VideoProcessorImpl(
-        encoder_, decoder_, frame_reader_, frame_writer_, packet_manipulator_,
-        config_, &stats_);
+    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());
   }
 
   // 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;
@@ skipping 67 matching lines @@
                          int num_key_frames) {
     int num_dropped_frames = processor_->NumberDroppedFrames();
     int num_resize_actions = processor_->NumberSpatialResizes();
     printf(
         "For update #: %d,\n "
         " Target Bitrate: %d,\n"
         " Encoding bitrate: %f,\n"
         " Frame rate: %d \n",
         update_index, bit_rate_, encoding_bitrate_total_, frame_rate_);
     printf(
-        " Number of frames to approach target rate = %d, \n"
-        " Number of dropped frames = %d, \n"
-        " Number of spatial resizes = %d, \n",
+        " Number of frames to approach target rate: %d, \n"
+        " Number of dropped frames: %d, \n"
+        " Number of spatial resizes: %d, \n",
         num_frames_to_hit_target_, num_dropped_frames, num_resize_actions);
     EXPECT_LE(perc_encoding_rate_mismatch_, 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(
           " Number of 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, max_key_frame_size_mismatch);
     }
     printf("\n");
     printf("Rates statistics for Layer data \n");
     for (int i = 0; i < num_temporal_layers_; i++) {
-      printf("Layer #%d \n", 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];
       printf(
           " Target Layer Bit rate: %f \n"
           " Layer frame rate: %f, \n"
           " Layer per frame bandwidth: %f, \n"
           " Layer Encoding bit rate: %f, \n"
           " Layer Percent frame size mismatch: %d,  \n"
-          " Layer Percent encoding rate mismatch = %d, \n"
-          " Number of frame processed per layer = %d \n",
+          " Layer Percent encoding rate mismatch: %d, \n"
+          " Number of frame processed per layer: %d \n",
           bit_rate_layer_[i], frame_rate_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, max_delta_frame_size_mismatch);
       EXPECT_LE(perc_encoding_rate_mismatch, max_encoding_rate_mismatch);
     }
     printf("\n");
     EXPECT_LE(num_frames_to_hit_target_, max_time_hit_target);
     EXPECT_LE(num_dropped_frames, max_num_dropped_frames);
     EXPECT_EQ(num_resize_actions, num_spatial_resizes);
@@ skipping 43 matching lines @@
         bit_rate_layer_[i] = bit_rate_ * bit_rate_ratio;
       }
       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;
     }
   }
 
-  void TearDown() {
-    delete processor_;
-    delete packet_manipulator_;
-    delete frame_writer_;
-    delete frame_reader_;
-    delete decoder_;
-    delete encoder_;
-  }
-
   // Processes all frames in the clip and verifies the result.
   void ProcessFramesAndVerify(QualityMetrics quality_metrics,
                               RateProfile rate_profile,
                               CodecConfigPars process,
                               RateControlMetrics* rc_metrics) {
     // Codec/config settings.
     codec_type_ = process.codec_type;
     start_bitrate_ = rate_profile.target_bit_rate[0];
     packet_loss_ = process.packet_loss;
     key_frame_interval_ = process.key_frame_interval;
@@ skipping 64 matching lines @@
     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.
-    webrtc::test::QualityMetricsResult psnr_result, ssim_result;
-    EXPECT_EQ(
-        0, webrtc::test::I420MetricsFromFiles(
-               config_.input_filename.c_str(), config_.output_filename.c_str(),
-               config_.codec_settings->width, config_.codec_settings->height,
-               &psnr_result, &ssim_result));
-    printf("PSNR avg: %f, min: %f    SSIM avg: %f, min: %f\n",
+    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,
+                                            &psnr_result, &ssim_result));
+    printf("PSNR avg: %f, min: %f\nSSIM avg: %f, min: %f\n",
            psnr_result.average, psnr_result.min, ssim_result.average,
            ssim_result.min);
     stats_.PrintSummary();
     EXPECT_GT(psnr_result.average, quality_metrics.minimum_avg_psnr);
     EXPECT_GT(psnr_result.min, quality_metrics.minimum_min_psnr);
     EXPECT_GT(ssim_result.average, quality_metrics.minimum_avg_ssim);
     EXPECT_GT(ssim_result.min, quality_metrics.minimum_min_ssim);
     if (remove(config_.output_filename.c_str()) < 0) {
       fprintf(stderr, "Failed to remove temporary file!\n");
     }
   }
 };
 
-void SetRateProfilePars(RateProfile* rate_profile,
-                        int update_index,
-                        int bit_rate,
-                        int frame_rate,
-                        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] = frame_index_rate_update;
-}
-
-void SetCodecParameters(CodecConfigPars* process_settings,
-                        VideoCodecType codec_type,
-                        float packet_loss,
-                        int key_frame_interval,
-                        int num_temporal_layers,
-                        bool error_concealment_on,
-                        bool denoising_on,
-                        bool frame_dropper_on,
-                        bool spatial_resize_on) {
-  process_settings->codec_type = codec_type;
-  process_settings->packet_loss = packet_loss;
-  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;
-}
-
-void SetQualityMetrics(QualityMetrics* quality_metrics,
-                       double minimum_avg_psnr,
-                       double minimum_min_psnr,
-                       double minimum_avg_ssim,
-                       double minimum_min_ssim) {
-  quality_metrics->minimum_avg_psnr = minimum_avg_psnr;
-  quality_metrics->minimum_min_psnr = minimum_min_psnr;
-  quality_metrics->minimum_avg_ssim = minimum_avg_ssim;
-  quality_metrics->minimum_min_ssim = minimum_min_ssim;
-}
-
-void SetRateControlMetrics(RateControlMetrics* rc_metrics,
-                           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,
-                           int num_spatial_resizes,
-                           int num_key_frames) {
-  rc_metrics[update_index].max_num_dropped_frames = max_num_dropped_frames;
-  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;
-}
-
 #if defined(WEBRTC_VIDEOPROCESSOR_H264_TESTS)
 
 // H264: Run with no packet loss and fixed bitrate. Quality should be very high.
 // Note(hbos): The PacketManipulatorImpl code used to simulate packet loss in
 // these unittests appears to drop "packets" in a way that is not compatible
 // with H264. Therefore ProcessXPercentPacketLossH264, X != 0, unittests have
 // not been added.
 TEST_F(VideoProcessorIntegrationTest, Process0PercentPacketLossH264) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
@@ skipping 361 matching lines @@
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 32.5, 30.0, 0.85, 0.80);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[2];
   SetRateControlMetrics(rc_metrics, 0, 0, 20, 30, 10, 10, 0, 1);
   SetRateControlMetrics(rc_metrics, 1, 0, 0, 30, 15, 10, 0, 0);
   ProcessFramesAndVerify(quality_metrics, rate_profile, process_settings,
                          rc_metrics);
 }
 }  // namespace webrtc