Minor improvements to VideoProcessor and corresponding test.

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.
  */
 
 #include "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
 
 #include <string.h>
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "webrtc/modules/video_coding/include/video_codec_initializer.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/rtc_base/checks.h"
+#include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 
 namespace webrtc {
 namespace test {
 
 namespace {
 
-// TODO(brandtr): Update this to use the real frame rate.
-const int k90khzTimestampFrameDiff = 3000;  // Assuming 30 fps.
-
-// Use the frame number as the basis for timestamp to identify frames. Let the
-// first timestamp be non-zero, to not make the IvfFileWriter believe that we
-// want to use capture timestamps in the IVF files.
-uint32_t FrameNumberToTimestamp(int frame_number) {
-  RTC_DCHECK_GE(frame_number, 0);
-  return (frame_number + 1) * k90khzTimestampFrameDiff;
-}
-
-int TimestampToFrameNumber(uint32_t timestamp) {
-  RTC_DCHECK_GT(timestamp, 0);
-  RTC_DCHECK_EQ(timestamp % k90khzTimestampFrameDiff, 0);
-  return (timestamp / k90khzTimestampFrameDiff) - 1;
-}
+const int kRtpClockRateHz = 90000;
 
 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 std::unique_ptr<VideoBitrateAllocator>(
       VideoCodecInitializer::CreateBitrateAllocator(*config.codec_settings,
                                                     std::move(tl_factory)));
 }
 
-void PrintCodecSettings(const VideoCodec* config) {
-  printf("    Start bitrate    : %d kbps\n", config->startBitrate);
-  printf("    Width            : %d\n", config->width);
-  printf("    Height           : %d\n", config->height);
-  printf("    Codec type       : %s\n",
-         CodecTypeToPayloadName(config->codecType).value_or("Unknown"));
-  if (config->codecType == kVideoCodecVP8) {
-    printf("    Denoising        : %d\n", config->VP8().denoisingOn);
-    printf("    Error concealment: %d\n", config->VP8().errorConcealmentOn);
-    printf("    Frame dropping   : %d\n", config->VP8().frameDroppingOn);
-    printf("    Resilience       : %d\n", config->VP8().resilience);
-  } else if (config->codecType == kVideoCodecVP9) {
-    printf("    Denoising        : %d\n", config->VP9().denoisingOn);
-    printf("    Frame dropping   : %d\n", config->VP9().frameDroppingOn);
-    printf("    Resilience       : %d\n", config->VP9().resilienceOn);
+void PrintCodecSettings(const VideoCodec* codec_settings) {
+  RTC_DCHECK(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);
+    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);
+    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);
   }
 }
 
 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 43 matching lines @@
       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());
 }
 
+VideoProcessorImpl::~VideoProcessorImpl() {
+  encoder_->RegisterEncodeCompleteCallback(nullptr);
+  decoder_->RegisterDecodeCompleteCallback(nullptr);
+}
+
 void VideoProcessorImpl::Init() {
   RTC_DCHECK(!initialized_) << "VideoProcessor already initialized.";
+  RTC_DCHECK(config_.codec_settings) << "No codec settings supplied.";
   initialized_ = true;
 
-  // Setup required callbacks for the encoder/decoder.
+  // 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,
                            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)
       << "Failed to initialize VideoDecoder";
 
   if (config_.verbose) {
-    printf("Filename: %s\n", config_.filename.c_str());
     printf("Video Processor:\n");
-    printf("  #CPU cores used  : %d\n", num_cores);
-    printf("  Total # of frames: %d\n",
+    printf(" Filename         : %s\n", config_.filename.c_str());
+    printf(" Total # of frames: %d\n",
            analysis_frame_reader_->NumberOfFrames());
-    printf("  Codec settings:\n");
-    printf("    Encoder implementation name: %s\n",
-           encoder_->ImplementationName());
-    printf("    Decoder implementation name: %s\n",
-           decoder_->ImplementationName());
-    if (strcmp(encoder_->ImplementationName(),
-               decoder_->ImplementationName()) == 0) {
-      printf("    Codec implementation name: %s_%s\n",
+    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)
                  .value_or("Unknown"),
              encoder_->ImplementationName());
     }
     PrintCodecSettings(config_.codec_settings);
+    printf("\n");
   }
 }
 
-VideoProcessorImpl::~VideoProcessorImpl() {
-  encoder_->RegisterEncodeCompleteCallback(nullptr);
-  decoder_->RegisterDecodeCompleteCallback(nullptr);
-}
-
-void VideoProcessorImpl::SetRates(int bit_rate, int 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 VideoProcessorImpl::EncodedFrameSize(int frame_number) {
-  RTC_DCHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].encoded_frame_size;
-}
-
-FrameType VideoProcessorImpl::EncodedFrameType(int frame_number) {
-  RTC_DCHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].encoded_frame_type;
-}
-
-int VideoProcessorImpl::GetQpFromEncoder(int frame_number) {
-  RTC_DCHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].qp_encoder;
-}
-
-int VideoProcessorImpl::GetQpFromBitstream(int frame_number) {
-  RTC_DCHECK_LT(frame_number, frame_infos_.size());
-  return frame_infos_[frame_number].qp_bitstream;
-}
-
-int VideoProcessorImpl::NumberDroppedFrames() {
-  return num_dropped_frames_;
-}
-
-int VideoProcessorImpl::NumberSpatialResizes() {
-  return num_spatial_resizes_;
-}
-
 bool VideoProcessorImpl::ProcessFrame(int frame_number) {
   RTC_DCHECK_GE(frame_number, 0);
   RTC_DCHECK_LE(frame_number, frame_infos_.size())
       << "Must process frames without gaps.";
   RTC_DCHECK(initialized_) << "VideoProcessor not initialized.";
 
   rtc::scoped_refptr<I420BufferInterface> buffer(
       analysis_frame_reader_->ReadFrame());
 
   if (!buffer) {
@@ skipping 29 matching lines @@
   // Create frame statistics object used for aggregation at end of test run.
   FrameStatistic* frame_stat = &stats_->NewFrame(frame_number);
 
   // For the highest measurement accuracy of the encode time, the start/stop
   // time recordings should wrap the Encode call as tightly as possible.
   frame_info->encode_start_ns = rtc::TimeNanos();
   frame_stat->encode_return_code =
       encoder_->Encode(source_frame, nullptr, &frame_types);
 
   if (frame_stat->encode_return_code != WEBRTC_VIDEO_CODEC_OK) {
-    fprintf(stderr, "Failed to encode frame %d, return code: %d\n",
-            frame_number, frame_stat->encode_return_code);
+    LOG(LS_WARNING) << "Failed to encode frame " << frame_number
+                    << ", return code: " << frame_stat->encode_return_code
+                    << ".";
   }
 
   return true;
 }
 
+void VideoProcessorImpl::SetRates(int bit_rate, int 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 VideoProcessorImpl::EncodedFrameSize(int frame_number) {
+  RTC_DCHECK_LT(frame_number, frame_infos_.size());
+  return frame_infos_[frame_number].encoded_frame_size;
+}
+
+FrameType VideoProcessorImpl::EncodedFrameType(int frame_number) {
+  RTC_DCHECK_LT(frame_number, frame_infos_.size());
+  return frame_infos_[frame_number].encoded_frame_type;
+}
+
+int VideoProcessorImpl::GetQpFromEncoder(int frame_number) {
+  RTC_DCHECK_LT(frame_number, frame_infos_.size());
+  return frame_infos_[frame_number].qp_encoder;
+}
+
+int VideoProcessorImpl::GetQpFromBitstream(int frame_number) {
+  RTC_DCHECK_LT(frame_number, frame_infos_.size());
+  return frame_infos_[frame_number].qp_bitstream;
+}
+
+int VideoProcessorImpl::NumberDroppedFrames() {
+  return num_dropped_frames_;
+}
+
+int VideoProcessorImpl::NumberSpatialResizes() {
+  return num_spatial_resizes_;
+}
+
 void VideoProcessorImpl::FrameEncoded(
     webrtc::VideoCodecType codec,
     const EncodedImage& encoded_image,
     const webrtc::RTPFragmentationHeader* fragmentation) {
   // For the highest measurement accuracy of the encode time, the start/stop
   // time recordings should wrap the Encode call as tightly as possible.
   int64_t encode_stop_ns = rtc::TimeNanos();
 
   if (encoded_frame_writer_) {
     RTC_CHECK(encoded_frame_writer_->WriteFrame(encoded_image, codec));
@@ skipping 184 matching lines @@
   RTC_DCHECK_EQ(extracted_length, analysis_frame_writer_->FrameLength());
   RTC_CHECK(analysis_frame_writer_->WriteFrame(extracted_buffer.data()));
   if (decoded_frame_writer_) {
     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 VideoProcessorImpl::FrameNumberToTimestamp(int frame_number) {
+  RTC_DCHECK_GE(frame_number, 0);
+  const int ticks_per_frame =
+      kRtpClockRateHz / config_.codec_settings->maxFramerate;
+  return (frame_number + 1) * ticks_per_frame;
+}
+
+int VideoProcessorImpl::TimestampToFrameNumber(uint32_t timestamp) {
+  RTC_DCHECK_GT(timestamp, 0);
+  const int ticks_per_frame =
+      kRtpClockRateHz / config_.codec_settings->maxFramerate;
+  RTC_DCHECK_EQ(timestamp % ticks_per_frame, 0);
+  return (timestamp / ticks_per_frame) - 1;
+}
+
 }  // namespace test
 }  // namespace webrtc