mediasoup 3.27.1 → 3.28.0

package/worker/include/RTC/WebRtcTransport.hpp

@@ -1,6 +1,7 @@
 #ifndef MS_RTC_WEBRTC_TRANSPORT_HPP
 #define MS_RTC_WEBRTC_TRANSPORT_HPP
 
+#include "handles/SendCallbacks.hpp"
 #include "RTC/DtlsTransport.hpp"
 #include "RTC/ICE/IceCandidate.hpp"
 #include "RTC/ICE/IceServer.hpp"
@@ -82,17 +83,15 @@ namespace RTC
 
 	private:
 		bool IsConnected() const override;
+		size_t GetPacketOverhead() const override;
 		void MayRunDtlsTransport();
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/Shared.hpp

@@ -41,6 +41,11 @@ public:
 		return DepLibUV::GetTimeUs();
 	}
 
+	uint64_t GetLoopTimeMs() override
+	{
+		return DepLibUV::GetLoopTimeMs();
+	}
+
 	int64_t GetNtpOffsetUs() override
 	{
 		return DepLibUV::GetNtpOffsetUs();

package/worker/include/SharedInterface.hpp

@@ -51,6 +51,16 @@ public:
 	 */
 	virtual int64_t GetTimeUs() = 0;
 
+	/**
+	 * Get the time at which the current iteration of the event loop began (ms).
+	 *
+	 * @remarks
+	 * - It stays the same throughout an iteration no matter how long it takes, so it is
+	 *   what tells two iterations apart. The clocks above cannot, since they move while
+	 *   the iteration runs.
+	 */
+	virtual uint64_t GetLoopTimeMs() = 0;
+
 	/**
 	 * Distance from the clock above to the NTP epoch (us), which is what has to be added
 	 * to it to obtain the NTP timestamps of the RTCP we generate.

package/worker/include/Utils.hpp

@@ -515,10 +515,40 @@ namespace Utils
 			uint32_t fractions;
 		};
 
+		/**
+		 * Convert microseconds into milliseconds.
+		 *
+		 * @remarks
+		 * - The result is rounded to the nearest millisecond, halves upwards.
+		 */
+		static int64_t TimeUsToMs(int64_t timeUs)
+		{
+			// NOTE: The remainder decides the rounding instead of adding half the
+			// divisor first, which would overflow for a time close to the maximum.
+			// Integer division truncates towards zero, so a negative remainder is
+			// walked down to the next whole millisecond for halves to go upwards
+			// there too.
+			const int64_t quotient  = timeUs / 1000;
+			const int64_t remainder = timeUs % 1000;
+
+			if (remainder >= 500)
+			{
+				return quotient + 1;
+			}
+			else if (remainder < -500)
+			{
+				return quotient - 1;
+			}
+			else
+			{
+				return quotient;
+			}
+		}
+
 		/**
 		 * Convert microseconds into an NTP timestamp.
 		 */
-		static Time::Ntp TimeUs2Ntp(int64_t timeUs)
+		static Time::Ntp TimeUsToNtp(int64_t timeUs)
 		{
 			Time::Ntp ntp{}; // NOLINT(cppcoreguidelines-pro-type-member-init)
 
@@ -536,7 +566,7 @@ namespace Utils
 		/**
 		 * Convert an NTP timestamp into microseconds.
 		 */
-		static int64_t Ntp2TimeUs(Time::Ntp ntp)
+		static int64_t NtpToTimeUs(Time::Ntp ntp)
 		{
 			return (
 			  (static_cast<int64_t>(ntp.seconds) * 1000000) +
@@ -544,6 +574,45 @@ namespace Utils
 			    std::round((static_cast<double>(ntp.fractions) * 1000000) / NtpFractionalUnit)));
 		}
 
+		/**
+		 * Convert an interval in compact NTP representation (the middle 32 bits of an
+		 * NTP timestamp, so 1/65536 seconds units) into microseconds.
+		 *
+		 * @remarks
+		 * - The interval is usually the difference between two compact NTP timestamps,
+		 *   which wraps around every 65536 seconds. Values above 0x80000000 are hence
+		 *   taken as negative intervals rather than as intervals of more than 32768
+		 *   seconds.
+		 * - The result is rounded to the nearest microsecond, halves upwards.
+		 */
+		static int64_t CompactNtpIntervalToTimeUs(uint32_t compactNtpInterval)
+		{
+			auto value = static_cast<int64_t>(compactNtpInterval);
+
+			if (compactNtpInterval > 0x80000000)
+			{
+				value -= (int64_t{ 1 } << 32);
+			}
+
+			// NOTE: Right shifting a negative value rounds towards negative infinity,
+			// so adding half the divisor first rounds to the nearest value.
+			return ((value * 1000000) + (1 << 15)) >> 16;
+		}
+
+		/**
+		 * Convert a round trip time in compact NTP representation into microseconds.
+		 *
+		 * @remarks
+		 * - A non-monotonic clock can make the round trip time negative, so a negative
+		 *   value, as well as one too small to be true, yields 1 millisecond.
+		 */
+		static int64_t CompactNtpRttToTimeUs(uint32_t compactNtpRtt)
+		{
+			static constexpr int64_t MinRttUs{ 1000 };
+
+			return std::max(CompactNtpIntervalToTimeUs(compactNtpRtt), MinRttUs);
+		}
+
 		/**
 		 * Convert microseconds into the 6.18 fixed point seconds of the
 		 * `abs-send-time` RTP header extension, whose resolution is hence 1/262144
@@ -572,7 +641,7 @@ namespace Utils
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/draft-ietf-avtcore-abs-capture-time-00
 		 */
-		static std::optional<int64_t> TimeUs2Q32x32(int64_t timeUs)
+		static std::optional<int64_t> TimeUsToQ32x32(int64_t timeUs)
 		{
 			// The seconds of the format are 32 bits wide, so from here on it does not fit.
 			static constexpr int64_t OutOfRangeUs{ (1LL << 31) * 1000000 };

package/worker/include/common.hpp

@@ -29,14 +29,22 @@ typedef SSIZE_T ssize_t;
 #endif
 // IWYU pragma: end_exports
 
-// This is a macro to silence false warnings in GCC in switch() blocks with FBS
-// types.
+// This is a macro to silence false warnings in switch() blocks that already
+// cover every value of their enum and hence need no default label.
+//
+// GCC warns that the enum is not fully handled (typically with FBS types) and
+// MSVC warns that the function may fall off its end without returning a value,
+// so each of them is told that reaching the default label is impossible.
 #if defined(__GNUC__) && !defined(__clang__)
-#define NO_DEFAULT_GCC()                                                                           \
+#define NO_DEFAULT()                                                                               \
 	default:                                                                                         \
 		__builtin_unreachable()
+#elif defined(_MSC_VER)
+#define NO_DEFAULT()                                                                               \
+	default:                                                                                         \
+		__assume(0)
 #else
-#define NO_DEFAULT_GCC()
+#define NO_DEFAULT()
 #endif
 
 using ChannelReadCtx    = void*;

package/worker/include/handles/SendCallbacks.hpp

@@ -0,0 +1,34 @@
+#ifndef MS_SEND_CALLBACKS_HPP
+#define MS_SEND_CALLBACKS_HPP
+
+#include "common.hpp"
+
+// NOTE: Nothing ever copies one of these, so what they want to be is move only
+// callables. `std::function` is used instead because we are on C++20, and it
+// additionally demands that the callable be copyable, so a lambda capturing
+// anything move only is rejected.
+//
+// TODO: Once we upgrade to C++23, replace both with `std::move_only_function`.
+// Its signature must carry a trailing `const` so that its `operator()` is const
+// and the paths that hold one by const reference keep compiling:
+// using onSendCallback = std::move_only_function<void(bool sent) const>;
+// using onMessageQueuedCallback =
+//   std::move_only_function<void(bool queued, bool isSendBufferFull) const>;
+
+/**
+ * Told whether a packet handed over for sending actually left the socket.
+ *
+ * It travels by value down the send path and is moved at every step, so it
+ * cannot be leaked nor released twice, and any failure path can answer `false`
+ * by just invoking it. An empty one means that nobody wants to know, which is
+ * the common case, so every send path must tolerate it.
+ */
+using onSendCallback = std::function<void(bool sent)>;
+
+/**
+ * Told whether a message (such as SCTP message) was queued for sending, and
+ * whether it was the send buffer being full what kept it from being queued.
+ */
+using onMessageQueuedCallback = std::function<void(bool queued, bool isSendBufferFull)>;
+
+#endif

package/worker/include/handles/TcpConnectionHandle.hpp

@@ -2,14 +2,12 @@
 #define MS_TCP_CONNECTION_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/SendCallbacks.hpp"
 #include <uv.h>
 #include <string>
 
 class TcpConnectionHandle
 {
-protected:
-	using onSendCallback = const std::function<void(bool sent)>;
-
 public:
 	class Listener
 	{
@@ -34,12 +32,11 @@ public:
 		~UvWriteData()
 		{
 			delete[] this->store;
-			delete this->cb;
 		}
 
 		uv_write_t req{};
 		uint8_t* store{ nullptr };
-		TcpConnectionHandle::onSendCallback* cb{ nullptr };
+		onSendCallback cb;
 	};
 
 public:
@@ -65,12 +62,7 @@ public:
 		return this->uvHandle;
 	}
 	bool Start() noexcept;
-	void Write(
-	  const uint8_t* data1,
-	  size_t len1,
-	  const uint8_t* data2,
-	  size_t len2,
-	  TcpConnectionHandle::onSendCallback* cb);
+	void Write(const uint8_t* data1, size_t len1, const uint8_t* data2, size_t len2, onSendCallback cb);
 	void ErrorReceiving();
 	const struct sockaddr* GetLocalAddress() const
 	{
@@ -117,7 +109,7 @@ private:
 public:
 	void OnUvReadAlloc(size_t suggestedSize, uv_buf_t* buf);
 	void OnUvRead(ssize_t nread, const uv_buf_t* buf);
-	void OnUvWrite(int status, onSendCallback* cb);
+	void OnUvWrite(int status, const onSendCallback& cb);
 
 	/* Pure virtual methods that must be implemented by the subclass. */
 protected:

package/worker/include/handles/UdpSocketHandle.hpp

@@ -2,14 +2,12 @@
 #define MS_UDP_SOCKET_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/SendCallbacks.hpp"
 #include <uv.h>
 #include <string>
 
 class UdpSocketHandle
 {
-protected:
-	using onSendCallback = const std::function<void(bool sent)>;
-
 public:
 	/* Struct for the data field of uv_req_t when sending a datagram. */
 	struct UvSendData
@@ -24,12 +22,11 @@ public:
 		~UvSendData()
 		{
 			delete[] this->store;
-			delete this->cb;
 		}
 
 		uv_udp_send_t req{};
 		uint8_t* store{ nullptr };
-		UdpSocketHandle::onSendCallback* cb{ nullptr };
+		onSendCallback cb;
 	};
 
 public:
@@ -47,8 +44,7 @@ public:
 		return this->closed;
 	}
 	void Dump(int indentation = 0) const;
-	void Send(
-	  const uint8_t* data, size_t len, const struct sockaddr* addr, UdpSocketHandle::onSendCallback* cb);
+	void Send(const uint8_t* data, size_t len, const struct sockaddr* addr, onSendCallback cb);
 	const struct sockaddr* GetLocalAddress() const
 	{
 		return reinterpret_cast<const struct sockaddr*>(std::addressof(this->localAddr));
@@ -86,7 +82,7 @@ private:
 public:
 	void OnUvRecvAlloc(size_t suggestedSize, uv_buf_t* buf);
 	void OnUvRecv(ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned int flags);
-	void OnUvSend(int status, UdpSocketHandle::onSendCallback* cb);
+	void OnUvSend(int status, const onSendCallback& cb);
 
 	/* Pure virtual methods that must be implemented by the subclass. */
 protected:

package/worker/meson.build

@@ -23,6 +23,11 @@ if host_machine.system() == 'windows'
     '-D_SCL_SECURE_NO_WARNINGS',
     # Introduced in VS 2017 15.8, allow overaligned types in aligned_storage.
     '-D_ENABLE_EXTENDED_ALIGNED_STORAGE',
+    # Don't warn about flexible array members (a C99 feature that C++ lacks and
+    # every compiler offers as an extension). They are how RTP and RTCP headers
+    # give a name to the bytes that follow them, so their length is part of the
+    # parsing arithmetic and cannot be declared.
+    '/wd4200',
   ]
 endif
 
@@ -44,6 +49,12 @@ if get_option('ms_rtc_logger_rtp')
   ]
 endif
 
+if get_option('ms_rtc_logger_send_burst')
+  cpp_args += [
+    '-DMS_RTC_LOGGER_SEND_BURST',
+  ]
+endif
+
 if get_option('ms_dump_rtp_payload_descriptor')
   cpp_args += [
     '-DMS_DUMP_RTP_PAYLOAD_DESCRIPTOR',
@@ -132,7 +143,8 @@ common_sources = [
   'src/RTC/RemoteCaptureTimeEstimator.cpp',
   'src/RTC/RemoteClockOffsetEstimator.cpp',
   'src/RTC/Router.cpp',
-  'src/RTC/RtcLogger.cpp',
+  'src/RTC/RtcLogger/RtpPacket.cpp',
+  'src/RTC/RtcLogger/SendBurst.cpp',
   'src/RTC/RtpListener.cpp',
   'src/RTC/RtpObserver.cpp',
   'src/RTC/SctpListener.cpp',
@@ -164,17 +176,30 @@ common_sources = [
   'src/RTC/RtpDictionaries/RtpRtxParameters.cpp',
   'src/RTC/SctpDictionaries/SctpStreamParameters.cpp',
   'src/RTC/BWE/AimdRateControl.cpp',
+  'src/RTC/BWE/AlrDetector.cpp',
+  'src/RTC/BWE/BitrateProber.cpp',
+  'src/RTC/BWE/BitrateUtils.cpp',
   'src/RTC/BWE/BweTypes.cpp',
   'src/RTC/BWE/DelayBasedBwe.cpp',
   'src/RTC/BWE/FeedbackAdapter.cpp',
+  'src/RTC/BWE/InterArrival.cpp',
   'src/RTC/BWE/InterArrivalDelta.cpp',
+  'src/RTC/BWE/IntervalBudget.cpp',
   'src/RTC/BWE/LinkCapacityEstimator.cpp',
   'src/RTC/BWE/LossBasedController.cpp',
+  'src/RTC/BWE/OveruseDetector.cpp',
+  'src/RTC/BWE/OveruseEstimator.cpp',
+  'src/RTC/BWE/ProbeBitrateEstimator.cpp',
+  'src/RTC/BWE/ProbeController.cpp',
+  'src/RTC/BWE/ProbePacketGenerator.cpp',
+  'src/RTC/BWE/ProbingScheduler.cpp',
+  'src/RTC/BWE/RembGenerator.cpp',
+  'src/RTC/BWE/RemoteBitrateEstimatorAbsSendTime.cpp',
   'src/RTC/BWE/RobustThroughputEstimator.cpp',
   'src/RTC/BWE/SendPacketHistory.cpp',
   'src/RTC/BWE/TargetRateController.cpp',
+  'src/RTC/BWE/TransportWideCcFeedbackGenerator.cpp',
   'src/RTC/BWE/TrendlineEstimator.cpp',
-  'src/RTC/BWE/Utils.cpp',
   'src/RTC/ICE/IceCandidate.cpp',
   'src/RTC/ICE/IceServer.cpp',
   'src/RTC/ICE/StunPacket.cpp',
@@ -473,17 +498,30 @@ test_sources = [
   'test/src/RTC/TestTransportTuple.cpp',
   'test/src/RTC/TestTrendCalculator.cpp',
   'test/src/RTC/BWE/helpers/LinkSimulator.cpp',
+  'test/src/RTC/BWE/helpers/RemoteBitrateEstimatorAbsSendTimeTestHelper.cpp',
   'test/src/RTC/BWE/TestAimdRateControl.cpp',
+  'test/src/RTC/BWE/TestAlrDetector.cpp',
+  'test/src/RTC/BWE/TestBitrateProber.cpp',
+  'test/src/RTC/BWE/TestBitrateUtils.cpp',
   'test/src/RTC/BWE/TestDelayBasedBwe.cpp',
   'test/src/RTC/BWE/TestFeedbackAdapter.cpp',
+  'test/src/RTC/BWE/TestInterArrival.cpp',
   'test/src/RTC/BWE/TestInterArrivalDelta.cpp',
+  'test/src/RTC/BWE/TestIntervalBudget.cpp',
   'test/src/RTC/BWE/TestLinkCapacityEstimator.cpp',
   'test/src/RTC/BWE/TestLossBasedController.cpp',
+  'test/src/RTC/BWE/TestOveruseDetector.cpp',
+  'test/src/RTC/BWE/TestProbeBitrateEstimator.cpp',
+  'test/src/RTC/BWE/TestProbeController.cpp',
+  'test/src/RTC/BWE/TestProbePacketGenerator.cpp',
+  'test/src/RTC/BWE/TestProbingScheduler.cpp',
+  'test/src/RTC/BWE/TestRembGenerator.cpp',
+  'test/src/RTC/BWE/TestRemoteBitrateEstimatorAbsSendTime.cpp',
   'test/src/RTC/BWE/TestRobustThroughputEstimator.cpp',
   'test/src/RTC/BWE/TestSendPacketHistory.cpp',
   'test/src/RTC/BWE/TestTargetRateController.cpp',
+  'test/src/RTC/BWE/TestTransportWideCcFeedbackGenerator.cpp',
   'test/src/RTC/BWE/TestTrendlineEstimator.cpp',
-  'test/src/RTC/BWE/TestUtils.cpp',
   'test/src/RTC/ICE/iceCommon.cpp',
   'test/src/RTC/ICE/TestStunPacket.cpp',
   'test/src/RTC/RTP/rtpCommon.cpp',

package/worker/meson_options.txt

@@ -1,6 +1,7 @@
 option('ms_log_trace', type: 'boolean', value: false, description: 'Logs the current method/function if current log level is "debug"')
 option('ms_log_file_line', type: 'boolean', value: false, description: 'Logging macros print more verbose information, including current file and line')
 option('ms_rtc_logger_rtp', type: 'boolean', value: false, description: 'Prints a line with information for each processed RTP packet')
+option('ms_rtc_logger_send_burst', type: 'boolean', value: false, description: 'Prints how many RTP packets each transport sends within a single iteration of the event loop')
 option('ms_dump_rtp_payload_descriptor', type: 'boolean', value: false, description: 'RTC::RTP::Packet::Dump() method also dumps payload descriptor details')
 option('ms_dump_rtp_shared_packet_memory_usage', type: 'boolean', value: false, description: 'prints information about total memory allocated by RTC::RTP::SharedPacket instances')
 option('ms_build_tests', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker tests')

package/worker/mocks/include/MockShared.hpp

@@ -46,8 +46,22 @@ namespace mocks
 			return this->getTimeUs();
 		}
 
-		// NOTE: The NTP epoch is made to be the very clock given by argument, so that tests
-		// can reason about a single set of values.
+		/**
+		 * @remarks
+		 * - There is no event loop here, and the clock given by argument only moves when the
+		 *   test moves it, which is the very semantics of a time that stays put for the whole
+		 *   iteration.
+		 */
+		uint64_t GetLoopTimeMs() override
+		{
+			return static_cast<uint64_t>(GetTimeMs());
+		}
+
+		/**
+		 * @remarks
+		 * - The NTP epoch is made to be the very clock given by argument, so that tests can
+		 *   reason about a single set of values.
+		 */
 		int64_t GetNtpOffsetUs() override
 		{
 			return 0;

package/worker/mocks/include/handles/MockBackoffTimerHandle.hpp

@@ -133,7 +133,7 @@ namespace mocks
 					return std::min<int64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
 				}
 
-					NO_DEFAULT_GCC();
+					NO_DEFAULT();
 			}
 		}
 

package/worker/scripts/package-lock.json

@@ -21,9 +21,9 @@
 			}
 		},
 		"node_modules/brace-expansion": {
-			"version": "5.0.9",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
-			"integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+			"version": "5.0.12",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+			"integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
 			"license": "MIT",
 			"dependencies": {
 				"balanced-match": "^4.0.2"
@@ -105,9 +105,9 @@
 			"integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="
 		},
 		"brace-expansion": {
-			"version": "5.0.9",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
-			"integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+			"version": "5.0.12",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+			"integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
 			"requires": {
 				"balanced-match": "^4.0.2"
 			}

package/worker/src/RTC/BWE/AimdRateControl.cpp

@@ -3,6 +3,7 @@
 
 #include "RTC/BWE/AimdRateControl.hpp"
 #include "Logger.hpp"
+#include "RTC/Consts.hpp"
 #include <cmath>
 
 namespace RTC
@@ -21,8 +22,6 @@ namespace RTC
 		// Bounds of how often the bitrate may be reduced, derived from the RTT.
 		static constexpr int64_t MinBitrateReductionIntervalUs{ 10 * 1000 };
 		static constexpr int64_t MaxBitrateReductionIntervalUs{ 200 * 1000 };
-		// Bitrate the target is never taken below unless configured otherwise (bps).
-		static constexpr int64_t CongestionControllerMinBitrate{ 5000 };
 		// Bitrate the target starts from before anything has been measured (bps).
 		static constexpr int64_t MaxConfiguredBitrate{ 30000 * 1000 };
 		// Headroom allowed on top of the measured throughput when increasing (bps).
@@ -64,7 +63,7 @@ namespace RTC
 
 		AimdRateControl::AimdRateControl(AimdRateControlOptions options)
 		  : options(options),
-		    minConfiguredBitrate(CongestionControllerMinBitrate),
+		    minConfiguredBitrate(Consts::BweMinBitrate),
 		    maxConfiguredBitrate(MaxConfiguredBitrate),
 		    currentBitrate(this->maxConfiguredBitrate),
 		    latestEstimatedThroughput(this->currentBitrate),
@@ -358,7 +357,7 @@ namespace RTC
 					break;
 				}
 
-					NO_DEFAULT_GCC();
+					NO_DEFAULT();
 			}
 
 			this->currentBitrate = ClampBitrate(newBitrate.value_or(this->currentBitrate));
@@ -398,7 +397,7 @@ namespace RTC
 					break;
 				}
 
-					NO_DEFAULT_GCC();
+					NO_DEFAULT();
 			}
 		}
 

package/worker/src/RTC/BWE/AlrDetector.cpp

@@ -0,0 +1,80 @@
+#define MS_CLASS "RTC::BWE::AlrDetector"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/BWE/AlrDetector.hpp"
+#include "Logger.hpp"
+#include "RTC/BWE/BitrateUtils.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/* Instance methods. */
+
+		AlrDetector::AlrDetector(SharedInterface* shared) : AlrDetector(shared, AlrDetectorOptions{})
+		{
+			MS_TRACE();
+		}
+
+		AlrDetector::AlrDetector(SharedInterface* shared, AlrDetectorOptions options)
+		  : shared(shared),
+		    options(options),
+		    // What an interval leaves unspent builds up, since not filling the link
+		    // is precisely a state that has to accumulate to be noticed.
+		    alrBudget(/*initialTargetBitrate*/ 0, /*canBuildUpUnderuse*/ true)
+		{
+			MS_TRACE();
+		}
+
+		void AlrDetector::OnBytesSent(int64_t bytesSent, int64_t sentAtUs)
+		{
+			MS_TRACE();
+
+			// How long those bytes took to go out is unknown until there is a previous
+			// send to measure them against.
+			if (!this->lastSentAtUs.has_value())
+			{
+				this->lastSentAtUs = sentAtUs;
+
+				return;
+			}
+
+			const int64_t deltaTimeUs = sentAtUs - this->lastSentAtUs.value();
+
+			this->lastSentAtUs = sentAtUs;
+
+			this->alrBudget.UseBudget(bytesSent);
+			this->alrBudget.IncreaseBudget(deltaTimeUs);
+
+			const double budgetRatio = this->alrBudget.GetBudgetRatio();
+
+			if (budgetRatio > this->options.startBudgetLevelRatio && !this->alrStartTimeUs.has_value())
+			{
+				// The instant this state began is what the rest of the module reasons
+				// about, so it's the current one and not that of the send that revealed
+				// it.
+				this->alrStartTimeUs = this->shared->GetTimeUs();
+
+				MS_DEBUG_DEV("sender is not filling the link [budgetRatio:%f]", budgetRatio);
+			}
+			else if (budgetRatio < this->options.stopBudgetLevelRatio && this->alrStartTimeUs.has_value())
+			{
+				this->alrStartTimeUs.reset();
+
+				MS_DEBUG_DEV("sender is filling the link again [budgetRatio:%f]", budgetRatio);
+			}
+		}
+
+		void AlrDetector::SetEstimatedBitrate(int64_t bitrate)
+		{
+			MS_TRACE();
+
+			// NOTE: The target this comes from is clamped to the minimum bitrate of
+			// the congestion controller, so anything else is a programming error.
+			MS_ASSERT(bitrate > 0, "bitrate must be positive [bitrate:%" PRIi64 "]", bitrate);
+
+			this->alrBudget.SetTargetBitrate(
+			  BitrateUtils::ApplyBitrateFactor(bitrate, this->options.bandwidthUsageRatio));
+		}
+	} // namespace BWE
+} // namespace RTC