Extract simulcast rate allocation outside of video encoder.

webrtc/modules/video_coding/codecs/vp8/vp8_impl.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 11 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
+#include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace {
 
 enum { kVp8ErrorPropagationTh = 30 };
 enum { kVp832ByteAlign = 32 };
 
 // VP8 denoiser states.
 enum denoiserState {
@@ skipping 10 matching lines @@
 int GCD(int a, int b) {
   int c = a % b;
   while (c != 0) {
     a = b;
     b = c;
     c = a % b;
   }
   return b;
 }
 
-std::vector<int> GetStreamBitratesKbps(const VideoCodec& codec,
-                                       int bitrate_to_allocate_kbps) {
-  if (codec.numberOfSimulcastStreams <= 1) {
-    return std::vector<int>(1, bitrate_to_allocate_kbps);
-  }
-
-  std::vector<int> bitrates_kbps(codec.numberOfSimulcastStreams);
-  // Allocate min -> target bitrates as long as we have bitrate to spend.
-  size_t last_active_stream = 0;
-  for (size_t i = 0; i < static_cast<size_t>(codec.numberOfSimulcastStreams) &&
-                     bitrate_to_allocate_kbps >=
-                         static_cast<int>(codec.simulcastStream[i].minBitrate);
-       ++i) {
-    last_active_stream = i;
-    int allocated_bitrate_kbps =
-        std::min(static_cast<int>(codec.simulcastStream[i].targetBitrate),
-                 bitrate_to_allocate_kbps);
-    bitrates_kbps[i] = allocated_bitrate_kbps;
-    bitrate_to_allocate_kbps -= allocated_bitrate_kbps;
-  }
-
-  // Spend additional bits on the highest-quality active layer, up to max
-  // bitrate.
-  // TODO(pbos): Consider spending additional bits on last_active_stream-1 down
-  // to 0 and not just the top layer when we have additional bitrate to spend.
-  int allocated_bitrate_kbps = std::min(
-      static_cast<int>(codec.simulcastStream[last_active_stream].maxBitrate -
-                       bitrates_kbps[last_active_stream]),
-      bitrate_to_allocate_kbps);
-  bitrates_kbps[last_active_stream] += allocated_bitrate_kbps;
-  bitrate_to_allocate_kbps -= allocated_bitrate_kbps;
-
-  // Make sure we can always send something. Suspending below min bitrate is
-  // controlled outside the codec implementation and is not overriden by this.
-  if (bitrates_kbps[0] < static_cast<int>(codec.simulcastStream[0].minBitrate))
-    bitrates_kbps[0] = static_cast<int>(codec.simulcastStream[0].minBitrate);
-
-  return bitrates_kbps;
-}
-
 uint32_t SumStreamMaxBitrate(int streams, const VideoCodec& codec) {
   uint32_t bitrate_sum = 0;
   for (int i = 0; i < streams; ++i) {
     bitrate_sum += codec.simulcastStream[i].maxBitrate;
   }
   return bitrate_sum;
 }
 
 int NumberOfStreams(const VideoCodec& codec) {
   int streams =
@@ skipping 30 matching lines @@
 }  // namespace
 
 VP8Encoder* VP8Encoder::Create() {
   return new VP8EncoderImpl();
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
-const float kTl1MaxTimeToDropFrames = 20.0f;
-
 VP8EncoderImpl::VP8EncoderImpl()
-    : encoded_complete_callback_(NULL),
+    : encoded_complete_callback_(nullptr),
+      rate_allocator_(new SimulcastRateAllocator(codec_)),
       inited_(false),
       timestamp_(0),
       feedback_mode_(false),
       qp_max_(56),  // Setting for max quantizer.
       cpu_speed_default_(-6),
       rc_max_intra_target_(0),
       token_partitions_(VP8_ONE_TOKENPARTITION),
       down_scale_requested_(false),
       down_scale_bitrate_(0),
-      tl0_frame_dropper_(),
-      tl1_frame_dropper_(kTl1MaxTimeToDropFrames),
       key_frame_request_(kMaxSimulcastStreams, false),
       quality_scaler_enabled_(false) {
   uint32_t seed = rtc::Time32();
   srand(seed);
 
   picture_id_.reserve(kMaxSimulcastStreams);
   last_key_frame_picture_id_.reserve(kMaxSimulcastStreams);
   temporal_layers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
@@ skipping 89 matching lines @@
     // above some threshold (base temporal layer is down to 1/4 for 3 layers).
     // We may want to condition this on bitrate later.
     if (new_framerate > 20) {
       configurations_[encoders_.size() - 1].rc_max_quantizer = 45;
     } else {
       // Go back to default value set in InitEncode.
       configurations_[encoders_.size() - 1].rc_max_quantizer = qp_max_;
     }
   }
 
-  std::vector<int> stream_bitrates =
-      GetStreamBitratesKbps(codec_, new_bitrate_kbit);
+  std::vector<uint32_t> stream_bitrates =
+      rate_allocator_->GetAllocation(new_bitrate_kbit);
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     if (encoders_.size() > 1)
       SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
 
     unsigned int target_bitrate = stream_bitrates[stream_idx];
     unsigned int max_bitrate = codec_.maxBitrate;
     int framerate = new_framerate;
     // TODO(holmer): This is a temporary hack for screensharing, where we
     // interpret the startBitrate as the encoder target bitrate. This is
@@ skipping 108 matching lines @@
 
   // TODO(andresp): crash if num temporal layers is bananas.
   if (num_temporal_layers < 1)
     num_temporal_layers = 1;
   SetupTemporalLayers(number_of_streams, num_temporal_layers, *inst);
 
   feedback_mode_ = inst->codecSpecific.VP8.feedbackModeOn;
 
   timestamp_ = 0;
   codec_ = *inst;
+  rate_allocator_.reset(new SimulcastRateAllocator(codec_));
 
   // Code expects simulcastStream resolutions to be correct, make sure they are
   // filled even when there are no simulcast layers.
   if (codec_.numberOfSimulcastStreams == 0) {
     codec_.simulcastStream[0].width = codec_.width;
     codec_.simulcastStream[0].height = codec_.height;
   }
 
   picture_id_.resize(number_of_streams);
   last_key_frame_picture_id_.resize(number_of_streams);
@@ skipping 147 matching lines @@
 
   if (encoders_.size() == 1) {
     configurations_[0].rc_target_bitrate = inst->startBitrate;
     temporal_layers_[0]->ConfigureBitrates(inst->startBitrate, inst->maxBitrate,
                                            inst->maxFramerate,
                                            &configurations_[0]);
   } else {
     // Note the order we use is different from webm, we have lowest resolution
     // at position 0 and they have highest resolution at position 0.
     int stream_idx = encoders_.size() - 1;
-    std::vector<int> stream_bitrates =
-        GetStreamBitratesKbps(codec_, inst->startBitrate);
+    std::vector<uint32_t> stream_bitrates =
+        rate_allocator_->GetAllocation(inst->startBitrate);
     SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
     configurations_[0].rc_target_bitrate = stream_bitrates[stream_idx];
     temporal_layers_[stream_idx]->ConfigureBitrates(
         stream_bitrates[stream_idx], inst->maxBitrate, inst->maxFramerate,
         &configurations_[0]);
     --stream_idx;
     for (size_t i = 1; i < encoders_.size(); ++i, --stream_idx) {
       memcpy(&configurations_[i], &configurations_[0],
              sizeof(configurations_[0]));
 
@@ skipping 819 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc