Wire up BitrateAllocation to be sent as RTCP TargetBitrate

webrtc/modules/video_coding/video_sender.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.
  */
 
@@ skipping 177 matching lines @@
   if (!_encoder)
     return VCM_UNINITIALIZED;
 
   *framerate = _encoder->GetEncoderParameters().input_frame_rate;
   return 0;
 }
 
 EncoderParameters VideoSender::UpdateEncoderParameters(
     const EncoderParameters& params,
     VideoBitrateAllocator* bitrate_allocator,
-    uint32_t target_bitrate_bps) {
+    uint32_t target_bitrate_bps,
+    VideoBitrateAllocationObserver* bitrate_observer) {

[danilchap, 2016/11/29 10:39:31]

bitrate_observer used as callback (called during this function, not used after
function is finished)
not like an observer (stored somewhere and called periodically as result of
different function calls)
may be rename the variable to to include callback instead of observer?

[sprang_webrtc, 2016/11/29 12:24:01]

Done.

   uint32_t video_target_rate_bps = _mediaOpt.SetTargetRates(
       target_bitrate_bps, params.loss_rate, params.rtt);
   uint32_t input_frame_rate = _mediaOpt.InputFrameRate();
   if (input_frame_rate == 0)
     input_frame_rate = current_codec_.maxFramerate;
 
   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);
   }
-
+  if (bitrate_observer)
+    bitrate_observer->OnBitrateAllocationUpdated(bitrate_allocation);
   EncoderParameters new_encoder_params = {bitrate_allocation, params.loss_rate,
                                           params.rtt, input_frame_rate};
   return new_encoder_params;
 }
 
 void VideoSender::UpdateChannelParemeters(
-    VideoBitrateAllocator* bitrate_allocator) {
+    VideoBitrateAllocator* bitrate_allocator,
+    VideoBitrateAllocationObserver* bitrate_observer) {
   rtc::CritScope cs(&params_crit_);
-  encoder_params_ =
-      UpdateEncoderParameters(encoder_params_, bitrate_allocator,
-                              encoder_params_.target_bitrate.get_sum_bps());
+  encoder_params_ = UpdateEncoderParameters(
+      encoder_params_, bitrate_allocator,
+      encoder_params_.target_bitrate.get_sum_bps(), bitrate_observer);
 }
 
 int32_t VideoSender::SetChannelParameters(
     uint32_t target_bitrate_bps,
     uint8_t lossRate,
     int64_t rtt,
-    VideoBitrateAllocator* bitrate_allocator) {
+    VideoBitrateAllocator* bitrate_allocator,
+    VideoBitrateAllocationObserver* bitrate_observer) {
   EncoderParameters encoder_params;
   encoder_params.loss_rate = lossRate;
   encoder_params.rtt = rtt;
-  encoder_params = UpdateEncoderParameters(encoder_params, bitrate_allocator,
-                                           target_bitrate_bps);
+  encoder_params = UpdateEncoderParameters(
+      encoder_params, bitrate_allocator, target_bitrate_bps, bitrate_observer);
 
   bool encoder_has_internal_source;
   {
     rtc::CritScope cs(&params_crit_);
     encoder_params_ = encoder_params;
     encoder_has_internal_source = encoder_has_internal_source_;
   }
 
   // For encoders with internal sources, we need to tell the encoder directly,
   // instead of waiting for an AddVideoFrame that will never come (internal
@@ skipping 140 matching lines @@
 }
 
 int32_t VideoSender::EnableFrameDropper(bool enable) {
   rtc::CritScope lock(&encoder_crit_);
   frame_dropper_enabled_ = enable;
   _mediaOpt.EnableFrameDropper(enable);
   return VCM_OK;
 }
 }  // namespace vcm
 }  // namespace webrtc