Reland #2 of Issue 2434073003: Extract bitrate allocation ...

webrtc/test/fake_encoder.cc

 /*
  *  Copyright (c) 2013 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/test/fake_encoder.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace test {
 
 FakeEncoder::FakeEncoder(Clock* clock)
     : clock_(clock),
       callback_(NULL),
-      target_bitrate_kbps_(0),
       max_target_bitrate_kbps_(-1),
       last_encode_time_ms_(0) {
   // Generate some arbitrary not-all-zero data
   for (size_t i = 0; i < sizeof(encoded_buffer_); ++i) {
     encoded_buffer_[i] = static_cast<uint8_t>(i);
   }
 }
 
 FakeEncoder::~FakeEncoder() {}
 
 void FakeEncoder::SetMaxBitrate(int max_kbps) {
   RTC_DCHECK_GE(max_kbps, -1);  // max_kbps == -1 disables it.
   max_target_bitrate_kbps_ = max_kbps;
 }
 
 int32_t FakeEncoder::InitEncode(const VideoCodec* config,
                                 int32_t number_of_cores,
                                 size_t max_payload_size) {
   config_ = *config;
-  target_bitrate_kbps_ = config_.startBitrate;
+  target_bitrate_.SetBitrate(0, 0, config_.startBitrate * 1000);
   return 0;
 }
 
 int32_t FakeEncoder::Encode(const VideoFrame& input_image,
                             const CodecSpecificInfo* codec_specific_info,
                             const std::vector<FrameType>* frame_types) {
   RTC_DCHECK_GT(config_.maxFramerate, 0);
   int64_t time_since_last_encode_ms = 1000 / config_.maxFramerate;
   int64_t time_now_ms = clock_->TimeInMilliseconds();
   const bool first_encode = last_encode_time_ms_ == 0;
   if (!first_encode) {
     // For all frames but the first we can estimate the display time by looking
     // at the display time of the previous frame.
     time_since_last_encode_ms = time_now_ms - last_encode_time_ms_;
   }
   if (time_since_last_encode_ms > 3 * 1000 / config_.maxFramerate) {
     // Rudimentary check to make sure we don't widely overshoot bitrate target
     // when resuming encoding after a suspension.
     time_since_last_encode_ms = 3 * 1000 / config_.maxFramerate;
   }
 
-  size_t bits_available =
-      static_cast<size_t>(target_bitrate_kbps_ * time_since_last_encode_ms);
+  size_t bits_available = static_cast<size_t>(target_bitrate_.get_sum_kbps() *
+                                              time_since_last_encode_ms);
   size_t min_bits = static_cast<size_t>(
       config_.simulcastStream[0].minBitrate * time_since_last_encode_ms);
   if (bits_available < min_bits)
     bits_available = min_bits;
   size_t max_bits =
       static_cast<size_t>(max_target_bitrate_kbps_ * time_since_last_encode_ms);
   if (max_bits > 0 && max_bits < bits_available)
     bits_available = max_bits;
   last_encode_time_ms_ = time_now_ms;
 
@@ skipping 46 matching lines @@
   callback_ = callback;
   return 0;
 }
 
 int32_t FakeEncoder::Release() { return 0; }
 
 int32_t FakeEncoder::SetChannelParameters(uint32_t packet_loss, int64_t rtt) {
   return 0;
 }
 
-int32_t FakeEncoder::SetRates(uint32_t new_target_bitrate, uint32_t framerate) {
-  target_bitrate_kbps_ = new_target_bitrate;
+int32_t FakeEncoder::SetRateAllocation(const BitrateAllocation& rate_allocation,
+                                       uint32_t framerate) {
+  target_bitrate_ = rate_allocation;
   return 0;
 }
 
 const char* FakeEncoder::kImplementationName = "fake_encoder";
 const char* FakeEncoder::ImplementationName() const {
   return kImplementationName;
 }
 
 FakeH264Encoder::FakeH264Encoder(Clock* clock)
     : FakeEncoder(clock), callback_(NULL), idr_counter_(0) {
@@ skipping 70 matching lines @@
   int delay_ms = 0;
   {
     rtc::CritScope lock(&lock_);
     delay_ms = delay_ms_;
   }
   SleepMs(delay_ms);
   return FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
 }
 }  // namespace test
 }  // namespace webrtc