mediasoup 3.19.21 → 3.20.0

package/worker/include/RTC/TransportCongestionControlClient.hpp

@@ -2,13 +2,14 @@
 #define MS_RTC_TRANSPORT_CONGESTION_CONTROL_CLIENT_HPP
 
 #include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/BweType.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/ReceiverReport.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/ProbationGenerator.hpp"
 #include "RTC/TrendCalculator.hpp"
-#include "handles/TimerHandle.hpp"
+#include "SharedInterface.hpp"
 #include <libwebrtc/api/transport/goog_cc_factory.h>
 #include <libwebrtc/api/transport/network_types.h>
 #include <libwebrtc/call/rtp_transport_controller_send.h>
@@ -21,7 +22,7 @@ namespace RTC
 
 	class TransportCongestionControlClient : public webrtc::PacketRouter,
 	                                         public webrtc::TargetTransferRateObserver,
-	                                         public TimerHandle::Listener
+	                                         public TimerHandleInterface::Listener
 	{
 	public:
 		struct Bitrates
@@ -54,6 +55,7 @@ namespace RTC
 	public:
 		TransportCongestionControlClient(
 		  RTC::TransportCongestionControlClient::Listener* listener,
+		  SharedInterface* shared,
 		  RTC::BweType bweType,
 		  uint32_t initialAvailableBitrate,
 		  uint32_t maxOutgoingBitrate,
@@ -104,18 +106,19 @@ namespace RTC
 		void SendPacket(RTC::RTP::Packet* packet, const webrtc::PacedPacketInfo& pacingInfo) override;
 		RTC::RTP::Packet* GeneratePadding(size_t size) override;
 
-		/* Pure virtual methods inherited from RTC::TimerHandle. */
+		/* Pure virtual methods inherited from RTC::TimerHandleInterface. */
 	public:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Allocated by this.
 		webrtc::NetworkControllerFactoryInterface* controllerFactory{ nullptr };
 		webrtc::RtpTransportControllerSend* rtpTransportControllerSend{ nullptr };
 		RTC::RTP::ProbationGenerator* probationGenerator{ nullptr };
-		TimerHandle* processTimer{ nullptr };
+		TimerHandleInterface* processTimer{ nullptr };
 		// Others.
 		RTC::BweType bweType;
 		uint32_t initialAvailableBitrate{ 0u };

package/worker/include/RTC/TransportCongestionControlServer.hpp

@@ -2,19 +2,20 @@
 #define MS_RTC_TRANSPORT_CONGESTION_CONTROL_SERVER_HPP
 
 #include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/BweType.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/Packet.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/SeqManager.hpp"
-#include "handles/TimerHandle.hpp"
+#include "SharedInterface.hpp"
 #include <libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h>
 #include <deque>
 
 namespace RTC
 {
 	class TransportCongestionControlServer : public webrtc::RemoteBitrateEstimator::Listener,
-	                                         public TimerHandle::Listener
+	                                         public TimerHandleInterface::Listener
 	{
 	public:
 		class Listener
@@ -30,6 +31,7 @@ namespace RTC
 	public:
 		TransportCongestionControlServer(
 		  RTC::TransportCongestionControlServer::Listener* listener,
+		  SharedInterface* shared,
 		  RTC::BweType bweType,
 		  size_t maxRtcpPacketLen);
 		~TransportCongestionControlServer() override;
@@ -72,15 +74,16 @@ namespace RTC
 		  const std::vector<uint32_t>& ssrcs,
 		  uint32_t availableBitrate) override;
 
-		/* Pure virtual methods inherited from TimerHandle::Listener. */
+		/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 	public:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Allocated by this.
-		TimerHandle* transportCcFeedbackSendPeriodicTimer{ nullptr };
+		TimerHandleInterface* transportCcFeedbackSendPeriodicTimer{ nullptr };
 		std::unique_ptr<RTC::RTCP::FeedbackRtpTransportPacket> transportCcFeedbackPacket;
 		webrtc::RemoteBitrateEstimatorAbsSendTime* rembServer{ nullptr };
 		// Others.

package/worker/include/RTC/TransportTuple.hpp

@@ -2,10 +2,10 @@
 #define MS_RTC_TRANSPORT_TUPLE_HPP
 
 #include "common.hpp"
-#include "Utils.hpp"
 #include "FBS/transport.h"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/UdpSocket.hpp"
+#include "Utils.hpp"
 #include <flatbuffers/flatbuffers.h>
 #include <string>
 

package/worker/include/RTC/UdpSocket.hpp

@@ -2,8 +2,8 @@
 #define MS_RTC_UDP_SOCKET_HPP
 
 #include "common.hpp"
-#include "RTC/Transport.hpp"
 #include "handles/UdpSocketHandle.hpp"
+#include "RTC/Transport.hpp"
 #include <string>
 
 namespace RTC

package/worker/include/RTC/WebRtcServer.hpp

@@ -4,12 +4,12 @@
 #include "Channel/ChannelRequest.hpp"
 #include "RTC/ICE/IceCandidate.hpp"
 #include "RTC/ICE/StunPacket.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/TcpServer.hpp"
 #include "RTC/TransportTuple.hpp"
 #include "RTC/UdpSocket.hpp"
 #include "RTC/WebRtcTransport.hpp"
+#include "SharedInterface.hpp"
 #include <flatbuffers/flatbuffers.h>
 #include <absl/container/flat_hash_map.h>
 #include <absl/container/flat_hash_set.h>
@@ -52,7 +52,7 @@ namespace RTC
 
 	public:
 		WebRtcServer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const flatbuffers::Vector<flatbuffers::Offset<FBS::Transport::ListenInfo>>* listenInfos);
 		~WebRtcServer() override;
@@ -112,7 +112,7 @@ namespace RTC
 		// Passed by argument.
 		std::string id;
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Vector of UdpSockets and TcpServers in the user given order.
 		std::vector<UdpSocketOrTcpServer> udpSocketOrTcpServers;
 		// Set of WebRtcTransports.

package/worker/include/RTC/WebRtcTransport.hpp

@@ -5,13 +5,13 @@
 #include "RTC/ICE/IceCandidate.hpp"
 #include "RTC/ICE/IceServer.hpp"
 #include "RTC/ICE/StunPacket.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/TcpServer.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
 #include "RTC/UdpSocket.hpp"
+#include "SharedInterface.hpp"
 #include <vector>
 
 namespace RTC
@@ -44,12 +44,12 @@ namespace RTC
 
 	public:
 		WebRtcTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::WebRtcTransport::WebRtcTransportOptions* options);
 		WebRtcTransport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  WebRtcTransportListener* webRtcTransportListener,
@@ -87,11 +87,9 @@ namespace RTC
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
+		  RTC::SCTP::Message message,
 		  onQueuedCallback* cb = nullptr) override;
-		bool SendSctpData(const uint8_t* data, size_t len) override;
+		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);

package/worker/include/Settings.hpp

@@ -2,8 +2,8 @@
 #define MS_SETTINGS_HPP
 
 #include "common.hpp"
-#include "LogLevel.hpp"
 #include "Channel/ChannelRequest.hpp"
+#include "LogLevel.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <string>
 #include <vector>
@@ -40,7 +40,6 @@ public:
 		std::string dtlsPrivateKeyFile;
 		std::string libwebrtcFieldTrials{ "WebRTC-Bwe-AlrLimitedBackoff/Enabled/" };
 		bool disableLiburing{ false };
-		bool useBuiltInSctpStack{ false };
 	};
 
 public:
@@ -54,7 +53,7 @@ private:
 	static void SetDtlsCertificateAndPrivateKeyFiles();
 
 public:
-	thread_local static struct Configuration configuration;
+	static thread_local struct Configuration configuration;
 
 private:
 	static const absl::flat_hash_map<std::string, LogLevel> String2LogLevel;

package/worker/include/Shared.hpp

@@ -0,0 +1,64 @@
+#ifndef MS_SHARED_HPP
+#define MS_SHARED_HPP
+
+#include "Channel/ChannelMessageRegistrator.hpp"
+#include "Channel/ChannelNotifier.hpp"
+#include "DepLibUV.hpp"
+#include "SharedInterface.hpp"
+
+class Shared : public SharedInterface
+{
+public:
+	explicit Shared(
+	  Channel::ChannelMessageRegistrator* channelMessageRegistrator,
+	  Channel::ChannelNotifier* channelNotifier);
+
+	~Shared() override;
+
+public:
+	Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() override
+	{
+		return this->channelMessageRegistrator.get();
+	}
+
+	Channel::ChannelNotifier* GetChannelNotifier() override
+	{
+		return this->channelNotifier.get();
+	}
+
+	TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) override;
+
+	BackoffTimerHandleInterface* CreateBackoffTimer(
+	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) override;
+
+	uint64_t GetTimeMs() override
+	{
+		return DepLibUV::GetTimeMs();
+	}
+
+	uint64_t GetTimeUs() override
+	{
+		return DepLibUV::GetTimeUs();
+	}
+
+	uint64_t GetTimeNs() override
+	{
+		return DepLibUV::GetTimeNs();
+	}
+
+	int64_t GetTimeMsInt64() override
+	{
+		return DepLibUV::GetTimeMsInt64();
+	}
+
+	int64_t GetTimeUsInt64() override
+	{
+		return DepLibUV::GetTimeUsInt64();
+	}
+
+private:
+	std::unique_ptr<Channel::ChannelMessageRegistrator> channelMessageRegistrator;
+	std::unique_ptr<Channel::ChannelNotifier> channelNotifier;
+};
+
+#endif

package/worker/include/SharedInterface.hpp

@@ -0,0 +1,77 @@
+#ifndef MS_SHARED_INTERFACE_HPP
+#define MS_SHARED_INTERFACE_HPP
+
+#include "Channel/ChannelMessageRegistratorInterface.hpp"
+// TODO: We should have a ChannelNotifierInterface class instead.
+#include "Channel/ChannelNotifier.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "handles/TimerHandleInterface.hpp"
+
+class SharedInterface
+{
+public:
+	virtual ~SharedInterface() = default;
+
+public:
+	/**
+	 * @todo We should have a ChannelMessageRegistratorInterface class instead.
+	 */
+	virtual Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() = 0;
+
+	/**
+	 * @todo We should have a ChannelNotifierInterface class instead.
+	 */
+	virtual Channel::ChannelNotifier* GetChannelNotifier() = 0;
+
+	/**
+	 * Creates a TimerHandle timer.
+	 *
+	 * @remarks
+	 * - The caller is responsible for freeing it.
+	 */
+	virtual TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) = 0;
+
+	/**
+	 * Creates a BackoffTimerHandle timer.
+	 *
+	 * @remarks
+	 * - The caller is responsible for freeing it.
+	 */
+	virtual BackoffTimerHandleInterface* CreateBackoffTimer(
+	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) = 0;
+
+	/**
+	 * Get current time in milliseconds.
+	 */
+	virtual uint64_t GetTimeMs() = 0;
+
+	/**
+	 * Get current time in microseconds.
+	 */
+	virtual uint64_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;
+};
+
+#endif

package/worker/include/Utils/UnwrappedSequenceNumber.hpp

@@ -0,0 +1,270 @@
+#ifndef MS_UTILS_UNWRAPPED_SEQUENCE_NUMBER_HPP
+#define MS_UTILS_UNWRAPPED_SEQUENCE_NUMBER_HPP
+
+#include "common.hpp"
+#include <limits>
+#include <ostream>
+#include <typeinfo>
+
+namespace Utils
+{
+	/**
+	 * UnwrappedSequenceNumber handles wrapping sequence numbers and unwraps
+	 * them to an int64_t value space, to allow wrapped sequence numbers to be
+	 * easily compared for ordering.
+	 *
+	 * Sequence numbers are expected to be monotonically increasing, but they
+	 * do not need to be unwrapped in order, as long as the difference to the
+	 * previous one is not larger than half the range of the wrapped sequence
+	 * number.
+	 */
+	template<typename T>
+	class UnwrappedSequenceNumber
+	{
+	public:
+		static_assert(!std::numeric_limits<T>::is_signed, "the wrapped type must be unsigned");
+		static_assert(
+		  std::numeric_limits<T>::max() < std::numeric_limits<int64_t>::max(),
+		  "the wrapped type must be less than the int64_t value space");
+
+		/**
+		 * The unwrapper is a sort of factory and converts wrapped sequence
+		 * numbers to unwrapped ones.
+		 */
+		class Unwrapper
+		{
+		public:
+			Unwrapper() = default;
+
+			Unwrapper(const Unwrapper&) = default;
+
+			Unwrapper& operator=(const Unwrapper&) = default;
+
+		public:
+			/**
+			 * Given a wrapped `value`, and with knowledge of its current last seen
+			 * largest number, will return a value that can be compared using normal
+			 * operators, such as less-than, greater-than etc.
+			 *
+			 * This will also update the Unwrapper's state, to track the last seen
+			 * largest value.
+			 */
+			UnwrappedSequenceNumber<T> Unwrap(T value)
+			{
+				if (!this->lastValue)
+				{
+					this->lastUnwrapped = value;
+				}
+				else
+				{
+					const uint64_t prev = this->lastValue->GetValue();
+					const uint64_t curr = value;
+					auto delta          = static_cast<int64_t>(curr - prev);
+					const auto half     = static_cast<int64_t>(1) << (sizeof(T) * 8 - 1);
+
+					if (delta < -half)
+					{
+						delta += static_cast<int64_t>(1) << (sizeof(T) * 8);
+					}
+					else if (delta > half)
+					{
+						delta -= static_cast<int64_t>(1) << (sizeof(T) * 8);
+					}
+
+					this->lastUnwrapped += delta;
+				}
+
+				this->lastValue = UnwrappedSequenceNumber<T>(value);
+
+				return UnwrappedSequenceNumber<T>(this->lastUnwrapped);
+			}
+
+			/**
+			 * Similar to `Unwrap()`, but will not update the Unwrappers's internal
+			 * state.
+			 */
+			UnwrappedSequenceNumber<T> PeekUnwrap(T value) const
+			{
+				if (!this->lastValue)
+				{
+					return UnwrappedSequenceNumber<T>(value);
+				}
+
+				const uint64_t prev = this->lastValue->GetValue();
+				const uint64_t curr = value;
+				auto delta          = static_cast<int64_t>(curr - prev);
+				const auto half     = static_cast<int64_t>(1) << (sizeof(T) * 8 - 1);
+
+				if (delta < -half)
+				{
+					delta += static_cast<int64_t>(1) << (sizeof(T) * 8);
+				}
+				else if (delta > half)
+				{
+					delta -= static_cast<int64_t>(1) << (sizeof(T) * 8);
+				}
+
+				return UnwrappedSequenceNumber<T>(this->lastUnwrapped + delta);
+			}
+
+			/**
+			 * Resets the Unwrapper to its pristine state. Used when a sequence number
+			 * is to be reset to zero.
+			 */
+			void Reset()
+			{
+				this->lastUnwrapped = 0;
+				this->lastValue.reset();
+			}
+
+		private:
+			int64_t lastUnwrapped{ 0 };
+			std::optional<UnwrappedSequenceNumber<T>> lastValue;
+		};
+
+	public:
+		/**
+		 * Returns a new sequence number based on `value`, and adding `delta`
+		 * (which may be negative).
+		 */
+		static UnwrappedSequenceNumber<T> AddTo(UnwrappedSequenceNumber<T> value, int64_t delta)
+		{
+			return UnwrappedSequenceNumber<T>(value.value + delta);
+		}
+
+		/**
+		 * Returns the absolute difference between `lhs` and `rhs`.
+		 */
+		static T Difference(UnwrappedSequenceNumber<T> lhs, UnwrappedSequenceNumber<T> rhs)
+		{
+			return (lhs.value > rhs.value) ? (lhs.value - rhs.value) : (rhs.value - lhs.value);
+		}
+
+	private:
+		static constexpr auto ValueLimit = static_cast<int64_t>(1) << std::numeric_limits<T>::digits;
+
+	public:
+		explicit UnwrappedSequenceNumber(int64_t value) : value(value)
+		{
+		}
+
+	public:
+		/**
+		 * Returns the wrapped value this type represents.
+		 */
+		T Wrap() const
+		{
+			return static_cast<T>(this->value % UnwrappedSequenceNumber::ValueLimit);
+		}
+
+		bool operator==(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value == other.value;
+		}
+
+		bool operator!=(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value != other.value;
+		}
+
+		bool operator<(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value < other.value;
+		}
+
+		bool operator>(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value > other.value;
+		}
+
+		bool operator>=(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value >= other.value;
+		}
+
+		bool operator<=(const UnwrappedSequenceNumber<T>& other) const
+		{
+			return this->value <= other.value;
+		}
+
+		// Const accessors for underlying value.
+
+		constexpr const int64_t* operator->() const
+		{
+			return std::addressof(this->value);
+		}
+
+		constexpr const int64_t& operator*() const&
+		{
+			return this->value;
+		}
+
+		constexpr const int64_t&& operator*() const&&
+		{
+			return std::move(this->value);
+		}
+
+		constexpr const int64_t& GetValue() const&
+		{
+			return this->value;
+		}
+
+		constexpr const int64_t&& GetValue() const&&
+		{
+			return std::move(this->value);
+		}
+
+		constexpr explicit operator const int64_t&() const&
+		{
+			return this->value;
+		}
+
+		/**
+		 * Increments the value.
+		 */
+		void Increment()
+		{
+			++this->value;
+		}
+
+		/**
+		 * Returns the next value relative to this sequence number.
+		 */
+		UnwrappedSequenceNumber<T> GetNextValue() const
+		{
+			return UnwrappedSequenceNumber<T>(this->value + 1);
+		}
+
+	private:
+		int64_t value{ 0 };
+	};
+
+	/**
+	 * For logging purposes in Catch2 tests.
+	 */
+	template<typename T>
+	inline std::ostream& operator<<(std::ostream& os, const UnwrappedSequenceNumber<T>& s)
+	{
+		return os << "{T:" << typeid(T).name() << ", wrapped:" << s.Wrap();
+	}
+
+	template<>
+	inline std::ostream& operator<<(std::ostream& os, const UnwrappedSequenceNumber<uint8_t>& s)
+	{
+		return os << "{T:uint8_t, wrapped:" << s.Wrap() << "}";
+	}
+
+	template<>
+	inline std::ostream& operator<<(std::ostream& os, const UnwrappedSequenceNumber<uint16_t>& s)
+	{
+		return os << "{T:uint16_t, wrapped:" << s.Wrap() << "}";
+	}
+
+	template<>
+	inline std::ostream& operator<<(std::ostream& os, const UnwrappedSequenceNumber<uint32_t>& s)
+	{
+		return os << "{T:uint32_t, wrapped:" << s.Wrap() << "}";
+	}
+} // namespace Utils
+
+#endif

package/worker/include/Utils.hpp

@@ -212,6 +212,12 @@ namespace Utils
 			return (size + 3) & ~static_cast<T>(0x03);
 		}
 
+		template<typename T>
+		typename std::enable_if<std::is_unsigned<T>::value, T>::type static PadDownTo4Bytes(T size)
+		{
+			return size & ~static_cast<T>(0x03);
+		}
+
 		template<typename T>
 		typename std::enable_if<std::is_unsigned<T>::value, T>::type static PadTo8Bytes(T size)
 		{
@@ -259,10 +265,10 @@ namespace Utils
 		static void WriteRandomBytes(uint8_t* buffer, size_t len);
 
 	private:
-		thread_local static std::mt19937_64 rng;
-		thread_local static EVP_MAC* mac;
-		thread_local static EVP_MAC_CTX* hmacSha1Ctx;
-		thread_local static uint8_t hmacSha1Buffer[];
+		static thread_local std::mt19937_64 rng;
+		static thread_local EVP_MAC* mac;
+		static thread_local EVP_MAC_CTX* hmacSha1Ctx;
+		static thread_local uint8_t hmacSha1Buffer[];
 		static const uint32_t Crc32Table[256];
 		static const uint32_t Crc32cTable[256];
 	};