mediasoup 3.27.0 → 3.28.0

package/worker/include/RTC/Transport.hpp

@@ -6,6 +6,7 @@
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "FBS/transport.h"
+#include "handles/SendCallbacks.hpp"
 #include "handles/TimerHandleInterface.hpp"
 #include "RTC/Consumer.hpp"
 #include "RTC/DataConsumer.hpp"
@@ -28,6 +29,9 @@
 #include "RTC/TransportCongestionControlServer.hpp"
 #endif
 #include "SharedInterface.hpp"
+#ifdef MS_RTC_LOGGER_SEND_BURST
+#include "RTC/RtcLogger/SendBurst.hpp"
+#endif
 #include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
@@ -47,10 +51,6 @@ namespace RTC
 	                  public Channel::ChannelSocket::NotificationHandler,
 	                  public TimerHandleInterface::Listener
 	{
-	protected:
-		using onSendCallback   = const std::function<void(bool sent)>;
-		using onQueuedCallback = const std::function<void(bool queued, bool sctpSendBufferFull)>;
-
 	public:
 		class Listener
 		{
@@ -202,7 +202,9 @@ namespace RTC
 		virtual void ReceiveRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
 		virtual void ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs) final;
 		virtual void SendSctpMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) final;
+		  RTC::DataConsumer* dataConsumer,
+		  RTC::SCTP::Message message,
+		  onMessageQueuedCallback cb = {}) final;
 
 	private:
 		virtual RTC::Producer* AssertAndGetProducerById(
@@ -228,14 +230,20 @@ namespace RTC
 		{
 			return false;
 		}
+		/**
+		 * Bytes that every packet sent through this transport carries on top of its
+		 * own length once it's on the network, or zero while no path has been
+		 * chosen yet.
+		 */
+		virtual size_t GetPacketOverhead() const = 0;
 		virtual void SendRtpPacket(
-		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const onSendCallback* cb = nullptr) = 0;
+		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) = 0;
 		virtual void HandleRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
 		virtual void SendRtcp(int64_t nowUs) final;
 		virtual void SendRtcpPacket(RTC::RTCP::Packet* packet)                 = 0;
 		virtual void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) = 0;
 		virtual void SendMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) = 0;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb = {}) = 0;
 		virtual bool SendData(const uint8_t* data, size_t len) = 0;
 		virtual void RecvStreamClosed(uint32_t ssrc)           = 0;
 		virtual void SendStreamClosed(uint32_t ssrc)           = 0;
@@ -308,7 +316,7 @@ namespace RTC
 		/* Pure virtual methods inherited from RTC::DataConsumer::Listener. */
 	public:
 		void OnDataConsumerSendMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb) override;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb) override;
 		void OnDataConsumerNeedBufferedAmount(
 		  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const override;
 		void OnDataConsumerNeedBufferedAmountLowThreshold(
@@ -412,6 +420,13 @@ namespace RTC
 		size_t maxSendMessageSize{ 0 };
 		size_t maxReceiveMessageSize{ 0 };
 		struct TraceEventTypes traceEventTypes;
+
+#ifdef MS_RTC_LOGGER_SEND_BURST
+	private:
+		RTC::RtcLogger::SendBurst sendBurstLogger;
+		// Allocated by this.
+		TimerHandleInterface* sendBurstLoggerTimer{ nullptr };
+#endif
 	};
 } // namespace RTC
 

package/worker/include/RTC/TransportTuple.hpp

@@ -3,6 +3,8 @@
 
 #include "common.hpp"
 #include "FBS/transport.h"
+#include "handles/SendCallbacks.hpp"
+#include "RTC/Consts.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/UdpSocket.hpp"
 #include "Utils.hpp"
@@ -13,9 +15,6 @@ namespace RTC
 {
 	class TransportTuple
 	{
-	protected:
-		using onSendCallback = const std::function<void(bool sent)>;
-
 	public:
 		enum class Protocol : uint8_t
 		{
@@ -139,15 +138,15 @@ namespace RTC
 			this->localAnnouncedAddress = localAnnouncedAddress;
 		}
 
-		void Send(const uint8_t* data, size_t len, RTC::TransportTuple::onSendCallback* cb = nullptr)
+		void Send(const uint8_t* data, size_t len, onSendCallback cb = {})
 		{
 			if (this->protocol == Protocol::UDP)
 			{
-				this->udpSocket->Send(data, len, this->udpRemoteAddr, cb);
+				this->udpSocket->Send(data, len, this->udpRemoteAddr, std::move(cb));
 			}
 			else
 			{
-				this->tcpConnection->Send(data, len, cb);
+				this->tcpConnection->Send(data, len, std::move(cb));
 			}
 		}
 
@@ -156,6 +155,62 @@ namespace RTC
 			return this->protocol;
 		}
 
+		/**
+		 * Bytes that every packet sent through this tuple carries on top of its own
+		 * length, which is what the network sees but nothing in here counts.
+		 *
+		 * @remarks
+		 * - It only contemplates IPv4 and IPv6 for the network layer and UDP and
+		 *   TCP for the transport one, both without options, plus the length field
+		 *   that frames a packet sent over TCP. Anything below that, such as the
+		 *   Ethernet frame or a tunnel, is not counted.
+		 */
+		size_t GetPacketOverhead() const
+		{
+			size_t overhead{ 0 };
+
+			switch (GetLocalAddress()->sa_family)
+			{
+				case AF_INET:
+				{
+					overhead += RTC::Consts::Ipv4HeaderSize;
+
+					break;
+				}
+
+				case AF_INET6:
+				{
+					overhead += RTC::Consts::Ipv6HeaderSize;
+
+					break;
+				}
+
+				default:
+				{
+					break;
+				}
+			}
+
+			switch (this->protocol)
+			{
+				case Protocol::UDP:
+				{
+					overhead += RTC::Consts::UdpHeaderSize;
+
+					break;
+				}
+
+				case Protocol::TCP:
+				{
+					overhead += RTC::Consts::TcpHeaderSize + RTC::Consts::TcpFramingSize;
+
+					break;
+				}
+			}
+
+			return overhead;
+		}
+
 		const struct sockaddr* GetLocalAddress() const
 		{
 			if (this->protocol == Protocol::UDP)

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,13 +176,29 @@ 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/ICE/IceCandidate.cpp',
   'src/RTC/ICE/IceServer.cpp',
@@ -470,13 +498,29 @@ 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/ICE/iceCommon.cpp',
   'test/src/RTC/ICE/TestStunPacket.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"
 			}