mediasoup 3.11.21 → 3.11.22

package/node/lib/Worker.js

@@ -90,7 +90,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.11.21',
+                MEDIASOUP_VERSION: '3.11.22',
                 // Let the worker process inherit all environment variables, useful
                 // if a custom and not in the path GCC is used so the user can set
                 // LD_LIBRARY_PATH environment variable for runtime.

package/node/lib/index.d.ts

@@ -10,7 +10,7 @@ export { types };
 /**
  * Expose mediasoup version.
  */
-export declare const version = "3.11.21";
+export declare const version = "3.11.22";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

@@ -11,7 +11,7 @@ exports.types = types;
 /**
  * Expose mediasoup version.
  */
-exports.version = '3.11.21';
+exports.version = '3.11.22';
 /**
  * Expose parseScalabilityMode() function.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.11.21",
+  "version": "3.11.22",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/alr_detector.cc

@@ -62,6 +62,11 @@ AlrDetector::AlrDetector(
           experiment_settings
               ? experiment_settings->alr_stop_budget_level_percent / 100.0
               : kDefaultStopBudgetLevelRatio),
+      alr_timeout_(
+          "alr_timeout",
+          experiment_settings
+              ? experiment_settings->alr_timeout
+              : kDefaultAlrTimeout),
       alr_budget_(0, true) {
   ParseFieldTrial({&bandwidth_usage_ratio_, &start_budget_level_ratio_,
                    &stop_budget_level_ratio_},
@@ -73,7 +78,7 @@ AlrDetector::~AlrDetector() {}
 void AlrDetector::OnBytesSent(size_t bytes_sent, int64_t send_time_ms) {
   if (!last_send_time_ms_.has_value()) {
     last_send_time_ms_ = send_time_ms;
-    // Since the duration for sending the bytes is unknwon, return without
+    // Since the duration for sending the bytes is unknown, return without
     // updating alr state.
     return;
   }
@@ -109,4 +114,18 @@ absl::optional<int64_t> AlrDetector::GetApplicationLimitedRegionStartTime()
   return alr_started_time_ms_;
 }
 
+absl::optional<int64_t> AlrDetector::GetApplicationLimitedRegionStartTime(
+    int64_t at_time_ms) {
+  if (!alr_started_time_ms_ && *last_send_time_ms_) {
+    int64_t delta_time_ms = at_time_ms - *last_send_time_ms_;
+    // If ALR is stopped and we haven't sent any packets for a while, force start.
+    if (delta_time_ms > alr_timeout_) {
+      MS_WARN_TAG(bwe, "large delta_time_ms: %ld, forcing alr state change",
+        delta_time_ms);
+      alr_started_time_ms_.emplace(at_time_ms);
+    }
+  }
+  return alr_started_time_ms_;
+}
+
 }  // namespace webrtc

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/alr_detector.h

@@ -43,6 +43,7 @@ class AlrDetector {
   // Returns time in milliseconds when the current application-limited region
   // started or empty result if the sender is currently not application-limited.
   absl::optional<int64_t> GetApplicationLimitedRegionStartTime() const;
+  absl::optional<int64_t> GetApplicationLimitedRegionStartTime(int64_t at_time_ms);
 
   void UpdateBudgetWithElapsedTime(int64_t delta_time_ms);
   void UpdateBudgetWithBytesSent(size_t bytes_sent);
@@ -56,6 +57,7 @@ class AlrDetector {
   static constexpr double kDefaultBandwidthUsageRatio = 0.65;
   static constexpr double kDefaultStartBudgetLevelRatio = 0.80;
   static constexpr double kDefaultStopBudgetLevelRatio = 0.50;
+  static constexpr int    kDefaultAlrTimeout = 3000;
 
   AlrDetector(const WebRtcKeyValueConfig* key_value_config,
               absl::optional<AlrExperimentSettings> experiment_settings);
@@ -64,6 +66,7 @@ class AlrDetector {
   FieldTrialParameter<double>  bandwidth_usage_ratio_;
   FieldTrialParameter<double>  start_budget_level_ratio_;
   FieldTrialParameter<double>  stop_budget_level_ratio_;
+  FieldTrialParameter<int>     alr_timeout_;
 
   absl::optional<int64_t> last_send_time_ms_;
 

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/delay_based_bwe.cc

@@ -61,7 +61,7 @@ DelayBasedBwe::DelayBasedBwe(const WebRtcKeyValueConfig* key_value_config,
       network_state_predictor_(network_state_predictor),
       inter_arrival_(),
       delay_detector_(
-          new TrendlineEstimator(key_value_config_, network_state_predictor_)),
+          new TrendlineEstimator(network_state_predictor_)),
       last_seen_packet_(Timestamp::MinusInfinity()),
       uma_recorded_(false),
       rate_control_(key_value_config, /*send_side=*/true),
@@ -127,7 +127,7 @@ void DelayBasedBwe::IncomingPacketFeedback(const PacketResult& packet_feedback,
         new InterArrival((kTimestampGroupLengthMs << kInterArrivalShift) / 1000,
                          kTimestampToMs, true));
     delay_detector_.reset(
-        new TrendlineEstimator(key_value_config_, network_state_predictor_));
+        new TrendlineEstimator(network_state_predictor_));
   }
   last_seen_packet_ = at_time;
 

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/goog_cc_network_control.cc

@@ -195,7 +195,7 @@ NetworkControlUpdate GoogCcNetworkController::OnProcessInterval(
   }
   bandwidth_estimation_->UpdateEstimate(msg.at_time);
   absl::optional<int64_t> start_time_ms =
-      alr_detector_->GetApplicationLimitedRegionStartTime();
+      alr_detector_->GetApplicationLimitedRegionStartTime(msg.at_time.ms());
   probe_controller_->SetAlrStartTimeMs(start_time_ms);
 
   auto probes = probe_controller_->Process(msg.at_time.ms());

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/trendline_estimator.cc

@@ -13,96 +13,92 @@
 
 #include "modules/congestion_controller/goog_cc/trendline_estimator.h"
 
-#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
-#include "rtc_base/numerics/safe_minmax.h"
-
-#include "Logger.hpp"
-
-#include <absl/types/optional.h>
 #include <math.h>
+
 #include <algorithm>
 #include <string>
 
+#include "absl/strings/match.h"
+#include "absl/types/optional.h"
+#include "api/network_state_predictor.h"
+#include "rtc_base/numerics/safe_minmax.h"
+#include "api/transport/webrtc_key_value_config.h"
+
+#include "Logger.hpp"
+
 namespace webrtc {
 
 namespace {
 
 // Parameters for linear least squares fit of regression line to noisy data.
-constexpr size_t kDefaultTrendlineWindowSize = 20;
-constexpr double kDefaultTrendlineSmoothingCoeff = 0.6;
+constexpr double kDefaultTrendlineSmoothingCoeff = 0.9;
 constexpr double kDefaultTrendlineThresholdGain = 4.0;
-const char kBweWindowSizeInPacketsExperiment[] =
-    "WebRTC-BweWindowSizeInPackets";
-
-size_t ReadTrendlineFilterWindowSize(
-    const WebRtcKeyValueConfig* key_value_config) {
-  std::string experiment_string =
-      key_value_config->Lookup(kBweWindowSizeInPacketsExperiment);
-  size_t window_size;
-  int parsed_values =
-      sscanf(experiment_string.c_str(), "Enabled-%zu", &window_size);
-  if (parsed_values == 1) {
-    if (window_size > 1)
-      return window_size;
-    MS_WARN_DEV("window size must be greater than 1");
-  }
-  MS_WARN_DEV(
-    "failed to parse parameters for BweWindowSizeInPackets"
-    " experiment from field trial string, using default");
-  return kDefaultTrendlineWindowSize;
-}
 
 absl::optional<double> LinearFitSlope(
-    const std::deque<std::pair<double, double>>& points) {
-  //RTC_DCHECK(points.size() >= 2);
+    const std::deque<TrendlineEstimator::PacketTiming>& packets) {
+  // RTC_DCHECK(packets.size() >= 2);
   // Compute the "center of mass".
   double sum_x = 0;
   double sum_y = 0;
-  for (const auto& point : points) {
-    sum_x += point.first;
-    sum_y += point.second;
+  for (const auto& packet : packets) {
+    sum_x += packet.arrival_time_ms;
+    sum_y += packet.smoothed_delay_ms;
   }
-  double x_avg = sum_x / points.size();
-  double y_avg = sum_y / points.size();
+  double x_avg = sum_x / packets.size();
+  double y_avg = sum_y / packets.size();
   // Compute the slope k = \sum (x_i-x_avg)(y_i-y_avg) / \sum (x_i-x_avg)^2
   double numerator = 0;
   double denominator = 0;
-  for (const auto& point : points) {
-    numerator += (point.first - x_avg) * (point.second - y_avg);
-    denominator += (point.first - x_avg) * (point.first - x_avg);
+  for (const auto& packet : packets) {
+    double x = packet.arrival_time_ms;
+    double y = packet.smoothed_delay_ms;
+    numerator += (x - x_avg) * (y - y_avg);
+    denominator += (x - x_avg) * (x - x_avg);
   }
   if (denominator == 0)
     return absl::nullopt;
   return numerator / denominator;
 }
 
+absl::optional<double> ComputeSlopeCap(
+    const std::deque<TrendlineEstimator::PacketTiming>& packets,
+    const TrendlineEstimatorSettings& settings) {
+  // RTC_DCHECK(1 <= settings.beginning_packets &&
+  //            settings.beginning_packets < packets.size());
+  // RTC_DCHECK(1 <= settings.end_packets &&
+  //            settings.end_packets < packets.size());
+  // RTC_DCHECK(settings.beginning_packets + settings.end_packets <=
+  //            packets.size());
+  TrendlineEstimator::PacketTiming early = packets[0];
+  for (size_t i = 1; i < settings.beginning_packets; ++i) {
+    if (packets[i].raw_delay_ms < early.raw_delay_ms)
+      early = packets[i];
+  }
+  size_t late_start = packets.size() - settings.end_packets;
+  TrendlineEstimator::PacketTiming late = packets[late_start];
+  for (size_t i = late_start + 1; i < packets.size(); ++i) {
+    if (packets[i].raw_delay_ms < late.raw_delay_ms)
+      late = packets[i];
+  }
+  if (late.arrival_time_ms - early.arrival_time_ms < 1) {
+    return absl::nullopt;
+  }
+  return (late.raw_delay_ms - early.raw_delay_ms) /
+             (late.arrival_time_ms - early.arrival_time_ms) +
+         settings.cap_uncertainty;
+}
+
 constexpr double kMaxAdaptOffsetMs = 15.0;
-constexpr double kOverUsingTimeThreshold = 30;
+constexpr double kOverUsingTimeThreshold = 10;
 constexpr int kMinNumDeltas = 60;
 constexpr int kDeltaCounterMax = 1000;
 
 }  // namespace
 
 TrendlineEstimator::TrendlineEstimator(
-    const WebRtcKeyValueConfig* key_value_config,
     NetworkStatePredictor* network_state_predictor)
-    : TrendlineEstimator(
-          key_value_config->Lookup(kBweWindowSizeInPacketsExperiment)
-                      .find("Enabled") == 0
-              ? ReadTrendlineFilterWindowSize(key_value_config)
-              : kDefaultTrendlineWindowSize,
-          kDefaultTrendlineSmoothingCoeff,
-          kDefaultTrendlineThresholdGain,
-          network_state_predictor) {}
-
-TrendlineEstimator::TrendlineEstimator(
-    size_t window_size,
-    double smoothing_coef,
-    double threshold_gain,
-    NetworkStatePredictor* network_state_predictor)
-    : window_size_(window_size),
-      smoothing_coef_(smoothing_coef),
-      threshold_gain_(threshold_gain),
+    : smoothing_coef_(kDefaultTrendlineSmoothingCoeff),
+      threshold_gain_(kDefaultTrendlineThresholdGain),
       num_of_deltas_(0),
       first_arrival_time_ms_(-1),
       accumulated_delay_(0),
@@ -120,63 +116,75 @@ TrendlineEstimator::TrendlineEstimator(
       hypothesis_(BandwidthUsage::kBwNormal),
       hypothesis_predicted_(BandwidthUsage::kBwNormal),
       network_state_predictor_(network_state_predictor) {
-  MS_DEBUG_DEV(
-    "using Trendline filter for delay change estimation with window size: %zu",
-    window_size_);
 }
 
 TrendlineEstimator::~TrendlineEstimator() {}
 
+void TrendlineEstimator::UpdateTrendline(double recv_delta_ms,
+                                         double send_delta_ms,
+                                         int64_t send_time_ms,
+                                         int64_t arrival_time_ms) {
+  const double delta_ms = recv_delta_ms - send_delta_ms;
+  ++num_of_deltas_;
+  num_of_deltas_ = std::min(num_of_deltas_, kDeltaCounterMax);
+  if (first_arrival_time_ms_ == -1)
+    first_arrival_time_ms_ = arrival_time_ms;
+
+  // Exponential backoff filter.
+  accumulated_delay_ += delta_ms;
+  // BWE_TEST_LOGGING_PLOT(1, "accumulated_delay_ms", arrival_time_ms,
+  //                       accumulated_delay_);
+  smoothed_delay_ = smoothing_coef_ * smoothed_delay_ +
+                    (1 - smoothing_coef_) * accumulated_delay_;
+  // BWE_TEST_LOGGING_PLOT(1, "smoothed_delay_ms", arrival_time_ms,
+  //                       smoothed_delay_);
+
+  // Maintain packet window
+  delay_hist_.emplace_back(
+      static_cast<double>(arrival_time_ms - first_arrival_time_ms_),
+      smoothed_delay_, accumulated_delay_);
+  if (settings_.enable_sort) {
+    for (size_t i = delay_hist_.size() - 1;
+         i > 0 &&
+         delay_hist_[i].arrival_time_ms < delay_hist_[i - 1].arrival_time_ms;
+         --i) {
+      std::swap(delay_hist_[i], delay_hist_[i - 1]);
+    }
+  }
+  if (delay_hist_.size() > settings_.window_size)
+    delay_hist_.pop_front();
+
+  // Simple linear regression.
+  double trend = prev_trend_;
+  if (delay_hist_.size() == settings_.window_size) {
+    // Update trend_ if it is possible to fit a line to the data. The delay
+    // trend can be seen as an estimate of (send_rate - capacity)/capacity.
+    // 0 < trend < 1   ->  the delay increases, queues are filling up
+    //   trend == 0    ->  the delay does not change
+    //   trend < 0     ->  the delay decreases, queues are being emptied
+    trend = LinearFitSlope(delay_hist_).value_or(trend);
+    if (settings_.enable_cap) {
+      absl::optional<double> cap = ComputeSlopeCap(delay_hist_, settings_);
+      // We only use the cap to filter out overuse detections, not
+      // to detect additional underuses.
+      if (trend >= 0 && cap.has_value() && trend > cap.value()) {
+        trend = cap.value();
+      }
+    }
+  }
+  // BWE_TEST_LOGGING_PLOT(1, "trendline_slope", arrival_time_ms, trend);
+
+  Detect(trend, send_delta_ms, arrival_time_ms);
+}
+
 void TrendlineEstimator::Update(double recv_delta_ms,
                                 double send_delta_ms,
                                 int64_t send_time_ms,
                                 int64_t arrival_time_ms,
                                 bool calculated_deltas) {
   if (calculated_deltas) {
-    const double delta_ms = recv_delta_ms - send_delta_ms;
-    ++num_of_deltas_;
-    num_of_deltas_ = std::min(num_of_deltas_, kDeltaCounterMax);
-    if (first_arrival_time_ms_ == -1)
-      first_arrival_time_ms_ = arrival_time_ms;
-
-    // Exponential backoff filter.
-    accumulated_delay_ += delta_ms;
-    // BWE_TEST_LOGGING_PLOT(1, "accumulated_delay_ms", arrival_time_ms,
-                          // accumulated_delay_);
-    // smoothed_delay_ = smoothing_coef_ * smoothed_delay_ +
-                      // (1 - smoothing_coef_) * accumulated_delay_;
-    // MS_NOTE: Apply WEMA to the current delta_ms. Don't consider the
-    // accumulated delay. Tests show it behaves more robustly upon delta peaks.
-    smoothed_delay_ = smoothing_coef_ * delta_ms +
-                      (1 - smoothing_coef_) * smoothed_delay_;
-    // BWE_TEST_LOGGING_PLOT(1, "smoothed_delay_ms", arrival_time_ms,
-                          // smoothed_delay_);
-
-    // Simple linear regression.
-    delay_hist_.push_back(std::make_pair(
-        static_cast<double>(arrival_time_ms - first_arrival_time_ms_),
-        smoothed_delay_));
-    if (delay_hist_.size() > window_size_)
-      delay_hist_.pop_front();
-    double trend = prev_trend_;
-    if (delay_hist_.size() == window_size_) {
-      // Update trend_ if it is possible to fit a line to the data. The delay
-      // trend can be seen as an estimate of (send_rate - capacity)/capacity.
-      // 0 < trend < 1   ->  the delay increases, queues are filling up
-      //   trend == 0    ->  the delay does not change
-      //   trend < 0     ->  the delay decreases, queues are being emptied
-      trend = LinearFitSlope(delay_hist_).value_or(trend);
-    }
-
-    // BWE_TEST_LOGGING_PLOT(1, "trendline_slope", arrival_time_ms, trend);
-
-    MS_DEBUG_DEV("trend:%f, send_delta_ms:%f, recv_delta_ms:%f, delta_ms:%f arrival_time_ms:%" PRIi64 ", accumulated_delay_:%f, smoothed_delay_:%f", trend, send_delta_ms, recv_delta_ms, delta_ms, arrival_time_ms, accumulated_delay_, smoothed_delay_);
-    Detect(trend, send_delta_ms, arrival_time_ms);
-  }
-  else {
-    MS_DEBUG_DEV("no calculated deltas");
+    UpdateTrendline(recv_delta_ms, send_delta_ms, send_time_ms, arrival_time_ms);
   }
-
   if (network_state_predictor_) {
     hypothesis_predicted_ = network_state_predictor_->Update(
         send_time_ms, arrival_time_ms, hypothesis_);
@@ -212,6 +220,7 @@ void TrendlineEstimator::Detect(double trend, double ts_delta, int64_t now_ms) {
       if (trend >= prev_trend_) {
         time_over_using_ = 0;
         overuse_counter_ = 0;
+        hypothesis_ = BandwidthUsage::kBwOverusing;
         MS_DEBUG_DEV("hypothesis_: BandwidthUsage::kBwOverusing");
 
 #if MS_LOG_DEV_LEVEL == 3
@@ -219,8 +228,6 @@ void TrendlineEstimator::Detect(double trend, double ts_delta, int64_t now_ms) {
           MS_DEBUG_DEV("arrival_time_ms - first_arrival_time_ms_:%f, smoothed_delay_:%f", kv.first, kv.second);
         }
 #endif
-
-        hypothesis_ = BandwidthUsage::kBwOverusing;
       }
     }
   } else if (modified_trend < -threshold_) {
@@ -231,8 +238,8 @@ void TrendlineEstimator::Detect(double trend, double ts_delta, int64_t now_ms) {
   } else {
     time_over_using_ = -1;
     overuse_counter_ = 0;
-    MS_DEBUG_DEV("---- BandwidthUsage::kBwNormal ---");
     hypothesis_ = BandwidthUsage::kBwNormal;
+    MS_DEBUG_DEV("---- BandwidthUsage::kBwNormal ---");
   }
   prev_trend_ = trend;
   UpdateThreshold(modified_trend, now_ms);

package/worker/deps/libwebrtc/libwebrtc/modules/congestion_controller/goog_cc/trendline_estimator.h

@@ -10,37 +10,48 @@
 #ifndef MODULES_CONGESTION_CONTROLLER_GOOG_CC_TRENDLINE_ESTIMATOR_H_
 #define MODULES_CONGESTION_CONTROLLER_GOOG_CC_TRENDLINE_ESTIMATOR_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include <deque>
+#include <memory>
+#include <utility>
+
 #include "api/network_state_predictor.h"
 #include "api/transport/webrtc_key_value_config.h"
 #include "modules/congestion_controller/goog_cc/delay_increase_detector_interface.h"
 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "rtc_base/constructor_magic.h"
 
-#include <stddef.h>
-#include <stdint.h>
-#include <deque>
-#include <utility>
-
 namespace webrtc {
 
+struct TrendlineEstimatorSettings {
+  static constexpr unsigned kDefaultTrendlineWindowSize = 20;
+
+  // Sort the packets in the window. Should be redundant,
+  // but then almost no cost.
+  bool enable_sort = false;
+
+  // Cap the trendline slope based on the minimum delay seen
+  // in the beginning_packets and end_packets respectively.
+  bool enable_cap = false;
+  unsigned beginning_packets = 7;
+  unsigned end_packets = 7;
+  double cap_uncertainty = 0.0;
+
+  // Size (in packets) of the window.
+  unsigned window_size = kDefaultTrendlineWindowSize;
+};
+
 class TrendlineEstimator : public DelayIncreaseDetectorInterface {
  public:
-  TrendlineEstimator(const WebRtcKeyValueConfig* key_value_config,
-                     NetworkStatePredictor* network_state_predictor);
-  // |window_size| is the number of points required to compute a trend line.
-  // |smoothing_coef| controls how much we smooth out the delay before fitting
-  // the trend line. |threshold_gain| is used to scale the trendline slope for
-  // comparison to the old threshold. Once the old estimator has been removed
-  // (or the thresholds been merged into the estimators), we can just set the
-  // threshold instead of setting a gain.|network_state_predictor| is used to
-  // bettter predict network state.
-  TrendlineEstimator(size_t window_size,
-                     double smoothing_coef,
-                     double threshold_gain,
-                     NetworkStatePredictor* network_state_predictor);
+  TrendlineEstimator(NetworkStatePredictor* network_state_predictor);
 
   ~TrendlineEstimator() override;
 
+  TrendlineEstimator(const TrendlineEstimator&) = delete;
+  TrendlineEstimator& operator=(const TrendlineEstimator&) = delete;
+
   // Update the estimator with a new sample. The deltas should represent deltas
   // between timestamp groups as defined by the InterArrival class.
   void Update(double recv_delta_ms,
@@ -49,21 +60,33 @@ class TrendlineEstimator : public DelayIncreaseDetectorInterface {
               int64_t arrival_time_ms,
               bool calculated_deltas) override;
 
+  void UpdateTrendline(double recv_delta_ms,
+                       double send_delta_ms,
+                       int64_t send_time_ms,
+                       int64_t arrival_time_ms);
+
   BandwidthUsage State() const override;
 
- protected:
-  // Used in unit tests.
-  double modified_trend() const { return prev_trend_ * threshold_gain_; }
+  struct PacketTiming {
+    PacketTiming(double arrival_time_ms,
+                 double smoothed_delay_ms,
+                 double raw_delay_ms)
+        : arrival_time_ms(arrival_time_ms),
+          smoothed_delay_ms(smoothed_delay_ms),
+          raw_delay_ms(raw_delay_ms) {}
+    double arrival_time_ms;
+    double smoothed_delay_ms;
+    double raw_delay_ms;
+  };
 
  private:
   friend class GoogCcStatePrinter;
-
   void Detect(double trend, double ts_delta, int64_t now_ms);
 
   void UpdateThreshold(double modified_offset, int64_t now_ms);
 
   // Parameters.
-  const size_t window_size_;
+  TrendlineEstimatorSettings settings_;
   const double smoothing_coef_;
   const double threshold_gain_;
   // Used by the existing threshold.
@@ -74,7 +97,7 @@ class TrendlineEstimator : public DelayIncreaseDetectorInterface {
   double accumulated_delay_;
   double smoothed_delay_;
   // Linear least squares regression.
-  std::deque<std::pair<double, double>> delay_hist_;
+  std::deque<PacketTiming> delay_hist_;
 
   const double k_up_;
   const double k_down_;
@@ -88,8 +111,6 @@ class TrendlineEstimator : public DelayIncreaseDetectorInterface {
   BandwidthUsage hypothesis_;
   BandwidthUsage hypothesis_predicted_;
   NetworkStatePredictor* network_state_predictor_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(TrendlineEstimator);
 };
 }  // namespace webrtc
 

package/worker/deps/libwebrtc/libwebrtc/rtc_base/experiments/alr_experiment.cc

@@ -26,7 +26,7 @@ const char AlrExperimentSettings::kScreenshareProbingBweExperimentName[] =
     "WebRTC-ProbingScreenshareBwe";
 const char AlrExperimentSettings::kStrictPacingAndProbingExperimentName[] =
     "WebRTC-StrictPacingAndProbing";
-const char kDefaultProbingScreenshareBweSettings[] = "1.0,2875,80,40,-60,3";
+const char kDefaultProbingScreenshareBweSettings[] = "1.0,2875,80,40,-60,3,3000";
 
 bool AlrExperimentSettings::MaxOneFieldTrialEnabled() {
   return AlrExperimentSettings::MaxOneFieldTrialEnabled(
@@ -71,12 +71,13 @@ AlrExperimentSettings::CreateFromFieldTrial(
   }
 
   AlrExperimentSettings settings;
-  if (sscanf(group_name.c_str(), "%f,%" PRId64 ",%d,%d,%d,%d",
+  if (sscanf(group_name.c_str(), "%f,%" PRId64 ",%d,%d,%d,%d,%d",
              &settings.pacing_factor, &settings.max_paced_queue_time,
              &settings.alr_bandwidth_usage_percent,
              &settings.alr_start_budget_level_percent,
              &settings.alr_stop_budget_level_percent,
-             &settings.group_id) == 6) {
+             &settings.group_id,
+             &settings.alr_timeout) == 7) {
     ret.emplace(settings);
     MS_DEBUG_TAG(bwe, "Using ALR experiment settings: "
                       "pacing factor: %f"
@@ -84,13 +85,15 @@ AlrExperimentSettings::CreateFromFieldTrial(
                      ", ALR bandwidth usage percent: %d"
                      ", ALR start budget level percent: %d"
                      ", ALR end budget level percent: %d"
-                     ", ALR experiment group ID: %d",
+                     ", ALR experiment group ID: %d"
+                     ", ALR timeout: %d",
                      settings.pacing_factor,
                      settings.max_paced_queue_time,
                      settings.alr_bandwidth_usage_percent,
                      settings.alr_start_budget_level_percent,
                      settings.alr_stop_budget_level_percent,
-                     settings.group_id);
+                     settings.group_id,
+                     settings.alr_timeout);
   } else {
     MS_DEBUG_TAG(bwe, "Failed to parse ALR experiment: %s", experiment_name);
   }

package/worker/deps/libwebrtc/libwebrtc/rtc_base/experiments/alr_experiment.h

@@ -24,6 +24,7 @@ struct AlrExperimentSettings {
   int alr_bandwidth_usage_percent;
   int alr_start_budget_level_percent;
   int alr_stop_budget_level_percent;
+  int alr_timeout;
   // Will be sent to the receive side for stats slicing.
   // Can be 0..6, because it's sent as a 3 bits value and there's also
   // reserved value to indicate absence of experiment.

package/worker/include/RTC/RtcLogger.hpp

@@ -0,0 +1,58 @@
+#ifndef MS_RTC_RTC_LOGGER_HPP
+#define MS_RTC_RTC_LOGGER_HPP
+
+#include "common.hpp"
+#include <absl/container/flat_hash_map.h>
+
+namespace RTC
+{
+	namespace RtcLogger
+	{
+		class RtpPacket
+		{
+		public:
+			enum class DropReason : uint8_t
+			{
+				NONE = 0,
+				PRODUCER_NOT_FOUND,
+				RECV_RTP_STREAM_NOT_FOUND,
+				RECV_RTP_STREAM_DISCARDED,
+				CONSUMER_INACTIVE,
+				INVALID_TARGET_LAYER,
+				UNSUPPORTED_PAYLOAD_TYPE,
+				NOT_A_KEYFRAME,
+				SPATIAL_LAYER_MISMATCH,
+				TOO_HIGH_TIMESTAMP_EXTRA_NEEDED,
+				PACKET_PREVIOUS_TO_SPATIAL_LAYER_SWITCH,
+				DROPPED_BY_CODEC,
+				SEND_RTP_STREAM_DISCARDED,
+			};
+
+			static absl::flat_hash_map<DropReason, std::string> dropReason2String;
+
+			RtpPacket()  = default;
+			~RtpPacket() = default;
+			void Sent();
+			void Dropped(DropReason dropReason);
+
+		private:
+			void Log() const;
+			void Clear();
+
+		public:
+			uint64_t timestamp;
+			std::string recvTransportId{};
+			std::string sendTransportId{};
+			std::string routerId{};
+			std::string producerId{};
+			std::string consumerId{};
+			uint32_t recvRtpTimestamp;
+			uint32_t sendRtpTimestamp;
+			uint16_t recvSeqNumber;
+			uint16_t sendSeqNumber;
+			bool dropped;
+			DropReason dropReason{ DropReason::NONE };
+		};
+	}; // namespace RtcLogger
+} // namespace RTC
+#endif