Backport changes to congestion control from libwebrtc

node/src/Worker.ts

@@ -70,7 +70,7 @@ export type WorkerSettings =
 	 *
 	 * NOTE: For advanced users only. An invalid value will make the worker crash.
 	 * Default value is
-	 * "WebRTC-Bwe-AlrLimitedBackoff/Enabled/".
+	 * "WebRTC-Bwe-AlrLimitedBackoff/Enabled/WebRTC-Bwe-LossBasedBweV2/Enabled:true,CandidateFactors:1.02|1.0|0.95,DelayBasedCandidate:true,HigherBwBiasFactor:0.0002,HigherLogBwBiasFactor:0.02,ObservationDurationLowerBound:250ms,InstantUpperBoundBwBalance:75kbps,BwRampupUpperBoundFactor:1000000.0,InstantUpperBoundTemporalWeightFactor:0.9,TemporalWeightFactor:0.9,MaxIncreaseFactor:1.3,NewtonStepSize:0.75,InherentLossUpperBoundBwBalance:75kbps,LossThresholdOfHighBandwidthPreference:0.15,NotIncreaseIfInherentLossLessThanAverageLoss:true,TrendlineIntegrationEnabled:true,SendingRateSmoothingFactor:0.6/".
 	 */
 	libwebrtcFieldTrials?: string;
 

rust/src/worker.rs

@@ -186,7 +186,7 @@ pub struct WorkerSettings {
     ///
     /// NOTE: For advanced users only. An invalid value will make the worker crash.
     /// Default value is
-    /// "WebRTC-Bwe-AlrLimitedBackoff/Enabled/".
+    /// "WebRTC-Bwe-AlrLimitedBackoff/Enabled/WebRTC-Bwe-LossBasedBweV2/Enabled:true,CandidateFactors:1.02|1.0|0.95,DelayBasedCandidate:true,HigherBwBiasFactor:0.0002,HigherLogBwBiasFactor:0.02,ObservationDurationLowerBound:250ms,InstantUpperBoundBwBalance:75kbps,BwRampupUpperBoundFactor:1000000.0,InstantUpperBoundTemporalWeightFactor:0.9,TemporalWeightFactor:0.9,MaxIncreaseFactor:1.3,NewtonStepSize:0.75,InherentLossUpperBoundBwBalance:75kbps,LossThresholdOfHighBandwidthPreference:0.15,NotIncreaseIfInherentLossLessThanAverageLoss:true,TrendlineIntegrationEnabled:true,SendingRateSmoothingFactor:0.6/".
     #[doc(hidden)]
     pub libwebrtc_field_trials: Option<String>,
     /// Function that will be called under worker thread before worker starts, can be used for

worker/deps/libwebrtc/libwebrtc/api/transport/network_control.h

@@ -72,7 +72,11 @@ class NetworkControllerInterface {
   // Called round trip time has been calculated by protocol specific mechanisms.
   virtual NetworkControlUpdate OnRoundTripTimeUpdate(RoundTripTimeUpdate) = 0;
   // Called when a packet is sent on the network.
-  virtual NetworkControlUpdate OnSentPacket(SentPacket) = 0;
+  virtual NetworkControlUpdate OnSentPacket(
+      SentPacket) = 0;
+  // Called when a packet is received from the remote client.
+  virtual NetworkControlUpdate OnReceivedPacket(
+      ReceivedPacket) = 0;
   // Called when the stream specific configuration has been updated.
   virtual NetworkControlUpdate OnStreamsConfig(StreamsConfig) = 0;
   // Called when target transfer rate constraints has been changed.
@@ -108,7 +112,11 @@ class NetworkStateEstimator {
   // Gets the current best estimate according to the estimator.
   virtual absl::optional<NetworkStateEstimate> GetCurrentEstimate() = 0;
   // Called with per packet feedback regarding receive time.
+  // Used when the NetworkStateEstimator runs in the sending endpoint.
   virtual void OnTransportPacketsFeedback(const TransportPacketsFeedback&) = 0;
+  // Called with per packet feedback regarding receive time.
+  // Used when the NetworkStateEstimator runs in the receiving endpoint.
+  virtual void OnReceivedPacket(const PacketResult&) {}
   // Called when the receiving or sending endpoint changes address.
   virtual void OnRouteChange(const NetworkRouteChange&) = 0;
   virtual ~NetworkStateEstimator() = default;

worker/deps/libwebrtc/libwebrtc/api/transport/network_types.cc

@@ -13,8 +13,7 @@
 #include <algorithm>
 
 namespace webrtc {
-// TODO(srte): Revert to using default after removing union member.
-StreamsConfig::StreamsConfig() {}
+StreamsConfig::StreamsConfig() = default;
 StreamsConfig::StreamsConfig(const StreamsConfig&) = default;
 StreamsConfig::~StreamsConfig() = default;
 
@@ -49,7 +48,7 @@ std::vector<PacketResult> TransportPacketsFeedback::ReceivedWithSendInfo()
     const {
   std::vector<PacketResult> res;
   for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.receive_time.IsFinite()) {
+    if (fb.IsReceived()) {
       res.push_back(fb);
     }
   }
@@ -59,7 +58,7 @@ std::vector<PacketResult> TransportPacketsFeedback::ReceivedWithSendInfo()
 std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
   std::vector<PacketResult> res;
   for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.receive_time.IsPlusInfinity()) {
+    if (!fb.IsReceived()) {
       res.push_back(fb);
     }
   }
@@ -75,7 +74,7 @@ std::vector<PacketResult> TransportPacketsFeedback::SortedByReceiveTime()
     const {
   std::vector<PacketResult> res;
   for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.receive_time.IsFinite()) {
+    if (fb.IsReceived()) {
       res.push_back(fb);
     }
   }

worker/deps/libwebrtc/libwebrtc/api/transport/network_types.h

@@ -24,6 +24,19 @@ namespace webrtc {
 
 // Configuration
 
+// Represents constraints and rates related to the currently enabled streams.
+// This is used as input to the congestion controller via the StreamsConfig
+// struct.
+struct BitrateAllocationLimits {
+  // The total minimum send bitrate required by all sending streams.
+  DataRate min_allocatable_rate = DataRate::Zero();
+  // The total maximum allocatable bitrate for all currently available streams.
+  DataRate max_allocatable_rate = DataRate::Zero();
+  // The max bitrate to use for padding. The sum of the per-stream max padding
+  // rate.
+  DataRate max_padding_rate = DataRate::Zero();
+};
+
 // Use StreamsConfig for information about streams that is required for specific
 // adjustments to the algorithms in network controllers. Especially useful
 // for experiments.
@@ -34,9 +47,9 @@ struct StreamsConfig {
   Timestamp at_time = Timestamp::PlusInfinity();
   absl::optional<bool> requests_alr_probing;
   absl::optional<double> pacing_factor;
-  union {
-    absl::optional<DataRate> min_total_allocated_bitrate = absl::nullopt;
-  };
+
+  // TODO: (srte) Use BitrateAllocationLimits here.
+  absl::optional<DataRate> min_total_allocated_bitrate;
   absl::optional<DataRate> max_padding_rate;
   absl::optional<DataRate> max_total_allocated_bitrate;
 };
@@ -84,13 +97,20 @@ struct PacedPacketInfo {
   int probe_cluster_id = kNotAProbe;
   int probe_cluster_min_probes = -1;
   int probe_cluster_min_bytes = -1;
+  int probe_cluster_bytes_sent = 0;
 };
 
 struct SentPacket {
   Timestamp send_time = Timestamp::PlusInfinity();
+  // Size of packet with overhead up to IP layer.
   DataSize size = DataSize::Zero();
+  // Size of preceeding packets that are not part of feedback.
   DataSize prior_unacked_data = DataSize::Zero();
+  // Probe cluster id and parameters including bitrate, number of packets and
+  // number of bytes.
   PacedPacketInfo pacing_info;
+  // True if the packet is an audio packet, false for video, padding, RTX etc.
+  bool audio = false;
   // Transport independent sequence number, any tracked packet should have a
   // sequence number that is unique over the whole call and increasing by 1 for
   // each packet.
@@ -138,6 +158,8 @@ struct PacketResult {
   PacketResult(const PacketResult&);
   ~PacketResult();
 
+  inline bool IsReceived() const { return !receive_time.IsPlusInfinity(); }
+
   SentPacket sent_packet;
   Timestamp receive_time = Timestamp::PlusInfinity();
 };
@@ -166,6 +188,7 @@ struct TransportPacketsFeedback {
 
 struct NetworkEstimate {
   Timestamp at_time = Timestamp::PlusInfinity();
+  // Deprecated, use TargetTransferRate::target_rate instead.
   DataRate bandwidth = DataRate::Infinity();
   TimeDelta round_trip_time = TimeDelta::PlusInfinity();
   TimeDelta bwe_period = TimeDelta::PlusInfinity();
@@ -199,6 +222,8 @@ struct TargetTransferRate {
   // The estimate on which the target rate is based on.
   NetworkEstimate network_estimate;
   DataRate target_rate = DataRate::Zero();
+  DataRate stable_target_rate = DataRate::Zero();
+  double cwnd_reduce_ratio = 0;
 };
 
 // Contains updates of network controller comand state. Using optionals to

worker/deps/libwebrtc/libwebrtc/modules/bitrate_controller/loss_based_bandwidth_estimation.cc

@@ -8,10 +8,11 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "absl/strings/match.h"
 #include "modules/bitrate_controller/loss_based_bandwidth_estimation.h"
+#include "api/transport/webrtc_key_value_config.h"
 #include "api/units/data_rate.h"
 #include "api/units/time_delta.h"
-#include "system_wrappers/source/field_trial.h"
 
 #include <algorithm>
 #include <string>
@@ -21,6 +22,10 @@ namespace webrtc {
 namespace {
 const char kBweLossBasedControl[] = "WebRTC-Bwe-LossBasedControl";
 
+// Expecting RTCP feedback to be sent with roughly 1s intervals, a 5s gap
+// indicates a channel outage.
+constexpr TimeDelta kMaxRtcpFeedbackInterval = TimeDelta::Millis<5000>();
+
 // Increase slower when RTT is high.
 double GetIncreaseFactor(const LossBasedControlConfig& config, TimeDelta rtt) {
   // Clamp the RTT
@@ -70,10 +75,16 @@ double ExponentialUpdate(TimeDelta window, TimeDelta interval) {
   return 1.0f - exp(interval / window * -1.0);
 }
 
+bool IsEnabled(const WebRtcKeyValueConfig* key_value_config,
+               absl::string_view name) {
+  return key_value_config->Lookup(name).find("Enabled") == 0;
+}
+
 }  // namespace
 
-LossBasedControlConfig::LossBasedControlConfig()
-    : enabled(field_trial::IsEnabled(kBweLossBasedControl)),
+LossBasedControlConfig::LossBasedControlConfig(
+    const WebRtcKeyValueConfig* key_value_config)
+    : enabled(IsEnabled(key_value_config, kBweLossBasedControl)),
       min_increase_factor("min_incr", 1.02),
       max_increase_factor("max_incr", 1.08),
       increase_low_rtt("incr_low_rtt", TimeDelta::ms(200)),
@@ -85,26 +96,27 @@ LossBasedControlConfig::LossBasedControlConfig()
       increase_offset("incr_offset", DataRate::bps(1000)),
       loss_bandwidth_balance_increase("balance_incr", DataRate::kbps(0.5)),
       loss_bandwidth_balance_decrease("balance_decr", DataRate::kbps(4)),
+	    loss_bandwidth_balance_reset("balance_reset", DataRate::kbps(0.1)),
       loss_bandwidth_balance_exponent("exponent", 0.5),
       allow_resets("resets", false),
       decrease_interval("decr_intvl", TimeDelta::ms(300)),
       loss_report_timeout("timeout", TimeDelta::ms(6000)) {
-  std::string trial_string = field_trial::FindFullName(kBweLossBasedControl);
   ParseFieldTrial(
       {&min_increase_factor, &max_increase_factor, &increase_low_rtt,
        &increase_high_rtt, &decrease_factor, &loss_window, &loss_max_window,
        &acknowledged_rate_max_window, &increase_offset,
        &loss_bandwidth_balance_increase, &loss_bandwidth_balance_decrease,
-       &loss_bandwidth_balance_exponent, &allow_resets, &decrease_interval,
-       &loss_report_timeout},
-      trial_string);
+       &loss_bandwidth_balance_reset, &loss_bandwidth_balance_exponent,
+       &allow_resets, &decrease_interval, &loss_report_timeout},
+      key_value_config->Lookup(kBweLossBasedControl));
 }
 LossBasedControlConfig::LossBasedControlConfig(const LossBasedControlConfig&) =
     default;
 LossBasedControlConfig::~LossBasedControlConfig() = default;
 
-LossBasedBandwidthEstimation::LossBasedBandwidthEstimation()
-    : config_(LossBasedControlConfig()),
+LossBasedBandwidthEstimation::LossBasedBandwidthEstimation(
+    const WebRtcKeyValueConfig* key_value_config)
+    : config_(key_value_config),
       average_loss_(0),
       average_loss_max_(0),
       loss_based_bitrate_(DataRate::Zero()),
@@ -161,9 +173,14 @@ void LossBasedBandwidthEstimation::UpdateAcknowledgedBitrate(
   }
 }
 
-void LossBasedBandwidthEstimation::Update(Timestamp at_time,
-                                          DataRate min_bitrate,
-                                          TimeDelta last_round_trip_time) {
+DataRate LossBasedBandwidthEstimation::Update(Timestamp at_time,
+                                              DataRate min_bitrate,
+                                              DataRate wanted_bitrate,
+                                              TimeDelta last_round_trip_time) {
+  if (loss_based_bitrate_.IsZero()) {
+    loss_based_bitrate_ = wanted_bitrate;
+  }
+
   // Only increase if loss has been low for some time.
   const double loss_estimate_for_increase = average_loss_max_;
   // Avoid multiple decreases from averaging over one loss spike.
@@ -173,8 +190,15 @@ void LossBasedBandwidthEstimation::Update(Timestamp at_time,
       !has_decreased_since_last_loss_report_ &&
       (at_time - time_last_decrease_ >=
        last_round_trip_time + config_.decrease_interval);
+  // If packet lost reports are too old, dont increase bitrate.
+  const bool loss_report_valid =
+      at_time - last_loss_packet_report_ < 1.2 * kMaxRtcpFeedbackInterval;
 
-  if (loss_estimate_for_increase < loss_increase_threshold()) {
+  if (loss_report_valid && config_.allow_resets &&
+      loss_estimate_for_increase < loss_reset_threshold()) {
+    loss_based_bitrate_ = wanted_bitrate;
+  } else if (loss_report_valid &&
+             loss_estimate_for_increase < loss_increase_threshold()) {
     // Increase bitrate by RTT-adaptive ratio.
     DataRate new_increased_bitrate =
         min_bitrate * GetIncreaseFactor(config_, last_round_trip_time) +
@@ -200,14 +224,21 @@ void LossBasedBandwidthEstimation::Update(Timestamp at_time,
       loss_based_bitrate_ = new_decreased_bitrate;
     }
   }
+  return loss_based_bitrate_;
 }
 
-void LossBasedBandwidthEstimation::Reset(DataRate bitrate) {
+void LossBasedBandwidthEstimation::Initialize(DataRate bitrate) {
   loss_based_bitrate_ = bitrate;
   average_loss_ = 0;
   average_loss_max_ = 0;
 }
 
+double LossBasedBandwidthEstimation::loss_reset_threshold() const {
+  return LossFromBitrate(loss_based_bitrate_,
+                         config_.loss_bandwidth_balance_reset,
+                         config_.loss_bandwidth_balance_exponent);
+}
+
 double LossBasedBandwidthEstimation::loss_increase_threshold() const {
   return LossFromBitrate(loss_based_bitrate_,
                          config_.loss_bandwidth_balance_increase,
@@ -223,14 +254,4 @@ double LossBasedBandwidthEstimation::loss_decrease_threshold() const {
 DataRate LossBasedBandwidthEstimation::decreased_bitrate() const {
   return config_.decrease_factor * acknowledged_bitrate_max_;
 }
-
-void LossBasedBandwidthEstimation::MaybeReset(DataRate bitrate) {
-  if (config_.allow_resets)
-    Reset(bitrate);
-}
-
-void LossBasedBandwidthEstimation::SetInitialBitrate(DataRate bitrate) {
-  Reset(bitrate);
-}
-
 }  // namespace webrtc

worker/deps/libwebrtc/libwebrtc/modules/bitrate_controller/loss_based_bandwidth_estimation.h

@@ -16,13 +16,15 @@
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
 #include "rtc_base/experiments/field_trial_parser.h"
+#include "api/transport/webrtc_key_value_config.h"
+
 
 #include <vector>
 
 namespace webrtc {
 
 struct LossBasedControlConfig {
-  LossBasedControlConfig();
+  explicit LossBasedControlConfig(const WebRtcKeyValueConfig* key_value_config);
   LossBasedControlConfig(const LossBasedControlConfig&);
   LossBasedControlConfig& operator=(const LossBasedControlConfig&) = default;
   ~LossBasedControlConfig();
@@ -38,23 +40,34 @@ struct LossBasedControlConfig {
   FieldTrialParameter<DataRate> increase_offset;
   FieldTrialParameter<DataRate> loss_bandwidth_balance_increase;
   FieldTrialParameter<DataRate> loss_bandwidth_balance_decrease;
+  FieldTrialParameter<DataRate> loss_bandwidth_balance_reset;
   FieldTrialParameter<double> loss_bandwidth_balance_exponent;
   FieldTrialParameter<bool> allow_resets;
   FieldTrialParameter<TimeDelta> decrease_interval;
   FieldTrialParameter<TimeDelta> loss_report_timeout;
 };
 
+// Estimates an upper BWE limit based on loss.
+// It requires knowledge about lost packets and acknowledged bitrate.
+// Ie, this class require transport feedback.
 class LossBasedBandwidthEstimation {
  public:
-  LossBasedBandwidthEstimation();
-  void Update(Timestamp at_time,
-              DataRate min_bitrate,
-              TimeDelta last_round_trip_time);
+  explicit LossBasedBandwidthEstimation(
+      const WebRtcKeyValueConfig* key_value_config);
+  // Returns the new estimate.
+  DataRate Update(Timestamp at_time,
+                  DataRate min_bitrate,
+                  DataRate wanted_bitrate,
+                  TimeDelta last_round_trip_time);
   void UpdateAcknowledgedBitrate(DataRate acknowledged_bitrate,
                                  Timestamp at_time);
-  void MaybeReset(DataRate bitrate);
-  void SetInitialBitrate(DataRate bitrate);
+  void Initialize(DataRate bitrate);
   bool Enabled() const { return config_.enabled; }
+  // Returns true if LossBasedBandwidthEstimation is enabled and have
+  // received loss statistics. Ie, this class require transport feedback.
+  bool InUse() const {
+    return Enabled() && last_loss_packet_report_.IsFinite();
+  }
   void UpdateLossStatistics(const std::vector<PacketResult>& packet_results,
                             Timestamp at_time);
   DataRate GetEstimate() const { return loss_based_bitrate_; }
@@ -64,9 +77,11 @@ class LossBasedBandwidthEstimation {
   void Reset(DataRate bitrate);
   double loss_increase_threshold() const;
   double loss_decrease_threshold() const;
+  double loss_reset_threshold() const;
+
   DataRate decreased_bitrate() const;
 
-  LossBasedControlConfig config_;
+  const LossBasedControlConfig config_;
   double average_loss_;
   double average_loss_max_;
   DataRate loss_based_bitrate_;