mediasoup 3.26.0 → 3.27.0

package/worker/include/RTC/WebRtcTransport.hpp

@@ -63,9 +63,13 @@ namespace RTC
 		flatbuffers::Offset<FBS::WebRtcTransport::DumpResponse> FillBuffer(
 		  flatbuffers::FlatBufferBuilder& builder) const;
 		void ProcessStunPacketFromWebRtcServer(
-		  RTC::TransportTuple* tuple, const RTC::ICE::StunPacket* packet);
+		  RTC::TransportTuple* tuple, const RTC::ICE::StunPacket* packet, int64_t receivedAtUs);
 		void ProcessNonStunPacketFromWebRtcServer(
-		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
 		void RemoveTuple(RTC::TransportTuple* tuple);
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
@@ -92,11 +96,24 @@ namespace RTC
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
-		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnStunDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnDtlsDataReceived(const RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnRtpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtcpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnStunDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnDtlsDataReceived(
+		  const RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnRtpDataReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtcpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 
 		/* Pure virtual methods inherited from RTC::UdpSocket::Listener. */
 	public:
@@ -105,7 +122,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 		/* Pure virtual methods inherited from RTC::TcpServer::Listener. */
 	public:
@@ -114,7 +132,11 @@ namespace RTC
 		/* Pure virtual methods inherited from RTC::TcpConnection::Listener. */
 	public:
 		void OnTcpConnectionPacketReceived(
-		  RTC::TcpConnection* connection, const uint8_t* data, size_t len, size_t bufferLen) override;
+		  RTC::TcpConnection* connection,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs) override;
 
 		/* Pure virtual methods inherited from RTC::ICE::IceServer::Listener. */
 	public:
@@ -150,7 +172,10 @@ namespace RTC
 		void OnDtlsTransportSendData(
 		  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) override;
 		void OnDtlsTransportApplicationDataReceived(
-		  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) override;
+		  const RTC::DtlsTransport* dtlsTransport,
+		  const uint8_t* data,
+		  size_t len,
+		  int64_t receivedAtUs) override;
 
 	private:
 		// Passed by argument.

package/worker/include/Settings.hpp

@@ -34,11 +34,13 @@ public:
 	{
 		LogLevel logLevel{ LogLevel::LOG_ERROR };
 		struct LogTags logTags;
-		uint16_t rtcMinPort{ 10000u };
-		uint16_t rtcMaxPort{ 59999u };
+		uint16_t rtcMinPort{ 10000 };
+		uint16_t rtcMaxPort{ 59999 };
 		std::string dtlsCertificateFile;
 		std::string dtlsPrivateKeyFile;
+#ifndef MS_USE_BUILTIN_BWE
 		std::string libwebrtcFieldTrials{ "WebRTC-Bwe-AlrLimitedBackoff/Enabled/" };
+#endif
 	};
 
 public:

package/worker/include/Shared.hpp

@@ -26,39 +26,24 @@ public:
 		return this->channelNotifier.get();
 	}
 
-	TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) override;
+	TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener, std::string label) override;
 
 	BackoffTimerHandleInterface* CreateBackoffTimer(
 	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) override;
 
-	uint64_t GetTimeMs() override
+	int64_t GetTimeMs() override
 	{
 		return DepLibUV::GetTimeMs();
 	}
 
-	uint64_t GetTimeUs() override
+	int64_t GetTimeUs() override
 	{
 		return DepLibUV::GetTimeUs();
 	}
 
-	uint64_t GetTimeNs() override
+	int64_t GetNtpOffsetUs() override
 	{
-		return DepLibUV::GetTimeNs();
-	}
-
-	int64_t GetTimeMsInt64() override
-	{
-		return DepLibUV::GetTimeMsInt64();
-	}
-
-	int64_t GetTimeUsInt64() override
-	{
-		return DepLibUV::GetTimeUsInt64();
-	}
-
-	uint64_t GetNtpOffsetMs() override
-	{
-		return DepLibUV::GetNtpOffsetMs();
+		return DepLibUV::GetNtpOffsetUs();
 	}
 
 private:

package/worker/include/SharedInterface.hpp

@@ -29,7 +29,8 @@ public:
 	 * @remarks
 	 * - The caller is responsible for freeing it.
 	 */
-	virtual TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) = 0;
+	virtual TimerHandleInterface* CreateTimer(
+	  TimerHandleInterface::Listener* listener, std::string label) = 0;
 
 	/**
 	 * Creates a BackoffTimerHandle timer.
@@ -43,41 +44,18 @@ public:
 	/**
 	 * Get current time in milliseconds.
 	 */
-	virtual uint64_t GetTimeMs() = 0;
+	virtual int64_t GetTimeMs() = 0;
 
 	/**
 	 * Get current time in microseconds.
 	 */
-	virtual uint64_t GetTimeUs() = 0;
+	virtual int64_t GetTimeUs() = 0;
 
 	/**
-	 * Get current time in nanoseconds.
-	 */
-	virtual uint64_t GetTimeNs() = 0;
-
-	/**
-	 * @remarks
-	 * - Used within libwebrtc dependency which uses int64_t values for time
-	 *   representation.
-	 *
-	 * @todo Remove once not needed.
-	 */
-	virtual int64_t GetTimeMsInt64() = 0;
-
-	/**
-	 * @remarks
-	 * - Used within libwebrtc dependency which uses int64_t values for time
-	 *   representation.
-	 *
-	 * @todo Remove once not needed.
-	 */
-	virtual int64_t GetTimeUsInt64() = 0;
-
-	/**
-	 * Distance from the clock above to the NTP epoch (ms), which is what has to be added
+	 * 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.
 	 */
-	virtual uint64_t GetNtpOffsetMs() = 0;
+	virtual int64_t GetNtpOffsetUs() = 0;
 };
 
 #endif

package/worker/include/Utils.hpp

@@ -197,13 +197,13 @@ namespace Utils
 		template<typename T>
 		typename std::enable_if<std::is_unsigned<T>::value, bool>::type static IsPaddedTo4Bytes(T size)
 		{
-			return (size & 0x03) == 0u;
+			return (size & 0x03) == 0;
 		}
 
 		template<typename T>
 		typename std::enable_if<std::is_unsigned<T>::value, bool>::type static IsPaddedTo8Bytes(T size)
 		{
-			return (size & 0x07) == 0u;
+			return (size & 0x07) == 0;
 		}
 
 		template<typename T>
@@ -515,7 +515,10 @@ namespace Utils
 			uint32_t fractions;
 		};
 
-		static Time::Ntp TimeMs2Ntp(uint64_t ms)
+		/**
+		 * Convert microseconds into an NTP timestamp.
+		 */
+		static Time::Ntp TimeUs2Ntp(int64_t timeUs)
 		{
 			Time::Ntp ntp{}; // NOLINT(cppcoreguidelines-pro-type-member-init)
 
@@ -523,28 +526,44 @@ namespace Utils
 			// every 2^32 seconds since Jan 1, 1900, being Feb 7, 2036 the next time it
 			// happens. That is the NTP era and receivers deal with it by doing modular
 			// arithmetic, so there is nothing to protect against here.
-			ntp.seconds = static_cast<uint32_t>(ms / 1000);
+			ntp.seconds = static_cast<uint32_t>(timeUs / 1000000);
 			ntp.fractions =
-			  static_cast<uint32_t>((static_cast<double>(ms % 1000) / 1000) * NtpFractionalUnit);
+			  static_cast<uint32_t>((static_cast<double>(timeUs % 1000000) / 1000000) * NtpFractionalUnit);
 
 			return ntp;
 		}
 
-		static uint64_t Ntp2TimeMs(Time::Ntp ntp)
+		/**
+		 * Convert an NTP timestamp into microseconds.
+		 */
+		static int64_t Ntp2TimeUs(Time::Ntp ntp)
 		{
 			return (
-			  (static_cast<uint64_t>(ntp.seconds) * 1000) +
-			  static_cast<uint64_t>(
-			    std::round((static_cast<double>(ntp.fractions) * 1000) / NtpFractionalUnit)));
+			  (static_cast<int64_t>(ntp.seconds) * 1000000) +
+			  static_cast<int64_t>(
+			    std::round((static_cast<double>(ntp.fractions) * 1000000) / NtpFractionalUnit)));
 		}
 
-		static uint32_t TimeMsToAbsSendTime(uint64_t ms)
+		/**
+		 * Convert microseconds into the 6.18 fixed point seconds of the
+		 * `abs-send-time` RTP header extension, whose resolution is hence 1/262144
+		 * of a second.
+		 */
+		static uint32_t TimeUsToAbsSendTime(int64_t timeUs)
 		{
-			return static_cast<uint32_t>(((ms << 18) + 500) / 1000) & 0x00FFFFFF;
+			// Period after which the 24 bits of the field wrap around.
+			constexpr int64_t WrapPeriodUs{ 64 * 1000000 };
+
+			// NOTE: Bring the given time into the period first. This keeps the shift
+			// below from overflowing, and makes a negative time yield the same value
+			// as the positive time it's congruent with rather than a meaningless one.
+			const int64_t wrappedUs = ((timeUs % WrapPeriodUs) + WrapPeriodUs) % WrapPeriodUs;
+
+			return static_cast<uint32_t>(((wrappedUs << 18) + 500000) / 1000000) & 0x00FFFFFF;
 		}
 
 		/**
-		 * Convert milliseconds into signed Q32.32 fixed point seconds, which is how the
+		 * Convert microseconds into signed Q32.32 fixed point seconds, which is how the
 		 * `abs-capture-time` RTP header extension encodes its clock offset, being the
 		 * capture timestamp itself unsigned instead (UQ32.32).
 		 *
@@ -553,29 +572,29 @@ namespace Utils
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/draft-ietf-avtcore-abs-capture-time-00
 		 */
-		static std::optional<int64_t> TimeMs2Q32x32(int64_t ms)
+		static std::optional<int64_t> TimeUs2Q32x32(int64_t timeUs)
 		{
 			// The seconds of the format are 32 bits wide, so from here on it does not fit.
-			static constexpr int64_t OutOfRangeMs{ (1LL << 31) * 1000 };
+			static constexpr int64_t OutOfRangeUs{ (1LL << 31) * 1000000 };
 
-			if (ms >= OutOfRangeMs || ms <= -OutOfRangeMs)
+			if (timeUs >= OutOfRangeUs || timeUs <= -OutOfRangeUs)
 			{
 				return std::nullopt;
 			}
 
-			return static_cast<int64_t>(
-			  std::round(static_cast<double>(ms) * (static_cast<double>(NtpFractionalUnit) / 1000)));
+			return static_cast<int64_t>(std::round(
+			  static_cast<double>(timeUs) * (static_cast<double>(NtpFractionalUnit) / 1000000)));
 		}
 
 		/**
-		 * Convert signed Q32.32 fixed point seconds into milliseconds.
+		 * Convert signed Q32.32 fixed point seconds into microseconds.
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/draft-ietf-avtcore-abs-capture-time-00
 		 */
-		static int64_t Q32x32ToTimeMs(int64_t q32x32)
+		static int64_t Q32x32ToTimeUs(int64_t q32x32)
 		{
-			return static_cast<int64_t>(
-			  std::round(static_cast<double>(q32x32) * (1000 / static_cast<double>(NtpFractionalUnit))));
+			return static_cast<int64_t>(std::round(
+			  static_cast<double>(q32x32) * (1000000 / static_cast<double>(NtpFractionalUnit))));
 		}
 	};
 

package/worker/include/common.hpp

@@ -1,6 +1,9 @@
 #ifndef MS_COMMON_HPP
 #define MS_COMMON_HPP
 
+// NOTE: This is an umbrella header. The includes below are not meant to be used
+// by this file, but re-exported to whoever includes it.
+// IWYU pragma: begin_exports
 #include <algorithm> // std::transform(), std::find(), std::min(), std::max(), std::copy(), std::clamp(), std::ranges
 #include <cinttypes>  // PRIu64, etc
 #include <cstddef>    // size_t
@@ -24,6 +27,7 @@ typedef SSIZE_T ssize_t;
 #include <netinet/in.h> // sockaddr_in, sockaddr_in6
 #include <sys/socket.h> // struct sockaddr, struct sockaddr_storage, AF_INET, AF_INET6
 #endif
+// IWYU pragma: end_exports
 
 // This is a macro to silence false warnings in GCC in switch() blocks with FBS
 // types.

package/worker/include/handles/BackoffTimerHandle.hpp

@@ -40,7 +40,7 @@ public:
 	 * Set the base timeout duration. It will be applied after the next timeout
 	 * and effective duration can be larger if backoff algorithm is exponential.
 	 */
-	void SetBaseTimeoutMs(uint64_t baseTimeoutMs) override;
+	void SetBaseTimeoutMs(int64_t baseTimeoutMs) override;
 
 	/**
 	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer
@@ -77,7 +77,7 @@ public:
 	}
 
 private:
-	uint64_t ComputeNextTimeoutMs() const;
+	int64_t ComputeNextTimeoutMs() const;
 
 	/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 public:
@@ -87,9 +87,9 @@ private:
 	// Passed by argument.
 	BackoffTimerHandleInterface::Listener* listener{ nullptr };
 	const std::string label;
-	uint64_t baseTimeoutMs;
+	int64_t baseTimeoutMs;
 	BackoffAlgorithm backoffAlgorithm;
-	std::optional<uint64_t> maxBackoffTimeoutMs;
+	std::optional<int64_t> maxBackoffTimeoutMs;
 	std::optional<size_t> maxRestarts;
 	// Allocated by this.
 	TimerHandle* timer{ nullptr };

package/worker/include/handles/BackoffTimerHandleInterface.hpp

@@ -23,7 +23,7 @@ public:
 		 *   it must signal it be setting `stop` to true.
 		 */
 		virtual void OnBackoffTimer(
-		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) = 0;
+		  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop) = 0;
 	};
 
 public:
@@ -51,7 +51,7 @@ public:
 		/**
 		 * Base timeout duration (ms).
 		 */
-		uint64_t baseTimeoutMs;
+		int64_t baseTimeoutMs;
 		/**
 		 * Backoff algorithm.
 		 */
@@ -60,7 +60,7 @@ public:
 		 * Maximum duration of the backoff timeout (ms). If no value is given, no
 		 * limit is set.
 		 */
-		std::optional<uint64_t> maxBackoffTimeoutMs;
+		std::optional<int64_t> maxBackoffTimeoutMs;
 		/**
 		 * Maximum number of restarts. If no value is given, it will restart
 		 * forever until stopped.
@@ -69,7 +69,7 @@ public:
 	};
 
 public:
-	static constexpr uint64_t MaxTimeoutMs{ std::numeric_limits<uint64_t>::max() / 2 };
+	static constexpr int64_t MaxTimeoutMs{ std::numeric_limits<int64_t>::max() / 2 };
 
 public:
 	BackoffTimerHandleInterface() = default;
@@ -96,7 +96,7 @@ public:
 	 * Set the base timeout duration. It will be applied after the next timeout
 	 * and effective duration can be larger if backoff algorithm is exponential.
 	 */
-	virtual void SetBaseTimeoutMs(uint64_t baseTimeoutMs) = 0;
+	virtual void SetBaseTimeoutMs(int64_t baseTimeoutMs) = 0;
 
 	/**
 	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer

package/worker/include/handles/TcpConnectionHandle.hpp

@@ -125,16 +125,16 @@ protected:
 
 protected:
 	// Passed by argument.
-	size_t bufferSize{ 0u };
+	size_t bufferSize{ 0 };
 	// Allocated by this.
 	uint8_t* buffer{ nullptr };
 	// Others.
-	size_t bufferDataLen{ 0u };
+	size_t bufferDataLen{ 0 };
 	std::string localIp;
-	uint16_t localPort{ 0u };
+	uint16_t localPort{ 0 };
 	struct sockaddr_storage peerAddr{};
 	std::string peerIp;
-	uint16_t peerPort{ 0u };
+	uint16_t peerPort{ 0 };
 
 private:
 	// Passed by argument.
@@ -144,8 +144,8 @@ private:
 	// Others.
 	struct sockaddr_storage* localAddr{ nullptr };
 	bool closed{ false };
-	size_t recvBytes{ 0u };
-	size_t sentBytes{ 0u };
+	size_t recvBytes{ 0 };
+	size_t sentBytes{ 0 };
 	bool isClosedByPeer{ false };
 	bool hasError{ false };
 };

package/worker/include/handles/TcpServerHandle.hpp

@@ -66,7 +66,7 @@ public:
 protected:
 	struct sockaddr_storage localAddr{};
 	std::string localIp;
-	uint16_t localPort{ 0u };
+	uint16_t localPort{ 0 };
 
 private:
 	// Allocated by this (may be passed by argument).

package/worker/include/handles/TimerHandle.hpp

@@ -16,7 +16,7 @@ class TimerHandle : public TimerHandleInterface
 	friend class BackoffTimerHandle;
 
 private:
-	explicit TimerHandle(TimerHandleInterface::Listener* listener);
+	explicit TimerHandle(TimerHandleInterface::Listener* listener, std::string label);
 
 public:
 	TimerHandle& operator=(const TimerHandle&) = delete;
@@ -26,22 +26,22 @@ public:
 	~TimerHandle() override;
 
 public:
-	void Start(uint64_t timeout, uint64_t repeat = 0) override;
+	void Start(int64_t timeoutMs, int64_t repeatMs = 0) override;
 
 	void Stop() override;
 
 	void Restart() override;
 
-	void Restart(uint64_t timeout, uint64_t repeat = 0) override;
+	void Restart(int64_t timeoutMs, int64_t repeatMs = 0) override;
 
-	uint64_t GetTimeout() const override
+	int64_t GetTimeoutMs() const override
 	{
-		return this->timeout;
+		return this->timeoutMs;
 	}
 
-	uint64_t GetRepeat() const override
+	int64_t GetRepeatMs() const override
 	{
-		return this->repeat;
+		return this->repeatMs;
 	}
 
 	bool IsActive() const override
@@ -49,6 +49,11 @@ public:
 		return uv_is_active(reinterpret_cast<uv_handle_t*>(this->uvHandle)) != 0;
 	}
 
+	const std::string GetLabel() const override
+	{
+		return this->label;
+	}
+
 private:
 	void InternalClose();
 
@@ -59,12 +64,13 @@ public:
 private:
 	// Passed by argument.
 	TimerHandleInterface::Listener* listener{ nullptr };
+	const std::string label;
 	// Allocated by this.
 	uv_timer_t* uvHandle{ nullptr };
 	// Others.
 	bool closed{ false };
-	uint64_t timeout{ 0u };
-	uint64_t repeat{ 0u };
+	int64_t timeoutMs{ 0 };
+	int64_t repeatMs{ 0 };
 };
 
 #endif

package/worker/include/handles/TimerHandleInterface.hpp

@@ -2,6 +2,7 @@
 #define MS_TIMER_HANDLE_INTERFACE_HPP
 
 #include "common.hpp"
+#include <string>
 
 class TimerHandleInterface
 {
@@ -25,19 +26,24 @@ public:
 	virtual ~TimerHandleInterface() = default;
 
 public:
-	virtual void Start(uint64_t timeout, uint64_t repeat = 0) = 0;
+	virtual void Start(int64_t timeoutMs, int64_t repeatMs = 0) = 0;
 
 	virtual void Stop() = 0;
 
 	virtual void Restart() = 0;
 
-	virtual void Restart(uint64_t timeout, uint64_t repeat = 0) = 0;
+	virtual void Restart(int64_t timeoutMs, int64_t repeatMs = 0) = 0;
 
-	virtual uint64_t GetTimeout() const = 0;
+	virtual int64_t GetTimeoutMs() const = 0;
 
-	virtual uint64_t GetRepeat() const = 0;
+	virtual int64_t GetRepeatMs() const = 0;
 
 	virtual bool IsActive() const = 0;
+
+	/**
+	 * Label of this timer, given at creation time.
+	 */
+	virtual const std::string GetLabel() const = 0;
 };
 
 #endif

package/worker/include/handles/UdpSocketHandle.hpp

@@ -96,15 +96,15 @@ protected:
 protected:
 	struct sockaddr_storage localAddr{};
 	std::string localIp;
-	uint16_t localPort{ 0u };
+	uint16_t localPort{ 0 };
 
 private:
 	// Allocated by this (may be passed by argument).
 	uv_udp_t* uvHandle{ nullptr };
 	// Others.
 	bool closed{ false };
-	size_t recvBytes{ 0u };
-	size_t sentBytes{ 0u };
+	size_t recvBytes{ 0 };
+	size_t sentBytes{ 0 };
 };
 
 #endif

package/worker/include/handles/UnixStreamSocketHandle.hpp

@@ -71,12 +71,12 @@ private:
 
 protected:
 	// Passed by argument.
-	size_t bufferSize{ 0u };
+	size_t bufferSize{ 0 };
 	UnixStreamSocketHandle::Role role;
 	// Allocated by this.
 	uint8_t* buffer{ nullptr };
 	// Others.
-	size_t bufferDataLen{ 0u };
+	size_t bufferDataLen{ 0 };
 };
 
 #endif