Extract bitrate allocation of spatial/temporal layers out of codec impl.

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 <assert.h>
 #include <string.h>
 
 #include <limits>
 #include <memory>
+#include <utility>
 #include <vector>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/timeutils.h"
+#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 {
 
 TestConfig::TestConfig()
     : name(""),
       description(""),
       test_number(0),
       input_filename(""),
       output_filename(""),
       output_dir("out"),
       networking_config(),
       exclude_frame_types(kExcludeOnlyFirstKeyFrame),
       frame_length_in_bytes(0),
       use_single_core(false),
       keyframe_interval(0),
-      codec_settings(NULL),
+      codec_settings(nullptr),
       verbose(true) {}
 
 TestConfig::~TestConfig() {}
 
 VideoProcessorImpl::VideoProcessorImpl(webrtc::VideoEncoder* encoder,
                                        webrtc::VideoDecoder* decoder,
                                        FrameReader* frame_reader,
                                        FrameWriter* frame_writer,
                                        PacketManipulator* packet_manipulator,
                                        const TestConfig& config,
                                        Stats* stats)
     : encoder_(encoder),
       decoder_(decoder),
       frame_reader_(frame_reader),
       frame_writer_(frame_writer),
       packet_manipulator_(packet_manipulator),
       config_(config),
       stats_(stats),
-      encode_callback_(NULL),
-      decode_callback_(NULL),
+      encode_callback_(nullptr),
+      decode_callback_(nullptr),
+      last_successful_frame_buffer_(nullptr),
       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),
       num_dropped_frames_(0),
       num_spatial_resizes_(0),
       last_encoder_frame_width_(0),
-      last_encoder_frame_height_(0) {
-  assert(encoder);
-  assert(decoder);
-  assert(frame_reader);
-  assert(frame_writer);
-  assert(packet_manipulator);
-  assert(stats);
+      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::GetBitrateAllocator(
+      *config.codec_settings, std::move(tl_factory));
+  RTC_DCHECK(encoder);
+  RTC_DCHECK(decoder);
+  RTC_DCHECK(frame_reader);
+  RTC_DCHECK(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 = frame_reader_->FrameLength();
   last_successful_frame_buffer_ = new uint8_t[frame_length_in_bytes];
   // Set fixed properties common for all frames.
@@ skipping 57 matching lines @@
 
 VideoProcessorImpl::~VideoProcessorImpl() {
   delete[] last_successful_frame_buffer_;
   encoder_->RegisterEncodeCompleteCallback(NULL);
   delete encode_callback_;
   decoder_->RegisterDecodeCompleteCallback(NULL);
   delete decode_callback_;
 }
 
 void VideoProcessorImpl::SetRates(int bit_rate, int frame_rate) {
-  int set_rates_result = encoder_->SetRates(bit_rate, frame_rate);
-  assert(set_rates_result >= 0);
+  int set_rates_result = encoder_->SetRateAllocation(
+      bitrate_allocator_->GetAllocation(bit_rate * 1000, frame_rate),
+      frame_rate);
+  RTC_CHECK_GE(set_rates_result, 0);
   if (set_rates_result < 0) {
     fprintf(stderr,
             "Failed to update encoder with new rate %d, "
             "return code: %d\n",
             bit_rate, set_rates_result);
   }
   num_dropped_frames_ = 0;
   num_spatial_resizes_ = 0;
 }
 
 size_t VideoProcessorImpl::EncodedFrameSize() {
   return encoded_frame_size_;
 }
 
 FrameType VideoProcessorImpl::EncodedFrameType() {
   return encoded_frame_type_;
 }
 
 int VideoProcessorImpl::NumberDroppedFrames() {
   return num_dropped_frames_;
 }
 
 int VideoProcessorImpl::NumberSpatialResizes() {
   return num_spatial_resizes_;
 }
 
 bool VideoProcessorImpl::ProcessFrame(int frame_number) {
-  assert(frame_number >= 0);
+  RTC_DCHECK_GE(frame_number, 0);
   if (!initialized_) {
     fprintf(stderr, "Attempting to use uninitialized VideoProcessor!\n");
     return false;
   }
   // |prev_time_stamp_| is used for getting number of dropped frames.
   if (frame_number == 0) {
     prev_time_stamp_ = -1;
   }
   rtc::scoped_refptr<VideoFrameBuffer> buffer(frame_reader_->ReadFrame());
   if (buffer) {
@@ skipping 73 matching lines @@
       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;
       default:
-        assert(false);
+        RTC_NOTREACHED();
     }
   }
 
   // Make a raw copy of the |encoded_image| buffer.
   size_t copied_buffer_size = encoded_image._length +
                               EncodedImage::GetBufferPaddingBytes(codec);
   std::unique_ptr<uint8_t[]> copied_buffer(new uint8_t[copied_buffer_size]);
   memcpy(copied_buffer.get(), encoded_image._buffer, encoded_image._length);
   // The image to feed to the decoder.
   EncodedImage copied_image;
@@ skipping 48 matching lines @@
                            config_.codec_settings->height));
 
     // Should be the same aspect ratio, no cropping needed.
     up_image->ScaleFrom(image.video_frame_buffer());
 
     // TODO(mikhal): Extracting the buffer for now - need to update test.
     size_t length =
         CalcBufferSize(kI420, up_image->width(), up_image->height());
     std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(up_image, length, image_buffer.get());
-    assert(extracted_length > 0);
+    RTC_DCHECK_GT(extracted_length, 0);
     // Update our copy of the last successful frame:
     memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
-    assert(write_success);
+    RTC_DCHECK(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   } else {  // No resize.
     // Update our copy of the last successful frame:
     // TODO(mikhal): Add as a member function, so won't be allocated per frame.
     size_t length = CalcBufferSize(kI420, image.width(), image.height());
     std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(image, length, image_buffer.get());
-    assert(extracted_length > 0);
+    RTC_DCHECK_GT(extracted_length, 0);
     memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
 
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
-    assert(write_success);
+    RTC_DCHECK(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   }
 }
 
 int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start,
                                                    int64_t stop) {
   uint64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec;
-  assert(encode_time <
-         static_cast<unsigned int>(std::numeric_limits<int>::max()));
+  RTC_DCHECK_LT(encode_time,
+                static_cast<unsigned int>(std::numeric_limits<int>::max()));
   return static_cast<int>(encode_time);
 }
 
 const char* ExcludeFrameTypesToStr(ExcludeFrameTypes e) {
   switch (e) {
     case kExcludeOnlyFirstKeyFrame:
       return "ExcludeOnlyFirstKeyFrame";
     case kExcludeAllKeyFrames:
       return "ExcludeAllKeyFrames";
     default:
-      assert(false);
+      RTC_NOTREACHED();
       return "Unknown";
   }
 }
 
 const char* VideoCodecTypeToStr(webrtc::VideoCodecType e) {
   switch (e) {
     case kVideoCodecVP8:
       return "VP8";
     case kVideoCodecI420:
       return "I420";
     case kVideoCodecRED:
       return "RED";
     case kVideoCodecULPFEC:
       return "ULPFEC";
     case kVideoCodecUnknown:
       return "Unknown";
     default:
-      assert(false);
+      RTC_NOTREACHED();
       return "Unknown";
   }
 }
 
 // Callbacks
 EncodedImageCallback::Result
 VideoProcessorImpl::VideoProcessorEncodeCompleteCallback::OnEncodedImage(
     const EncodedImage& encoded_image,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     const webrtc::RTPFragmentationHeader* fragmentation) {
   // Forward to parent class.
   RTC_CHECK(codec_specific_info);
   video_processor_->FrameEncoded(codec_specific_info->codecType,
                                  encoded_image,
                                  fragmentation);
   return Result(Result::OK, 0);
 }
 int32_t VideoProcessorImpl::VideoProcessorDecodeCompleteCallback::Decoded(
     VideoFrame& image) {
   // Forward to parent class.
   video_processor_->FrameDecoded(image);
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc