BWE allocation strategy

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 38 matching lines @@
     : limit_observer_(limit_observer),
       bitrate_observer_configs_(),
       last_bitrate_bps_(0),
       last_non_zero_bitrate_bps_(kDefaultBitrateBps),
       last_fraction_loss_(0),
       last_rtt_(0),
       num_pause_events_(0),
       clock_(Clock::GetRealTimeClock()),
       last_bwe_log_time_(0),
       total_requested_padding_bitrate_(0),
-      total_requested_min_bitrate_(0) {
+      total_requested_min_bitrate_(0),
+      bitrate_allocation_strategy_(nullptr) {
   sequenced_checker_.Detach();
 }
 
 BitrateAllocator::~BitrateAllocator() {
   RTC_HISTOGRAM_COUNTS_100("WebRTC.Call.NumberOfPauseEvents",
                            num_pause_events_);
 }
 
 void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
                                         uint8_t fraction_loss,
@@ skipping 147 matching lines @@
   } else if (it->allocated_bitrate_bps == -1) {
     // This observer hasn't received an allocation yet, so do the same.
     return last_non_zero_bitrate_bps_ /
            static_cast<int>(bitrate_observer_configs_.size());
   } else {
     // This observer already has an allocation.
     return it->allocated_bitrate_bps;
   }
 }
 
+void BitrateAllocator::SetBitrateAllocationStrategy(
+    rtc::BitrateAllocationStrategy* bitrate_allocation_strategy) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
+  bitrate_allocation_strategy_ = bitrate_allocation_strategy;
+}
+
 BitrateAllocator::ObserverConfigs::iterator
 BitrateAllocator::FindObserverConfig(const BitrateAllocatorObserver* observer) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   for (auto it = bitrate_observer_configs_.begin();
        it != bitrate_observer_configs_.end(); ++it) {
     if (it->observer == observer)
       return it;
   }
   return bitrate_observer_configs_.end();
 }
 
+BitrateAllocator::ObserverConfigs::iterator
+BitrateAllocator::FindObserverConfig(const std::string track_id) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
+  for (auto it = bitrate_observer_configs_.begin();
+       it != bitrate_observer_configs_.end(); ++it) {
+    if (it->track_id == track_id)
+      return it;
+  }
+  return bitrate_observer_configs_.end();
+}
+
 BitrateAllocator::ObserverAllocation BitrateAllocator::AllocateBitrates(
     uint32_t bitrate) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   if (bitrate_observer_configs_.empty())
     return ObserverAllocation();
 
+  if (bitrate_allocation_strategy_ != nullptr) {
+    rtc::BitrateAllocationStrategy::TrackConfigs track_configs;
+    for (auto& observer_config : bitrate_observer_configs_) {
+      // The strategy will not be able to handle track without ID specifically
+      // but it will be able to handle it in some general way. For example a
+      // strategy giving priotiry to audio streams will consider a stream
+      // without an ID as a non-audio streams and will allocate bitrate for it
+      // after required minimum allocated for audio.
+      if (observer_config.track_id.size() == 0) {
+        observer_config.track_id =
+          (std::stringstream() <<
+            static_cast<const void*>(observer_config.observer)).str();
+      }
+      track_configs[observer_config.track_id] =
+          rtc::BitrateAllocationStrategy::TrackConfig(
+              observer_config.min_bitrate_bps, observer_config.max_bitrate_bps,
+              observer_config.enforce_min_bitrate, observer_config.track_id);
+    }
+    rtc::BitrateAllocationStrategy::TrackAllocations track_allocations =
+        bitrate_allocation_strategy_->AllocateBitrates(bitrate, track_configs);
+    ObserverAllocation allocation;
+    for (const auto& observer_config : bitrate_observer_configs_) {
+      // The strategy should return allocation for all tracks.
+      // In release builds still may be better to use zero allocation
+      // rathen than crash
+      RTC_DCHECK(track_allocations.find(observer_config.track_id) !=
+                 track_allocations.end());
+      allocation[observer_config.observer] =
+          track_allocations[observer_config.track_id];
+    }
+    return allocation;
+  }
+
   if (bitrate == 0)
     return ZeroRateAllocation();
 
   uint32_t sum_min_bitrates = 0;
   uint32_t sum_max_bitrates = 0;
   for (const auto& observer_config : bitrate_observer_configs_) {
     sum_min_bitrates += observer_config.min_bitrate_bps;
     sum_max_bitrates += observer_config.max_bitrate_bps;
   }
 
@@ skipping 178 matching lines @@
       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