Step #0: Minor cleanups in VideoProcessor.

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 13 matching lines @@
 #include "webrtc/modules/video_coding/include/video_codec_initializer.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 
 namespace webrtc {
 namespace test {
 
 namespace {
 const int k90khzTimestampFrameDiff = 3000;  // Assuming 30 fps.
+
+std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
+    const TestConfig& config) {
+  std::unique_ptr<TemporalLayersFactory> tl_factory;
+  if (config.codec_settings->codecType == VideoCodecType::kVideoCodecVP8) {
+    tl_factory.reset(new TemporalLayersFactory());
+    config.codec_settings->VP8()->tl_factory = tl_factory.get();
+  }
+  return VideoCodecInitializer::CreateBitrateAllocator(*config.codec_settings,

[åsapersson, 2017/02/24 08:27:07]

return
std::unique_ptr<VideoBitrateAllocator>(VideoCodecInitializer::CreateBitrateAllocator(...));

[brandtr, 2017/02/28 13:59:54]

Done.

+                                                       std::move(tl_factory));
+}
+
 }  // namespace
 
 const char* ExcludeFrameTypesToStr(ExcludeFrameTypes e) {
   switch (e) {
     case kExcludeOnlyFirstKeyFrame:
       return "ExcludeOnlyFirstKeyFrame";
     case kExcludeAllKeyFrames:
       return "ExcludeAllKeyFrames";
     default:
       RTC_NOTREACHED();
@@ skipping 23 matching lines @@
                                        FrameReader* analysis_frame_reader,
                                        FrameWriter* analysis_frame_writer,
                                        PacketManipulator* packet_manipulator,
                                        const TestConfig& config,
                                        Stats* stats,
                                        FrameWriter* source_frame_writer,
                                        IvfFileWriter* encoded_frame_writer,
                                        FrameWriter* decoded_frame_writer)
     : encoder_(encoder),
       decoder_(decoder),
+      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),
-      packet_manipulator_(packet_manipulator),
-      config_(config),
-      stats_(stats),
       source_frame_writer_(source_frame_writer),
       encoded_frame_writer_(encoded_frame_writer),
       decoded_frame_writer_(decoded_frame_writer),
       first_key_frame_has_been_excluded_(false),
       last_frame_missing_(false),
       initialized_(false),
       encoded_frame_size_(0),
       encoded_frame_type_(kVideoFrameKey),
       prev_time_stamp_(0),
+      last_encoder_frame_width_(0),
+      last_encoder_frame_height_(0),
+      stats_(stats),
       num_dropped_frames_(0),
       num_spatial_resizes_(0),
-      last_encoder_frame_width_(0),
-      last_encoder_frame_height_(0),
       bit_rate_factor_(0.0),
       encode_start_ns_(0),
       decode_start_ns_(0) {
-  std::unique_ptr<TemporalLayersFactory> tl_factory;
-  if (config_.codec_settings->codecType == VideoCodecType::kVideoCodecVP8) {
-    tl_factory.reset(new TemporalLayersFactory());
-    config.codec_settings->VP8()->tl_factory = tl_factory.get();
-  }
-  bitrate_allocator_ = VideoCodecInitializer::CreateBitrateAllocator(
-      *config.codec_settings, std::move(tl_factory));
   RTC_DCHECK(encoder);
   RTC_DCHECK(decoder);
+  RTC_DCHECK(packet_manipulator);
   RTC_DCHECK(analysis_frame_reader);
   RTC_DCHECK(analysis_frame_writer);
-  RTC_DCHECK(packet_manipulator);
   RTC_DCHECK(stats);
 }
 
 bool VideoProcessorImpl::Init() {
   // Calculate a factor used for bit rate calculations.
   bit_rate_factor_ = config_.codec_settings->maxFramerate * 0.001 * 8;  // bits
 
   // Initialize data structures used by the encoder/decoder APIs.
   size_t frame_length_in_bytes = analysis_frame_reader_->FrameLength();
   last_successful_frame_buffer_.reset(new uint8_t[frame_length_in_bytes]);
 
   // Set fixed properties common for all frames.
   // To keep track of spatial resize actions by encoder.
   last_encoder_frame_width_ = config_.codec_settings->width;
   last_encoder_frame_height_ = config_.codec_settings->height;
 
   // Setup required callbacks for the encoder/decoder.
-  encode_callback_.reset(new VideoProcessorEncodeCompleteCallback(this));
-  decode_callback_.reset(new VideoProcessorDecodeCompleteCallback(this));
   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";
 
-  // Init the encoder and decoder.
+  // 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,
                            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),
                WEBRTC_VIDEO_CODEC_OK)
@@ skipping 168 matching lines @@
   stat.frame_number = frame_number;
   stat.frame_type = encoded_image._frameType;
   stat.qp = encoded_image.qp_;
   stat.bit_rate_in_kbps = encoded_image._length * bit_rate_factor_;
   stat.total_packets =
       encoded_image._length / config_.networking_config.packet_size_in_bytes +
       1;
 
   // Simulate packet loss.
   bool exclude_this_frame = false;
-  // Only keyframes can be excluded.
   if (encoded_image._frameType == kVideoFrameKey) {
+    // Only keyframes can be excluded.
     switch (config_.exclude_frame_types) {
       case kExcludeOnlyFirstKeyFrame:
         if (!first_key_frame_has_been_excluded_) {
           first_key_frame_has_been_excluded_ = true;
           exclude_this_frame = true;
         }
         break;
       case kExcludeAllKeyFrames:
         exclude_this_frame = true;
         break;
@@ skipping 122 matching lines @@
 int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start,
                                                    int64_t stop) {
   int64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec;
   RTC_DCHECK_GE(encode_time, std::numeric_limits<int>::min());
   RTC_DCHECK_LE(encode_time, std::numeric_limits<int>::max());
   return static_cast<int>(encode_time);
 }
 
 }  // namespace test
 }  // namespace webrtc