Move ownership of webrtc::VideoCodec into TestConfig.

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 133 matching lines @@
   virtual ~VideoProcessorIntegrationTest() = default;
 
   void CreateEncoderAndDecoder() {
     if (config_.hw_codec) {
 #if defined(WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED)
 #if defined(WEBRTC_ANDROID)
       // In general, external codecs should be destroyed by the factories that
       // allocated them. For the particular case of the Android
       // MediaCodecVideo{En,De}coderFactory's, however, it turns out that it is
       // fine for the std::unique_ptr to destroy the owned codec directly.
-      switch (config_.codec_settings->codecType) {
+      switch (config_.codec_settings.codecType) {
         case kVideoCodecH264:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kH264CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecH264));
           break;
         case kVideoCodecVP8:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kVp8CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP8));
           break;
         case kVideoCodecVP9:
           encoder_.reset(external_encoder_factory_->CreateVideoEncoder(
               cricket::VideoCodec(cricket::kVp9CodecName)));
           decoder_.reset(
               external_decoder_factory_->CreateVideoDecoder(kVideoCodecVP9));
           break;
         default:
           RTC_NOTREACHED();
           break;
       }
 #elif defined(WEBRTC_IOS)
-      ASSERT_EQ(kVideoCodecH264, config_.codec_settings->codecType)
+      ASSERT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
           << "iOS HW codecs only support H264.";
       std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory =
           CreateObjCEncoderFactory();
       std::unique_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory =
           CreateObjCDecoderFactory();
       cricket::VideoCodec codecInfo = encoder_factory->supported_codecs().at(0);
       encoder_.reset(encoder_factory->CreateVideoEncoder(codecInfo));
       decoder_.reset(decoder_factory->CreateVideoDecoder(kVideoCodecH264));
 #else
       RTC_NOTREACHED() << "Only support HW codecs on Android and iOS.";
 #endif
 #endif  // WEBRTC_VIDEOPROCESSOR_INTEGRATIONTEST_HW_CODECS_ENABLED
       RTC_CHECK(encoder_) << "HW encoder not successfully created.";
       RTC_CHECK(decoder_) << "HW decoder not successfully created.";
       return;
     }
 
     // SW codecs.
-    switch (config_.codec_settings->codecType) {
+    switch (config_.codec_settings.codecType) {
       case kVideoCodecH264:
         encoder_.reset(
             H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName)));
         decoder_.reset(H264Decoder::Create());
         break;
       case kVideoCodecVP8:
         encoder_.reset(VP8Encoder::Create());
         decoder_.reset(VP8Decoder::Create());
         break;
       case kVideoCodecVP9:
         encoder_.reset(VP9Encoder::Create());
         decoder_.reset(VP9Decoder::Create());
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
   }
 
   void SetUpObjects(const VisualizationParams* visualization_params) {
     CreateEncoderAndDecoder();
 
     // Create file objects for quality analysis.
     analysis_frame_reader_.reset(new test::YuvFrameReaderImpl(
-        config_.input_filename, config_.codec_settings->width,
-        config_.codec_settings->height));
+        config_.input_filename, config_.codec_settings.width,
+        config_.codec_settings.height));
     analysis_frame_writer_.reset(new test::YuvFrameWriterImpl(
-        config_.output_filename, config_.codec_settings->width,
-        config_.codec_settings->height));
+        config_.output_filename, config_.codec_settings.width,
+        config_.codec_settings.height));
     RTC_CHECK(analysis_frame_reader_->Init());
     RTC_CHECK(analysis_frame_writer_->Init());
 
     if (visualization_params) {
       // clang-format off
       const std::string output_filename_base =
           test::OutputPath() + config_.filename +
           "_cd-" + CodecTypeToPayloadName(
-              config_.codec_settings->codecType).value_or("") +
+              config_.codec_settings.codecType).value_or("") +
           "_hw-" + std::to_string(config_.hw_codec) +
           "_br-" + std::to_string(
-              static_cast<int>(config_.codec_settings->startBitrate));
+              static_cast<int>(config_.codec_settings.startBitrate));
       // clang-format on
       if (visualization_params->save_encoded_ivf) {
         rtc::File post_encode_file =
             rtc::File::Create(output_filename_base + "_encoded.ivf");
         encoded_frame_writer_ =
             IvfFileWriter::Wrap(std::move(post_encode_file), 0);
       }
       if (visualization_params->save_decoded_y4m) {
         decoded_frame_writer_.reset(new test::Y4mFrameWriterImpl(
-            output_filename_base + "_decoded.y4m",
-            config_.codec_settings->width, config_.codec_settings->height,
-            start_frame_rate_));
+            output_filename_base + "_decoded.y4m", config_.codec_settings.width,
+            config_.codec_settings.height, start_frame_rate_));
         RTC_CHECK(decoded_frame_writer_->Init());
       }
     }
 
     packet_manipulator_.reset(new test::PacketManipulatorImpl(
         &packet_reader_, config_.networking_config, config_.verbose));
     processor_ = rtc::MakeUnique<VideoProcessor>(
         encoder_.get(), decoder_.get(), analysis_frame_reader_.get(),
         analysis_frame_writer_.get(), packet_manipulator_.get(), config_,
         &stats_, encoded_frame_writer_.get(), decoded_frame_writer_.get());
@@ skipping 139 matching lines @@
                      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);
   }
 
   void VerifyQpParser(int frame_number) {
     if (!config_.hw_codec &&
-        (config_.codec_settings->codecType == kVideoCodecVP8 ||
-         config_.codec_settings->codecType == kVideoCodecVP9)) {
+        (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) {
-    if (codec_settings->codecType == kVideoCodecVP8) {
-      return codec_settings->VP8().numberOfTemporalLayers;
-    } else if (codec_settings->codecType == kVideoCodecVP9) {
-      return codec_settings->VP9().numberOfTemporalLayers;
+  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.
   int TemporalLayerIndexForFrame(int frame_number) {
     int tl_idx = -1;
     switch (num_temporal_layers_) {
       case 1:
@@ skipping 48 matching lines @@
   // 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) {
     // Codec/config settings.
-    RTC_CHECK(config_.codec_settings);
     num_temporal_layers_ = NumberOfTemporalLayers(config_.codec_settings);
-    config_.codec_settings->startBitrate = rate_profile.target_bit_rate[0];
+    config_.codec_settings.startBitrate = rate_profile.target_bit_rate[0];
     start_frame_rate_ = rate_profile.input_frame_rate[0];
     SetUpObjects(visualization_params);
     // Update the temporal layers and the codec with the initial rates.
     bit_rate_ = rate_profile.target_bit_rate[0];
     frame_rate_ = 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_);
@@ skipping 78 matching lines @@
       EXPECT_TRUE(encoded_frame_writer_->Close());
     }
     if (decoded_frame_writer_) {
       decoded_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,
+                                            config_.codec_settings.width,
+                                            config_.codec_settings.height,
                                             &psnr_result, &ssim_result));
     VerifyQuality(psnr_result, ssim_result, quality_thresholds);
     stats_.PrintSummary();
     printf("PSNR avg: %f, min: %f\nSSIM avg: %f, min: %f\n",
            psnr_result.average, psnr_result.min, ssim_result.average,
            ssim_result.min);
     printf("\n");
 
     // Remove analysis file.
     if (remove(config_.output_filename.c_str()) < 0) {
@@ skipping 17 matching lines @@
         test::OutputPath(), "videoprocessor_integrationtest");
     config->hw_codec = hw_codec;
     config->use_single_core = use_single_core;
     config->keyframe_interval = key_frame_interval;
     config->networking_config.packet_loss_probability = packet_loss_probability;
     config->verbose = verbose_logging;
     config->batch_mode = batch_mode;
   }
 
   static void SetCodecSettings(test::TestConfig* config,
-                               VideoCodec* codec_settings,
                                VideoCodecType codec_type,
                                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) {
-    VideoCodingModule::Codec(codec_type, codec_settings);
-    config->codec_settings = codec_settings;
-    config->codec_settings->width = width;
-    config->codec_settings->height = height;
-    switch (config->codec_settings->codecType) {
+    VideoCodingModule::Codec(codec_type, &config->codec_settings);
+    config->codec_settings.width = width;
+    config->codec_settings.height = height;
+    switch (config->codec_settings.codecType) {
       case kVideoCodecH264:
-        config->codec_settings->H264()->frameDroppingOn = frame_dropper_on;
-        config->codec_settings->H264()->keyFrameInterval =
-            kBaseKeyFrameInterval;
+        config->codec_settings.H264()->frameDroppingOn = frame_dropper_on;
+        config->codec_settings.H264()->keyFrameInterval = kBaseKeyFrameInterval;
         break;
       case kVideoCodecVP8:
-        config->codec_settings->VP8()->errorConcealmentOn =
-            error_concealment_on;
-        config->codec_settings->VP8()->denoisingOn = denoising_on;
-        config->codec_settings->VP8()->numberOfTemporalLayers =
+        config->codec_settings.VP8()->errorConcealmentOn = error_concealment_on;
+        config->codec_settings.VP8()->denoisingOn = denoising_on;
+        config->codec_settings.VP8()->numberOfTemporalLayers =
             num_temporal_layers;
-        config->codec_settings->VP8()->frameDroppingOn = frame_dropper_on;
-        config->codec_settings->VP8()->automaticResizeOn = spatial_resize_on;
-        config->codec_settings->VP8()->keyFrameInterval = kBaseKeyFrameInterval;
-        config->codec_settings->VP8()->resilience =
+        config->codec_settings.VP8()->frameDroppingOn = frame_dropper_on;
+        config->codec_settings.VP8()->automaticResizeOn = spatial_resize_on;
+        config->codec_settings.VP8()->keyFrameInterval = kBaseKeyFrameInterval;
+        config->codec_settings.VP8()->resilience =
             resilience_on ? kResilientStream : kResilienceOff;
         break;
       case kVideoCodecVP9:
-        config->codec_settings->VP9()->denoisingOn = denoising_on;
-        config->codec_settings->VP9()->numberOfTemporalLayers =
+        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;
-        config->codec_settings->VP9()->resilienceOn = resilience_on;
+        config->codec_settings.VP9()->frameDroppingOn = frame_dropper_on;
+        config->codec_settings.VP9()->automaticResizeOn = spatial_resize_on;
+        config->codec_settings.VP9()->keyFrameInterval = kBaseKeyFrameInterval;
+        config->codec_settings.VP9()->resilienceOn = resilience_on;
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
 
     config->frame_length_in_bytes =
         CalcBufferSize(VideoType::kI420, width, height);
   }
 
@@ skipping 22 matching lines @@
         max_key_frame_size_mismatch;
     rc_thresholds[update_index].max_delta_frame_size_mismatch =
         max_delta_frame_size_mismatch;
     rc_thresholds[update_index].max_encoding_rate_mismatch =
         max_encoding_rate_mismatch;
     rc_thresholds[update_index].max_time_hit_target = max_time_hit_target;
     rc_thresholds[update_index].num_spatial_resizes = num_spatial_resizes;
     rc_thresholds[update_index].num_key_frames = num_key_frames;
   }
 
+  // Config.
+  TestConfig config_;
+
   // Codecs.
   std::unique_ptr<VideoEncoder> encoder_;
   std::unique_ptr<cricket::WebRtcVideoEncoderFactory> external_encoder_factory_;
   std::unique_ptr<VideoDecoder> decoder_;
   std::unique_ptr<cricket::WebRtcVideoDecoderFactory> external_decoder_factory_;
-  VideoCodec codec_settings_;
 
   // Helper objects.
   std::unique_ptr<test::FrameReader> analysis_frame_reader_;
   std::unique_ptr<test::FrameWriter> analysis_frame_writer_;
   test::PacketReader packet_reader_;
   std::unique_ptr<test::PacketManipulator> packet_manipulator_;
   test::Stats stats_;
-  test::TestConfig config_;
   // Must be destroyed before |encoder_| and |decoder_|.
   std::unique_ptr<test::VideoProcessor> processor_;
 
   // Visualization objects.
   std::unique_ptr<IvfFileWriter> encoded_frame_writer_;
   std::unique_ptr<test::FrameWriter> decoded_frame_writer_;
 
   // Quantities defined/updated for every encoder rate update.
   int num_frames_per_update_[kMaxNumTemporalLayers];
   float sum_frame_size_mismatch_[kMaxNumTemporalLayers];
@@ skipping 17 matching lines @@
   int start_frame_rate_;
 
   // Codec and network settings.
   int num_temporal_layers_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_