Pass time constant to bwe smoothing filter.

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 47 matching lines @@
   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,
-                                        int64_t rtt) {
+                                        int64_t rtt,
+                                        int probing_interval_ms) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   last_bitrate_bps_ = target_bitrate_bps;
   last_non_zero_bitrate_bps_ =
       target_bitrate_bps > 0 ? target_bitrate_bps : last_non_zero_bitrate_bps_;
   last_fraction_loss_ = fraction_loss;
   last_rtt_ = rtt;
+  last_probing_interval_ms_ = probing_interval_ms;
 
   // Periodically log the incoming BWE.
   int64_t now = clock_->TimeInMilliseconds();
   if (now > last_bwe_log_time_ + kBweLogIntervalMs) {
     LOG(LS_INFO) << "Current BWE " << target_bitrate_bps;
     last_bwe_log_time_ = now;
   }
 
   ObserverAllocation allocation = AllocateBitrates(target_bitrate_bps);
 
   for (auto& config : bitrate_observer_configs_) {
     uint32_t allocated_bitrate = allocation[config.observer];
     uint32_t protection_bitrate = config.observer->OnBitrateUpdated(
-        allocated_bitrate, last_fraction_loss_, last_rtt_);
+        allocated_bitrate, last_fraction_loss_, last_rtt_,
+        last_probing_interval_ms_);
 
     if (allocated_bitrate == 0 && config.allocated_bitrate_bps > 0) {
       if (target_bitrate_bps > 0)
         ++num_pause_events_;
       // The protection bitrate is an estimate based on the ratio between media
       // and protection used before this observer was muted.
       uint32_t predicted_protection_bps =
           (1.0 - config.media_ratio) * config.min_bitrate_bps;
       LOG(LS_INFO) << "Pausing observer " << config.observer
                    << " with configured min bitrate " << config.min_bitrate_bps
@@ skipping 35 matching lines @@
                        pad_up_bitrate_bps, enforce_min_bitrate));
   }
 
   ObserverAllocation allocation;
   if (last_bitrate_bps_ > 0) {
     // Calculate a new allocation and update all observers.
     allocation = AllocateBitrates(last_bitrate_bps_);
     for (auto& config : bitrate_observer_configs_) {
       uint32_t allocated_bitrate = allocation[config.observer];
       uint32_t protection_bitrate = config.observer->OnBitrateUpdated(
-          allocated_bitrate, last_fraction_loss_, last_rtt_);
+          allocated_bitrate, last_fraction_loss_, last_rtt_,
+          last_probing_interval_ms_);
       config.allocated_bitrate_bps = allocated_bitrate;
       if (allocated_bitrate > 0)
         config.media_ratio = MediaRatio(allocated_bitrate, protection_bitrate);
     }
   } 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_);
+    observer->OnBitrateUpdated(0, last_fraction_loss_, last_rtt_,
+                               last_probing_interval_ms_);
   }
   UpdateAllocationLimits();
 }
 
 void BitrateAllocator::UpdateAllocationLimits() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
   uint32_t total_requested_padding_bitrate = 0;
   uint32_t total_requested_min_bitrate = 0;
 
   for (const auto& config : bitrate_observer_configs_) {
@@ skipping 245 matching lines @@
       (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