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

webrtc/modules/video_coding/video_sender.cc

Index: webrtc/modules/video_coding/video_sender.cc
diff --git a/webrtc/modules/video_coding/video_sender.cc b/webrtc/modules/video_coding/video_sender.cc
index b7664a719b3a7d155d23666df94663928087bc8c..b0062f6b29c212da658b2ad61cb12ad3f4164674 100644
--- a/webrtc/modules/video_coding/video_sender.cc
+++ b/webrtc/modules/video_coding/video_sender.cc
@@ -14,9 +14,12 @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_types.h"
+#include "webrtc/common_video/include/video_bitrate_allocator.h"

[stefan-webrtc, 2016/11/02 10:26:36]

Do you have to include both this one and default_video_bitrate_allocator.h?

[sprang_webrtc, 2016/11/02 13:28:33]

I don't have to, but I think this follows the "include what you use" rule. We
use both a raw VideoBitrateAllocator interface and the
DefaultVideoBitrateAllocator class, so I prefer not to include the interface
implicitly.

[stefan-webrtc, 2016/11/03 13:34:58]

Acknowledged.

 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/encoded_frame.h"
+#include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/video_coding_impl.h"
 #include "webrtc/system_wrappers/include/clock.h"
@@ -36,7 +39,7 @@ VideoSender::VideoSender(Clock* clock,
       frame_dropper_enabled_(true),
       _sendStatsTimer(1000, clock_),
       current_codec_(),
-      encoder_params_({0, 0, 0, 0}),
+      encoder_params_({BitrateAllocation(), 0, 0, 0}),
       encoder_has_internal_source_(false),
       next_frame_types_(1, kVideoFrameDelta) {
   _mediaOpt.Reset();
@@ -172,7 +175,7 @@ int VideoSender::Bitrate(unsigned int* bitrate) const {
 
   if (!_encoder)
     return VCM_UNINITIALIZED;
-  *bitrate = _encoder->GetEncoderParameters().target_bitrate;
+  *bitrate = _encoder->GetEncoderParameters().target_bitrate.get_sum_bps();
   return 0;
 }
 
@@ -189,15 +192,25 @@ int VideoSender::FrameRate(unsigned int* framerate) const {
   return 0;
 }
 
-int32_t VideoSender::SetChannelParameters(uint32_t target_bitrate,
-                                          uint8_t lossRate,
-                                          int64_t rtt) {
-  uint32_t target_rate =
-      _mediaOpt.SetTargetRates(target_bitrate, lossRate, rtt);
-
+int32_t VideoSender::SetChannelParameters(
+    uint32_t target_bitrate_bps,
+    uint8_t lossRate,
+    int64_t rtt,
+    VideoBitrateAllocator* bitrate_allocator) {

[stefan-webrtc, 2016/11/02 10:26:36]

Does this change on every channel parameter update? Should it be set in the ctor
instead?

[sprang_webrtc, 2016/11/02 13:28:33]

The bitrate_allocator is owned by ViEEncoder, and may change on
ReconfigureEncoder(). I included it as a parameter here rather than set up an
explicit setter method and keeping a state.

[stefan-webrtc, 2016/11/03 13:34:58]

Probably good, or perhaps you should pass in a BitrateAllocation instead? And if
it's nullptr you create a default allocation?

[sprang_webrtc, 2016/11/03 14:36:59]

The reason I pass down the allocator reference is that it needs the
input_frame_rate as argument. That is calculated by _mediaOpt in VideoSender...
The default allocator path is just used in tests.

I hope we can clean this up if we merge VideoSender ViEEncoder.

[stefan-webrtc, 2016/11/03 15:32:08]

I don't know how, but I missed that.

+  uint32_t video_target_rate_bps =
+      _mediaOpt.SetTargetRates(target_bitrate_bps, lossRate, rtt);
   uint32_t input_frame_rate = _mediaOpt.InputFrameRate();
+  BitrateAllocation bitrate_allocation;
+  if (bitrate_allocator) {
+    bitrate_allocation = bitrate_allocator->GetAllocation(video_target_rate_bps,
+                                                          input_frame_rate);
+  } else {
+    DefaultVideoBitrateAllocator default_allocator(current_codec_);
+    bitrate_allocation = default_allocator.GetAllocation(video_target_rate_bps,
+                                                         input_frame_rate);
+  }
 
-  EncoderParameters encoder_params = {target_rate, lossRate, rtt,
+  EncoderParameters encoder_params = {bitrate_allocation, lossRate, rtt,
                                       input_frame_rate};
   bool encoder_has_internal_source;
   {
@@ -228,7 +241,7 @@ void VideoSender::SetEncoderParameters(EncoderParameters params,
   // encoder implementations behave when given a zero target bitrate.
   // TODO(perkj): Make sure all known encoder implementations handle zero
   // target bitrate and remove this check.
-  if (!has_internal_source && params.target_bitrate == 0)
+  if (!has_internal_source && params.target_bitrate.get_sum_bps() == 0)
     return;
 
   if (params.input_frame_rate == 0) {
@@ -268,7 +281,8 @@ int32_t VideoSender::AddVideoFrame(const VideoFrame& videoFrame,
   SetEncoderParameters(encoder_params, encoder_has_internal_source);
   if (_mediaOpt.DropFrame()) {
     LOG(LS_VERBOSE) << "Drop Frame "
-                    << "target bitrate " << encoder_params.target_bitrate
+                    << "target bitrate "
+                    << encoder_params.target_bitrate.get_sum_bps()
                     << " loss rate " << encoder_params.loss_rate << " rtt "
                     << encoder_params.rtt << " input frame rate "
                     << encoder_params.input_frame_rate;