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 122 matching lines @@
   LOG(LS_INFO) << "UpdateAllocationLimits : total_requested_min_bitrate: "
                << total_requested_min_bitrate
                << "bps, total_requested_padding_bitrate: "
                << total_requested_padding_bitrate << "bps";
   limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate,
                                              total_requested_padding_bitrate);
 }
 
 void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
+
   auto it = FindObserverConfig(observer);
   if (it != bitrate_observer_configs_.end()) {
     bitrate_observer_configs_.erase(it);
   }
 
   UpdateAllocationLimits();
 }
 
 int BitrateAllocator::GetStartBitrate(BitrateAllocatorObserver* observer) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   const auto& it = FindObserverConfig(observer);
   if (it == bitrate_observer_configs_.end()) {
     // This observer hasn't been added yet, just give it its fair share.
     return last_non_zero_bitrate_bps_ /
            static_cast<int>((bitrate_observer_configs_.size() + 1));
   } 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::ObserverAllocation BitrateAllocator::AllocateBitrates(
     uint32_t bitrate) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   if (bitrate_observer_configs_.empty())
     return ObserverAllocation();
 
+  if (bitrate_allocation_strategy_ != nullptr) {
+    std::vector<const rtc::BitrateAllocationStrategy::TrackConfig*>
+        track_configs(bitrate_observer_configs_.size());
+    for (auto it = bitrate_observer_configs_.begin();
+         it != bitrate_observer_configs_.end(); ++it) {
+      track_configs[it - bitrate_observer_configs_.begin()] = &*it;
+    }

[Taylor Brandstetter, 2017/09/15 01:24:41]

nit: I think a foreach style loop would still be more readable:

int i = 0;
for (const auto& c : bitrate_observer_configs_) {
  track_configs[i++] = &c;
}

Or you could even do this if you wanna be fancy:

std::transform(bitrate_observer_configs_.begin(), 
               bitrate_observer_configs_.end(),
               track_configs.begin(),
               [](const rtc::BitrateAllocationStrategy::TrackConfig& c) { return
&c; });

[alexnarest, 2017/09/15 08:29:39]

Done.

+    std::vector<uint32_t> track_allocations =
+        bitrate_allocation_strategy_->AllocateBitrates(bitrate, track_configs);
+    // The strategy should return allocation for all tracks.
+    RTC_CHECK(track_allocations.size() == bitrate_observer_configs_.size());
+    ObserverAllocation allocation;
+    auto track_allocations_it = track_allocations.begin();
+    for (const auto& observer_config : bitrate_observer_configs_) {
+      allocation[observer_config.observer] = *track_allocations_it++;
+    }
+    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