Move BitrateAllocator reference from ViEEncoder to VideoSendStream.

webrtc/video/video_send_stream.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 138 matching lines @@
   return options;
 }
 }  // namespace
 
 namespace internal {
 VideoSendStream::VideoSendStream(
     int num_cpu_cores,
     ProcessThread* module_process_thread,
     CallStats* call_stats,
     CongestionController* congestion_controller,
+    BitrateAllocator* bitrate_allocator,
     VieRemb* remb,
-    BitrateAllocator* bitrate_allocator,
     const VideoSendStream::Config& config,
     const VideoEncoderConfig& encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       encoded_frame_proxy_(config.post_encode_callback),
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
+      bitrate_allocator_(bitrate_allocator),
       remb_(remb),
       encoder_thread_(EncoderThreadFunction, this, "EncoderThread"),
       encoder_wakeup_event_(false, false),
       stop_encoder_thread_(0),
       overuse_detector_(
           Clock::GetRealTimeClock(),
           GetCpuOveruseOptions(config.encoder_settings.full_overuse_time),
           this,
           config.post_encode_callback,
           &stats_proxy_),
@@ skipping 12 matching lines @@
                    config_.rtp.ssrcs.size(),
                    true),
       vie_receiver_(vie_channel_.vie_receiver()),
       vie_encoder_(num_cpu_cores,
                    config_.rtp.ssrcs,
                    module_process_thread_,
                    &stats_proxy_,
                    config.pre_encode_callback,
                    &overuse_detector_,
                    congestion_controller_->pacer(),
-                   &payload_router_,
-                   bitrate_allocator),
+                   &payload_router_),
       vcm_(vie_encoder_.vcm()),
       rtp_rtcp_modules_(vie_channel_.rtp_rtcp()),
       input_(&encoder_wakeup_event_,
              config_.local_renderer,
              &stats_proxy_,
              &overuse_detector_) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
 
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
   RTC_DCHECK(module_process_thread_);
@@ skipping 74 matching lines @@
                       config.encoder_settings.payload_type,
                       config.encoder_settings.internal_source));
 
   ReconfigureVideoEncoder(encoder_config);
 
   vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_);
 
   if (config_.post_encode_callback)
     vie_encoder_.RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
-  if (config_.suspend_below_min_bitrate)
-    vie_encoder_.SuspendBelowMinBitrate();
+  if (config_.suspend_below_min_bitrate) {
+    vcm_->SuspendBelowMinBitrate();
+    bitrate_allocator_->EnforceMinBitrate(false);
+  }
 
   vie_channel_.RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
   vie_channel_.RegisterSendBitrateObserver(&stats_proxy_);
   vie_channel_.RegisterSendFrameCountObserver(&stats_proxy_);
 
   module_process_thread_->RegisterModule(&overuse_detector_);
 
   encoder_thread_.Start();
   encoder_thread_.SetPriority(rtc::kHighPriority);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
+
+  bitrate_allocator_->RemoveObserver(this);
   Stop();
 
   // Stop the encoder thread permanently.
   rtc::AtomicOps::ReleaseStore(&stop_encoder_thread_, 1);
   encoder_wakeup_event_.Set();
   encoder_thread_.Stop();
 
   module_process_thread_->DeRegisterModule(&overuse_detector_);
   vie_channel_.RegisterSendFrameCountObserver(nullptr);
   vie_channel_.RegisterSendBitrateObserver(nullptr);
@@ skipping 183 matching lines @@
     video_codec.maxBitrate =
         (video_codec.width * video_codec.height * video_codec.maxFramerate) /
         1000;
   }
   if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
     video_codec.maxBitrate = kEncoderMinBitrateKbps;
 
   RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
 
+  video_codec.startBitrate =
+      bitrate_allocator_->AddObserver(this,
+                                      video_codec.minBitrate * 1000,
+                                      video_codec.maxBitrate * 1000) / 1000;
   vie_encoder_.SetEncoder(video_codec, config.min_transmit_bitrate_bps);
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   return vie_receiver_->DeliverRtcp(packet, length);
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
   return stats_proxy_.GetStats();
 }
@@ skipping 78 matching lines @@
   vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp);
   if (state == kNetworkDown) {
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
       rtp_rtcp->SetRTCPStatus(RtcpMode::kOff);
   }
 }
 
 int VideoSendStream::GetPaddingNeededBps() const {
   return vie_encoder_.GetPaddingNeededBps();
 }
+
+void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
+                                       uint8_t fraction_loss,
+                                       int64_t rtt) {
+  vie_encoder_.OnBitrateUpdated(bitrate_bps, fraction_loss, rtt);
+}
+
 }  // namespace internal
 }  // namespace webrtc