Implementing auto pausing of video streams.

webrtc/call/bitrate_allocator.h

 /*
  *  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 24 matching lines @@
 };
 
 // Usage: this class will register multiple RtcpBitrateObserver's one at each
 // RTCP module. It will aggregate the results and run one bandwidth estimation
 // and push the result to the encoders via BitrateAllocatorObserver(s).
 class BitrateAllocator {
  public:
   BitrateAllocator();
 
   // Allocate target_bitrate across the registered BitrateAllocatorObservers.
-  // Returns actual bitrate allocated (might be higher than target_bitrate if
-  // for instance EnforceMinBitrate() is enabled.
-  uint32_t OnNetworkChanged(uint32_t target_bitrate,
+  // Returns actual bitrate allocated, which might be higher than target_bitrate
+  // if for instance EnforceMinBitrate() is enabled.
+  uint32_t OnNetworkChanged(uint32_t target_bitrate_bps,
                             uint8_t fraction_loss,
                             int64_t rtt);
 
   // Set the start and max send bitrate used by the bandwidth management.
   //
   // |observer| updates bitrates if already in use.
   // |min_bitrate_bps| = 0 equals no min bitrate.
   // |max_bitrate_bps| = 0 equals no max bitrate.
   // |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
   //    this observer, even if the BWE is too low, 'false' will allocate 0 to
   //    the observer if BWE doesn't allow |min_bitrate_bps|.
   // Returns initial bitrate allocated for |observer|.
   // Note that |observer|->OnBitrateUpdated() will be called within the scope of
   // this method with the current rtt, fraction_loss and available bitrate and
   // that the bitrate in OnBitrateUpdated will be zero if the |observer| is
   // currently not allowed to send data.
   int AddObserver(BitrateAllocatorObserver* observer,
                   uint32_t min_bitrate_bps,
                   uint32_t max_bitrate_bps,
                   bool enforce_min_bitrate);
 
+  // Removes a previously added observer, but will not trigger a new bitrate

[pbos-webrtc, 2016/06/06 15:26:28]

Should this not trigger a new bitrate allocation? If so why?

[mflodman, 2016/06/09 13:23:13]

It has never done it and there is no urgency to actually trigger it for this
case, nothing is getting worse on the network and we might as well wait for the
next "real" update.

[pbos-webrtc, 2016/06/09 13:37:21]

Is there a guarantee that a new estimate will come?

+  // allocation.
   void RemoveObserver(BitrateAllocatorObserver* observer);
 
  private:
+  // Note: All bitrates for member variables and methods are in bps.
   struct ObserverConfig {
     ObserverConfig(BitrateAllocatorObserver* observer,
                    uint32_t min_bitrate_bps,
                    uint32_t max_bitrate_bps,
                    bool enforce_min_bitrate)
         : observer(observer),
           min_bitrate_bps(min_bitrate_bps),
           max_bitrate_bps(max_bitrate_bps),
           enforce_min_bitrate(enforce_min_bitrate) {}
     BitrateAllocatorObserver* const observer;
     uint32_t min_bitrate_bps;
     uint32_t max_bitrate_bps;
     bool enforce_min_bitrate;
   };
 
-  // This method controls the behavior when the available bitrate is lower than
-  // the minimum bitrate, or the sum of minimum bitrates.
-  // When true, the bitrate will never be set lower than the minimum bitrate(s).
-  // When false, the bitrate observers will be allocated rates up to their
-  // respective minimum bitrate, satisfying one observer after the other.
-  void EnforceMinBitrate(bool enforce_min_bitrate)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
-
   typedef std::list<ObserverConfig> ObserverConfigList;
   ObserverConfigList::iterator FindObserverConfig(
       const BitrateAllocatorObserver* observer)
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
 
   typedef std::multimap<uint32_t, const ObserverConfig*> ObserverSortingMap;
   typedef std::map<BitrateAllocatorObserver*, int> ObserverAllocation;
 
   ObserverAllocation AllocateBitrates(uint32_t bitrate)
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
-  ObserverAllocation NormalRateAllocation(uint32_t bitrate,
-                                          uint32_t sum_min_bitrates)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
 
   ObserverAllocation ZeroRateAllocation() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
   ObserverAllocation LowRateAllocation(uint32_t bitrate)
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+  ObserverAllocation NormalRateAllocation(uint32_t bitrate,

[pbos-webrtc, 2016/06/06 15:26:28]

_bps on everything here please

[mflodman, 2016/06/09 13:23:13]

See my previous reply.

+                                          uint32_t sum_min_bitrates)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+  ObserverAllocation MaxRateAllocation(uint32_t bitrate,
+                                       uint32_t sum_max_bitrates)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+
+  uint32_t LastAllocatedBitrate(const ObserverConfig& observer_config)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+  // The minimum bitrate required by this observer, including enable-hysteresis
+  // if the observer is in a paused state.
+  uint32_t MinBitrateForObserver(const ObserverConfig& observer_config)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+  // Splits |bitrate| evenly to all observers with a non-zero bitrate in
+  // |allocation|. The allowed max bitrate is |max_multiplier| x observer max
+  // bitrate.
+  void DistributeBitrateEvenly(
+      uint32_t bitrate, int max_multiplier, ObserverAllocation* allocation)
+          EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+  bool ShouldDoLowRateAllocation(uint32_t bitrate, uint32_t sum_min_bitrates)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+
 
   rtc::CriticalSection crit_sect_;
   // Stored in a list to keep track of the insertion order.
   ObserverConfigList bitrate_observer_configs_ GUARDED_BY(crit_sect_);
-  bool enforce_min_bitrate_ GUARDED_BY(crit_sect_);
   uint32_t last_bitrate_bps_ GUARDED_BY(crit_sect_);
   uint32_t last_non_zero_bitrate_bps_ GUARDED_BY(crit_sect_);
   uint8_t last_fraction_loss_ GUARDED_BY(crit_sect_);
   int64_t last_rtt_ GUARDED_BY(crit_sect_);
+  ObserverAllocation last_allocation_ GUARDED_BY(crit_sect_);
 };
 }  // namespace webrtc
 #endif  // WEBRTC_CALL_BITRATE_ALLOCATOR_H_