Remove ViEncoder::Pause / Start

webrtc/call/bitrate_allocator.cc

 /*
  *  Copyright (c) 2015 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 35 matching lines @@
   last_fraction_loss_ = fraction_loss;
   last_rtt_ = rtt;
 
   ObserverAllocation allocation = AllocateBitrates(target_bitrate_bps);
   for (const auto& kv : allocation) {
     kv.first->OnBitrateUpdated(kv.second, last_fraction_loss_, last_rtt_);
   }
   last_allocation_ = allocation;
 }
 
-int BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
-                                  uint32_t min_bitrate_bps,
-                                  uint32_t max_bitrate_bps,
-                                  uint32_t pad_up_bitrate_bps,
-                                  bool enforce_min_bitrate) {
+void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
+                                   uint32_t min_bitrate_bps,
+                                   uint32_t max_bitrate_bps,
+                                   uint32_t pad_up_bitrate_bps,
+                                   bool enforce_min_bitrate) {
   rtc::CritScope lock(&crit_sect_);
   auto it = FindObserverConfig(observer);
 
   // Update settings if the observer already exists, create a new one otherwise.
   if (it != bitrate_observer_configs_.end()) {
     it->min_bitrate_bps = min_bitrate_bps;
     it->max_bitrate_bps = max_bitrate_bps;
     it->pad_up_bitrate_bps = pad_up_bitrate_bps;
     it->enforce_min_bitrate = enforce_min_bitrate;
   } else {
@@ skipping 11 matching lines @@
   } else {
     // Currently, an encoder is not allowed to produce frames.
     // But we still have to return the initial config bitrate + let the
     // observer know that it can not produce frames.
     allocation = AllocateBitrates(last_non_zero_bitrate_bps_);
     observer->OnBitrateUpdated(0, last_fraction_loss_, last_rtt_);
   }
   UpdateAllocationLimits();
 
   last_allocation_ = allocation;
-  return allocation[observer];
 }
 
 void BitrateAllocator::UpdateAllocationLimits() {
   uint32_t total_requested_padding_bitrate = 0;
   uint32_t total_requested_min_bitrate = 0;
 
   {
     rtc::CritScope lock(&crit_sect_);
     for (const auto& config : bitrate_observer_configs_) {
       if (config.enforce_min_bitrate) {
@@ skipping 11 matching lines @@
   {
     rtc::CritScope lock(&crit_sect_);
     auto it = FindObserverConfig(observer);
     if (it != bitrate_observer_configs_.end()) {
       bitrate_observer_configs_.erase(it);
     }
   }
   UpdateAllocationLimits();
 }
 
+int BitrateAllocator::GetStartBitrate(BitrateAllocatorObserver* observer) {
+  rtc::CritScope lock(&crit_sect_);
+  const auto& it = last_allocation_.find(observer);
+  if (it != last_allocation_.end())
+    return it->second;
+
+  // This is a new observer that has not yet been started. Assume that if it is
+  // added, all observers would split the available bitrate evenly.
+  return last_non_zero_bitrate_bps_ /

[mflodman, 2016/06/17 11:28:17]

I think this is good enough for now and I'll open a discussion around skipping
the start bitrate in InitEncode call all together.

+         static_cast<int>((bitrate_observer_configs_.size() + 1));
+}
+
 BitrateAllocator::ObserverConfigList::iterator
 BitrateAllocator::FindObserverConfig(
     const BitrateAllocatorObserver* observer) {
   for (auto it = bitrate_observer_configs_.begin();
        it != bitrate_observer_configs_.end(); ++it) {
     if (it->observer == observer)
       return it;
   }
   return bitrate_observer_configs_.end();
 }
@@ skipping 180 matching lines @@
   uint32_t extra_bitrate_per_observer = (bitrate - sum_min_bitrates) /
       static_cast<uint32_t>(bitrate_observer_configs_.size());
   for (const auto& observer_config : bitrate_observer_configs_) {
     if (observer_config.min_bitrate_bps + extra_bitrate_per_observer <
         MinBitrateWithHysteresis(observer_config))
       return false;
   }
   return true;
 }
 }  // namespace webrtc