Move ownership of webrtc::VideoCodec into TestConfig.

webrtc/modules/video_coding/codecs/test/videoprocessor.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.
  */
 
@@ skipping 17 matching lines @@
 #include "webrtc/system_wrappers/include/cpu_info.h"
 
 namespace webrtc {
 namespace test {
 
 namespace {
 
 const int kRtpClockRateHz = 90000;
 
 std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
-    const TestConfig& config) {
+    TestConfig* config) {
   std::unique_ptr<TemporalLayersFactory> tl_factory;
-  if (config.codec_settings->codecType == VideoCodecType::kVideoCodecVP8) {
+  if (config->codec_settings.codecType == VideoCodecType::kVideoCodecVP8) {
     tl_factory.reset(new TemporalLayersFactory());
-    config.codec_settings->VP8()->tl_factory = tl_factory.get();
+    config->codec_settings.VP8()->tl_factory = tl_factory.get();
   }
   return std::unique_ptr<VideoBitrateAllocator>(
-      VideoCodecInitializer::CreateBitrateAllocator(*config.codec_settings,
+      VideoCodecInitializer::CreateBitrateAllocator(config->codec_settings,
                                                     std::move(tl_factory)));
 }
 
-void PrintCodecSettings(const VideoCodec* codec_settings) {
-  RTC_DCHECK(codec_settings);
+void PrintCodecSettings(const VideoCodec& codec_settings) {
   printf(" Codec settings:\n");
   printf("  Codec type        : %s\n",
-         CodecTypeToPayloadName(codec_settings->codecType).value_or("Unknown"));
-  printf("  Start bitrate     : %d kbps\n", codec_settings->startBitrate);
-  printf("  Max bitrate       : %d kbps\n", codec_settings->maxBitrate);
-  printf("  Min bitrate       : %d kbps\n", codec_settings->minBitrate);
-  printf("  Width             : %d\n", codec_settings->width);
-  printf("  Height            : %d\n", codec_settings->height);
-  printf("  Max frame rate    : %d\n", codec_settings->maxFramerate);
-  printf("  QPmax             : %d\n", codec_settings->qpMax);
-  if (codec_settings->codecType == kVideoCodecVP8) {
-    printf("  Complexity        : %d\n", codec_settings->VP8().complexity);
-    printf("  Denoising         : %d\n", codec_settings->VP8().denoisingOn);
+         CodecTypeToPayloadName(codec_settings.codecType).value_or("Unknown"));
+  printf("  Start bitrate     : %d kbps\n", codec_settings.startBitrate);
+  printf("  Max bitrate       : %d kbps\n", codec_settings.maxBitrate);
+  printf("  Min bitrate       : %d kbps\n", codec_settings.minBitrate);
+  printf("  Width             : %d\n", codec_settings.width);
+  printf("  Height            : %d\n", codec_settings.height);
+  printf("  Max frame rate    : %d\n", codec_settings.maxFramerate);
+  printf("  QPmax             : %d\n", codec_settings.qpMax);
+  if (codec_settings.codecType == kVideoCodecVP8) {
+    printf("  Complexity        : %d\n", codec_settings.VP8().complexity);
+    printf("  Denoising         : %d\n", codec_settings.VP8().denoisingOn);
     printf("  Error concealment : %d\n",
-           codec_settings->VP8().errorConcealmentOn);
-    printf("  Frame dropping    : %d\n", codec_settings->VP8().frameDroppingOn);
-    printf("  Resilience        : %d\n", codec_settings->VP8().resilience);
+           codec_settings.VP8().errorConcealmentOn);
+    printf("  Frame dropping    : %d\n", codec_settings.VP8().frameDroppingOn);
+    printf("  Resilience        : %d\n", codec_settings.VP8().resilience);
+    printf("  Key frame interval: %d\n", codec_settings.VP8().keyFrameInterval);
+  } else if (codec_settings.codecType == kVideoCodecVP9) {
+    printf("  Complexity        : %d\n", codec_settings.VP9().complexity);
+    printf("  Denoising         : %d\n", codec_settings.VP9().denoisingOn);
+    printf("  Frame dropping    : %d\n", codec_settings.VP9().frameDroppingOn);
+    printf("  Resilience        : %d\n", codec_settings.VP9().resilienceOn);
+    printf("  Key frame interval: %d\n", codec_settings.VP9().keyFrameInterval);
+    printf("  Adaptive QP mode  : %d\n", codec_settings.VP9().adaptiveQpMode);
+  } else if (codec_settings.codecType == kVideoCodecH264) {
+    printf("  Frame dropping    : %d\n", codec_settings.H264().frameDroppingOn);
     printf("  Key frame interval: %d\n",
-           codec_settings->VP8().keyFrameInterval);
-  } else if (codec_settings->codecType == kVideoCodecVP9) {
-    printf("  Complexity        : %d\n", codec_settings->VP9().complexity);
-    printf("  Denoising         : %d\n", codec_settings->VP9().denoisingOn);
-    printf("  Frame dropping    : %d\n", codec_settings->VP9().frameDroppingOn);
-    printf("  Resilience        : %d\n", codec_settings->VP9().resilienceOn);
-    printf("  Key frame interval: %d\n",
-           codec_settings->VP9().keyFrameInterval);
-    printf("  Adaptive QP mode  : %d\n", codec_settings->VP9().adaptiveQpMode);
-  } else if (codec_settings->codecType == kVideoCodecH264) {
-    printf("  Frame dropping    : %d\n",
-           codec_settings->H264().frameDroppingOn);
-    printf("  Key frame interval: %d\n",
-           codec_settings->H264().keyFrameInterval);
-    printf("  Profile           : %d\n", codec_settings->H264().profile);
+           codec_settings.H264().keyFrameInterval);
+    printf("  Profile           : %d\n", codec_settings.H264().profile);
   }
 }
 
 int GetElapsedTimeMicroseconds(int64_t start_ns, int64_t stop_ns) {
   int64_t diff_us = (stop_ns - start_ns) / rtc::kNumNanosecsPerMicrosec;
   RTC_DCHECK_GE(diff_us, std::numeric_limits<int>::min());
   RTC_DCHECK_LE(diff_us, std::numeric_limits<int>::max());
   return static_cast<int>(diff_us);
 }
 
@@ skipping 13 matching lines @@
 
 VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
                                webrtc::VideoDecoder* decoder,
                                FrameReader* analysis_frame_reader,
                                FrameWriter* analysis_frame_writer,
                                PacketManipulator* packet_manipulator,
                                const TestConfig& config,
                                Stats* stats,
                                IvfFileWriter* encoded_frame_writer,
                                FrameWriter* decoded_frame_writer)
-    : encoder_(encoder),
+    : config_(config),
+      encoder_(encoder),
       decoder_(decoder),
-      bitrate_allocator_(CreateBitrateAllocator(config)),
+      bitrate_allocator_(CreateBitrateAllocator(&config_)),
       encode_callback_(new VideoProcessorEncodeCompleteCallback(this)),
       decode_callback_(new VideoProcessorDecodeCompleteCallback(this)),
       packet_manipulator_(packet_manipulator),
-      config_(config),
       analysis_frame_reader_(analysis_frame_reader),
       analysis_frame_writer_(analysis_frame_writer),
       encoded_frame_writer_(encoded_frame_writer),
       decoded_frame_writer_(decoded_frame_writer),
       initialized_(false),
       last_encoded_frame_num_(-1),
       last_decoded_frame_num_(-1),
       first_key_frame_has_been_excluded_(false),
       last_decoded_frame_buffer_(0, analysis_frame_reader->FrameLength()),
       stats_(stats),
       num_dropped_frames_(0),
       num_spatial_resizes_(0) {
   RTC_DCHECK(encoder);
   RTC_DCHECK(decoder);
   RTC_DCHECK(packet_manipulator);
   RTC_DCHECK(analysis_frame_reader);
   RTC_DCHECK(analysis_frame_writer);
   RTC_DCHECK(stats);
   frame_infos_.reserve(analysis_frame_reader->NumberOfFrames());
 }
 
 VideoProcessor::~VideoProcessor() {
   encoder_->RegisterEncodeCompleteCallback(nullptr);
   decoder_->RegisterDecodeCompleteCallback(nullptr);
 }
 
 void VideoProcessor::Init() {
   RTC_DCHECK(!initialized_) << "VideoProcessor already initialized.";
-  RTC_DCHECK(config_.codec_settings) << "No codec settings supplied.";
   initialized_ = true;
 
   // Setup required callbacks for the encoder and decoder.
   RTC_CHECK_EQ(encoder_->RegisterEncodeCompleteCallback(encode_callback_.get()),
                WEBRTC_VIDEO_CODEC_OK)
       << "Failed to register encode complete callback";
   RTC_CHECK_EQ(decoder_->RegisterDecodeCompleteCallback(decode_callback_.get()),
                WEBRTC_VIDEO_CODEC_OK)
       << "Failed to register decode complete callback";
 
   // Initialize the encoder and decoder.
   uint32_t num_cores =
       config_.use_single_core ? 1 : CpuInfo::DetectNumberOfCores();
   RTC_CHECK_EQ(
-      encoder_->InitEncode(config_.codec_settings, num_cores,
+      encoder_->InitEncode(&config_.codec_settings, num_cores,
                            config_.networking_config.max_payload_size_in_bytes),
       WEBRTC_VIDEO_CODEC_OK)
       << "Failed to initialize VideoEncoder";
 
-  RTC_CHECK_EQ(decoder_->InitDecode(config_.codec_settings, num_cores),
+  RTC_CHECK_EQ(decoder_->InitDecode(&config_.codec_settings, num_cores),
                WEBRTC_VIDEO_CODEC_OK)
       << "Failed to initialize VideoDecoder";
 
   if (config_.verbose) {
     printf("Video Processor:\n");
     printf(" Filename         : %s\n", config_.filename.c_str());
     printf(" Total # of frames: %d\n",
            analysis_frame_reader_->NumberOfFrames());
     printf(" # CPU cores used : %d\n", num_cores);
     const char* encoder_name = encoder_->ImplementationName();
     printf(" Encoder implementation name: %s\n", encoder_name);
     const char* decoder_name = decoder_->ImplementationName();
     printf(" Decoder implementation name: %s\n", decoder_name);
     if (strcmp(encoder_name, decoder_name) == 0) {
       printf(" Codec implementation name  : %s_%s\n",
-             CodecTypeToPayloadName(config_.codec_settings->codecType)
+             CodecTypeToPayloadName(config_.codec_settings.codecType)
                  .value_or("Unknown"),
              encoder_->ImplementationName());
     }
     PrintCodecSettings(config_.codec_settings);
     printf("\n");
   }
 }
 
 bool VideoProcessor::ProcessFrame(int frame_number) {
   RTC_DCHECK_GE(frame_number, 0);
@@ skipping 36 matching lines @@
   if (frame_stat->encode_return_code != WEBRTC_VIDEO_CODEC_OK) {
     LOG(LS_WARNING) << "Failed to encode frame " << frame_number
                     << ", return code: " << frame_stat->encode_return_code
                     << ".";
   }
 
   return true;
 }
 
 void VideoProcessor::SetRates(int bit_rate, int frame_rate) {
-  config_.codec_settings->maxFramerate = frame_rate;
+  config_.codec_settings.maxFramerate = frame_rate;
   int set_rates_result = encoder_->SetRateAllocation(
       bitrate_allocator_->GetAllocation(bit_rate * 1000, frame_rate),
       frame_rate);
   RTC_DCHECK_GE(set_rates_result, 0)
       << "Failed to update encoder with new rate " << bit_rate;
   num_dropped_frames_ = 0;
   num_spatial_resizes_ = 0;
 }
 
 size_t VideoProcessor::EncodedFrameSize(int frame_number) {
@@ skipping 85 matching lines @@
   }
   FrameStatistic* frame_stat = &stats_->stats_[frame_number];
   frame_stat->encode_time_in_us =
       GetElapsedTimeMicroseconds(frame_info->encode_start_ns, encode_stop_ns);
   frame_stat->encoding_successful = true;
   frame_stat->encoded_frame_length_in_bytes = encoded_image._length;
   frame_stat->frame_number = frame_number;
   frame_stat->frame_type = encoded_image._frameType;
   frame_stat->qp = encoded_image.qp_;
   frame_stat->bit_rate_in_kbps = static_cast<int>(
-      encoded_image._length * config_.codec_settings->maxFramerate * 8 / 1000);
+      encoded_image._length * config_.codec_settings.maxFramerate * 8 / 1000);
   frame_stat->total_packets =
       encoded_image._length / config_.networking_config.packet_size_in_bytes +
       1;
 
   // Simulate packet loss.
   bool exclude_this_frame = false;
   if (encoded_image._frameType == kVideoFrameKey) {
     // Only keyframes can be excluded.
     switch (config_.exclude_frame_types) {
       case kExcludeOnlyFirstKeyFrame:
@@ skipping 84 matching lines @@
   }
   // Ensure strict monotonicity.
   RTC_CHECK_GT(frame_number, last_decoded_frame_num_);
   last_decoded_frame_num_ = frame_number;
 
   // Check if codec size is different from the original size, and if so,
   // scale back to original size. This is needed for the PSNR and SSIM
   // calculations.
   size_t extracted_length;
   rtc::Buffer extracted_buffer;
-  if (image.width() != config_.codec_settings->width ||
-      image.height() != config_.codec_settings->height) {
+  if (image.width() != config_.codec_settings.width ||
+      image.height() != config_.codec_settings.height) {
     rtc::scoped_refptr<I420Buffer> scaled_buffer(I420Buffer::Create(
-        config_.codec_settings->width, config_.codec_settings->height));
+        config_.codec_settings.width, config_.codec_settings.height));
     // Should be the same aspect ratio, no cropping needed.
     scaled_buffer->ScaleFrom(*image.video_frame_buffer()->ToI420());
 
     size_t length = CalcBufferSize(VideoType::kI420, scaled_buffer->width(),
                                    scaled_buffer->height());
     extracted_buffer.SetSize(length);
     extracted_length =
         ExtractBuffer(scaled_buffer, length, extracted_buffer.data());
   } else {
     // No resize.
@@ skipping 10 matching lines @@
     RTC_DCHECK_EQ(extracted_length, decoded_frame_writer_->FrameLength());
     RTC_CHECK(decoded_frame_writer_->WriteFrame(extracted_buffer.data()));
   }
 
   last_decoded_frame_buffer_ = std::move(extracted_buffer);
 }
 
 uint32_t VideoProcessor::FrameNumberToTimestamp(int frame_number) {
   RTC_DCHECK_GE(frame_number, 0);
   const int ticks_per_frame =
-      kRtpClockRateHz / config_.codec_settings->maxFramerate;
+      kRtpClockRateHz / config_.codec_settings.maxFramerate;
   return (frame_number + 1) * ticks_per_frame;
 }
 
 int VideoProcessor::TimestampToFrameNumber(uint32_t timestamp) {
   RTC_DCHECK_GT(timestamp, 0);
   const int ticks_per_frame =
-      kRtpClockRateHz / config_.codec_settings->maxFramerate;
+      kRtpClockRateHz / config_.codec_settings.maxFramerate;
   RTC_DCHECK_EQ(timestamp % ticks_per_frame, 0);
   return (timestamp / ticks_per_frame) - 1;
 }
 
 }  // namespace test
 }  // namespace webrtc