Fix suspend below min bitrate in new API by making it possible to set min bitrate at the receive-si…

webrtc/video_engine/vie_channel_group.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 25 matching lines @@
 namespace {
 
 static const uint32_t kTimeOffsetSwitchThreshold = 30;
 
 class WrappingBitrateEstimator : public RemoteBitrateEstimator {
  public:
   WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock)
       : observer_(observer),
         clock_(clock),
         crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
-        min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
-        rbe_(new RemoteBitrateEstimatorSingleStream(observer_,
-                                                    clock_,
-                                                    min_bitrate_bps_)),
+        rbe_(new RemoteBitrateEstimatorSingleStream(observer_, clock_)),
         using_absolute_send_time_(false),
-        packets_since_absolute_send_time_(0) {}
+        packets_since_absolute_send_time_(0),
+        min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) {}
 
   virtual ~WrappingBitrateEstimator() {}
 
   void IncomingPacket(int64_t arrival_time_ms,
                       size_t payload_size,
                       const RTPHeader& header,
                       bool was_paced) override {
     CriticalSectionScoped cs(crit_sect_.get());
     PickEstimatorFromHeader(header);
     rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced);
@@ skipping 23 matching lines @@
                       unsigned int* bitrate_bps) const override {
     CriticalSectionScoped cs(crit_sect_.get());
     return rbe_->LatestEstimate(ssrcs, bitrate_bps);
   }
 
   bool GetStats(ReceiveBandwidthEstimatorStats* output) const override {
     CriticalSectionScoped cs(crit_sect_.get());
     return rbe_->GetStats(output);
   }
 
+  void SetMinBitrate(int min_bitrate_bps) {
+    CriticalSectionScoped cs(crit_sect_.get());
+    rbe_->SetMinBitrate(min_bitrate_bps);
+    min_bitrate_bps_ = min_bitrate_bps;
+  }
+
  private:
   void PickEstimatorFromHeader(const RTPHeader& header)
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
     if (header.extension.hasAbsoluteSendTime) {
       // If we see AST in header, switch RBE strategy immediately.
       if (!using_absolute_send_time_) {
         LOG(LS_INFO) <<
             "WrappingBitrateEstimator: Switching to absolute send time RBE.";
         using_absolute_send_time_ = true;
         PickEstimator();
       }
       packets_since_absolute_send_time_ = 0;
     } else {
       // When we don't see AST, wait for a few packets before going back to TOF.
       if (using_absolute_send_time_) {
         ++packets_since_absolute_send_time_;
         if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) {
           LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission "
                        << "time offset RBE.";
           using_absolute_send_time_ = false;
           PickEstimator();
         }
       }
     }
   }
 
   // Instantiate RBE for Time Offset or Absolute Send Time extensions.
   void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
     if (using_absolute_send_time_) {
-      rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_,
-                                                       min_bitrate_bps_));
+      rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_));
     } else {
-      rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_,
-                                                        min_bitrate_bps_));
+      rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_));
     }
+    rbe_->SetMinBitrate(min_bitrate_bps_);
   }
 
   RemoteBitrateObserver* observer_;
   Clock* clock_;
   rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
-  const uint32_t min_bitrate_bps_;
   rtc::scoped_ptr<RemoteBitrateEstimator> rbe_;
   bool using_absolute_send_time_;
   uint32_t packets_since_absolute_send_time_;
+  int min_bitrate_bps_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator);
 };
 
 }  // namespace
 
 ChannelGroup::ChannelGroup(ProcessThread* process_thread)
     : remb_(new VieRemb()),
       bitrate_allocator_(new BitrateAllocator()),
       call_stats_(new CallStats()),
       packet_router_(new PacketRouter()),
       pacer_(new PacedSender(Clock::GetRealTimeClock(),
                              packet_router_.get(),
                              BitrateController::kDefaultStartBitrateKbps,
                              PacedSender::kDefaultPaceMultiplier *
                                  BitrateController::kDefaultStartBitrateKbps,
                              0)),
       remote_bitrate_estimator_(
           new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())),
       remote_estimator_proxy_(
           new RemoteEstimatorProxy(Clock::GetRealTimeClock(),
                                    packet_router_.get())),
       encoder_state_feedback_(new EncoderStateFeedback()),
       process_thread_(process_thread),
       pacer_thread_(ProcessThread::Create("PacerThread")),
       // Constructed last as this object calls the provided callback on
       // construction.
       bitrate_controller_(
           BitrateController::CreateBitrateController(Clock::GetRealTimeClock(),
-                                                     this)) {
+                                                     this)),
+      min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) {
   call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get());
 
   pacer_thread_->RegisterModule(pacer_.get());
   pacer_thread_->Start();
 
   process_thread->RegisterModule(remote_estimator_proxy_.get());
   process_thread->RegisterModule(remote_bitrate_estimator_.get());
   process_thread->RegisterModule(call_stats_.get());
   process_thread->RegisterModule(bitrate_controller_.get());
 }
@@ skipping 27 matching lines @@
       break;
     }
   }
   if (transport_seq_enabled) {
     if (transport_feedback_adapter_.get() == nullptr) {
       transport_feedback_adapter_.reset(new TransportFeedbackAdapter(
           bitrate_controller_->CreateRtcpBandwidthObserver(),
           Clock::GetRealTimeClock(), process_thread_));
       transport_feedback_adapter_->SetBitrateEstimator(
           new RemoteBitrateEstimatorAbsSendTime(
-              transport_feedback_adapter_.get(), Clock::GetRealTimeClock(),
-              RemoteBitrateEstimator::kDefaultMinBitrateBps));
+              transport_feedback_adapter_.get(), Clock::GetRealTimeClock()));
+      transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate(
+          min_bitrate_bps_);
       call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get());
     }
     transport_feedback_observer = transport_feedback_adapter_.get();
   }
 
   const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
   RTC_DCHECK(!ssrcs.empty());
   rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder(
       channel_id, number_of_cores, process_thread_, stats_proxy,
       pre_encode_callback, pacer_.get(), bitrate_allocator_.get()));
@@ skipping 129 matching lines @@
   channel_map_.erase(c_it);
 
   return channel;
 }
 
 void ChannelGroup::SetSyncInterface(VoEVideoSync* sync_interface) {
   for (auto channel : channel_map_)
     channel.second->SetVoiceChannel(-1, sync_interface);
 }
 
+void ChannelGroup::SetBweBitrates(int min_bitrate_bps,
+                                  int start_bitrate_bps,
+                                  int max_bitrate_bps) {
+  if (start_bitrate_bps > 0)
+    bitrate_controller_->SetStartBitrate(start_bitrate_bps);
+  bitrate_controller_->SetMinMaxBitrate(min_bitrate_bps, max_bitrate_bps);
+  if (remote_bitrate_estimator_.get())
+    remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps);
+  if (transport_feedback_adapter_.get())
+    transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate(
+        min_bitrate_bps);
+  min_bitrate_bps_ = min_bitrate_bps;
+}
+
 BitrateController* ChannelGroup::GetBitrateController() const {
   return bitrate_controller_.get();
 }
 
 RemoteBitrateEstimator* ChannelGroup::GetRemoteBitrateEstimator() const {
   return remote_bitrate_estimator_.get();
 }
 
 CallStats* ChannelGroup::GetCallStats() const {
   return call_stats_.get();
@@ skipping 35 matching lines @@
     rtc::CritScope lock(&encoder_map_crit_);
     for (const auto& encoder : vie_encoder_map_)
       pad_up_to_bitrate_bps += encoder.second->GetPaddingNeededBps();
   }
   pacer_->UpdateBitrate(
       target_bitrate_bps / 1000,
       PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000,
       pad_up_to_bitrate_bps / 1000);
 }
 }  // namespace webrtc