mediasoup 3.19.19 → 3.19.21

package/worker/include/RTC/SCTP/common/UnwrappedSequenceNumber.hpp

@@ -0,0 +1,274 @@
+#ifndef MS_RTC_SCTP_UNWRAPPED_SEQUENCE_NUMBER_HPP
+#define MS_RTC_SCTP_UNWRAPPED_SEQUENCE_NUMBER_HPP
+
+#include "common.hpp"
+#include "Utils.hpp"
+#include <limits>
+#include <ostream>
+#include <typeinfo>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * 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 SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/packet/Chunk.hpp

@@ -279,7 +279,6 @@ namespace RTC
 			 * - MediaSoupError - If `BuildParameterInPlace()` or
 			 *   `BuildErrorCauseInPlace()` was called before and the caller didn't
 			 *   invoke `Consolidate()` on the returned Parameter or Error Cause yet.
-
 			 */
 			virtual void AddParameter(const Parameter* parameter) final;
 

package/worker/include/RTC/SCTP/packet/UserData.hpp

@@ -105,6 +105,7 @@ namespace RTC
 			 */
 			std::vector<uint8_t> ReleasePayload() &&
 			{
+				// NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
 				return std::move(this->payload);
 			}
 

package/worker/include/RTC/SCTP/packet/parameters/IncomingSsnResetRequestParameter.hpp

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "Utils.hpp"
 #include "RTC/SCTP/packet/Parameter.hpp"
+#include <vector>
 
 namespace RTC
 {
@@ -88,17 +89,9 @@ namespace RTC
 
 			void SetReconfigurationRequestSequenceNumber(uint32_t value);
 
-			uint16_t GetNumberOfStreams() const
-			{
-				return GetVariableLengthValueLength() / 2;
-			}
-
-			uint16_t GetStreamAt(uint16_t idx) const
-			{
-				return Utils::Byte::Get2Bytes(GetVariableLengthValuePointer(), (idx * 2));
-			}
+			std::vector<uint16_t> GetStreamIds() const;
 
-			void AddStream(uint16_t stream);
+			void AddStreamId(uint16_t streamId);
 
 		protected:
 			IncomingSsnResetRequestParameter* SoftClone(const uint8_t* buffer) const final;
@@ -111,6 +104,17 @@ namespace RTC
 			{
 				return IncomingSsnResetRequestParameter::IncomingSsnResetRequestParameterHeaderLength;
 			}
+
+		private:
+			uint16_t GetNumberOfStreams() const
+			{
+				return GetVariableLengthValueLength() / 2;
+			}
+
+			uint16_t GetStreamAt(uint16_t idx) const
+			{
+				return Utils::Byte::Get2Bytes(GetVariableLengthValuePointer(), (idx * 2));
+			}
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/packet/parameters/OutgoingSsnResetRequestParameter.hpp

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "Utils.hpp"
 #include "RTC/SCTP/packet/Parameter.hpp"
+#include <vector>
 
 namespace RTC
 {
@@ -106,17 +107,9 @@ namespace RTC
 
 			void SetSenderLastAssignedTsn(uint32_t value);
 
-			uint16_t GetNumberOfStreams() const
-			{
-				return GetVariableLengthValueLength() / 2;
-			}
-
-			uint16_t GetStreamAt(uint16_t idx) const
-			{
-				return Utils::Byte::Get2Bytes(GetVariableLengthValuePointer(), (idx * 2));
-			}
+			std::vector<uint16_t> GetStreamIds() const;
 
-			void AddStream(uint16_t stream);
+			void AddStreamId(uint16_t streamId);
 
 		protected:
 			OutgoingSsnResetRequestParameter* SoftClone(const uint8_t* buffer) const final;
@@ -129,6 +122,17 @@ namespace RTC
 			{
 				return OutgoingSsnResetRequestParameter::OutgoingSsnResetRequestParameterHeaderLength;
 			}
+
+		private:
+			uint16_t GetNumberOfStreams() const
+			{
+				return GetVariableLengthValueLength() / 2;
+			}
+
+			uint16_t GetStreamAt(uint16_t idx) const
+			{
+				return Utils::Byte::Get2Bytes(GetVariableLengthValuePointer(), (idx * 2));
+			}
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp

@@ -42,7 +42,7 @@ namespace RTC
 			enum class AlternateErrorDetectionMethod : uint32_t
 			{
 				NONE           = 0x0000,
-				SCTP_OVER_DTLS = 0x0001
+				SCTP_OVER_DTLS = 0x0001,
 			};
 
 		public:
@@ -96,7 +96,18 @@ namespace RTC
 
 			AlternateErrorDetectionMethod GetAlternateErrorDetectionMethod() const
 			{
-				return static_cast<AlternateErrorDetectionMethod>(Utils::Byte::Get4Bytes(GetBuffer(), 4));
+				const auto method = Utils::Byte::Get4Bytes(GetBuffer(), 4);
+
+				if (
+				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::NONE) ||
+				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::SCTP_OVER_DTLS))
+				{
+					return static_cast<AlternateErrorDetectionMethod>(method);
+				}
+				else
+				{
+					return AlternateErrorDetectionMethod::NONE;
+				}
 			}
 
 			void SetAlternateErrorDetectionMethod(AlternateErrorDetectionMethod alternateErrorDetectionMethod);

package/worker/include/RTC/SCTP/public/AssociationInterface.hpp

@@ -32,12 +32,18 @@ namespace RTC
 
 			virtual Types::AssociationState GetAssociationState() const = 0;
 
+			/**
+			 * May invoke `Connect()` but only if the parent transport is ready for
+			 * SCTP transmission (e.g. the WebRtcTransport has ICE and DTLS connected).
+			 */
+			virtual void MayConnect() = 0;
+
 			/**
 			 * Initiate the SCTP association with the remote peer. It sends an INIT
 			 * Chunk.
 			 *
 			 * @remarks
-			 * - The SCTP association must be in Closed state.
+			 * - The SCTP association must be in New state.
 			 */
 			virtual void Connect() = 0;
 

package/worker/include/RTC/SCTP/public/AssociationListener.hpp

@@ -143,6 +143,17 @@ namespace RTC
 			 */
 			virtual void OnAssociationTotalBufferedAmountLow() = 0;
 
+			/**
+			 * Called when the Association needs to know if the parent transport is
+			 * ready for SCTP traffic (e.g. whether the WebRtcTransport has ICE and
+			 * DTLS connected and at least a DataProducer or DataConsumer has been
+			 * created). Returned boolean indicates it.
+			 *
+			 * @remarks
+			 * - It is NOT allowed to call methods in Association within this callback.
+			 */
+			virtual bool OnAssociationIsTransportReadyForSctp() = 0;
+
 			/**
 			 * SCTP message lifecycle events.
 			 *

package/worker/include/RTC/SCTP/public/Message.hpp

@@ -71,6 +71,7 @@ namespace RTC
 			 */
 			std::vector<uint8_t> ReleasePayload() &&
 			{
+				// NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
 				return std::move(this->payload);
 			}
 

package/worker/include/RTC/SCTP/public/SctpOptions.hpp

@@ -17,12 +17,12 @@ namespace RTC
 			/**
 			 * Signaled source port.
 			 */
-			uint16_t sourcePort{ 0 };
+			uint16_t sourcePort{ 5000 };
 
 			/**
 			 * Signaled destination port.
 			 */
-			uint16_t destinationPort{ 0 };
+			uint16_t destinationPort{ 5000 };
 
 			/**
 			 * Announced maximum number of outbound streams (OS).
@@ -30,7 +30,7 @@ namespace RTC
 			 * @remarks
 			 * - We use maximum value by default.
 			 */
-			uint16_t maxOutboundStreams{ 65535 };
+			uint16_t announcedMaxOutboundStreams{ 65535 };
 
 			/**
 			 * Announced maximum number of inbound streams (MIS).
@@ -38,7 +38,7 @@ namespace RTC
 			 * @remarks
 			 * - We use maximum value by default.
 			 */
-			uint16_t maxInboundStreams{ 65535 };
+			uint16_t announcedMaxInboundStreams{ 65535 };
 
 			/**
 			 * Maximum size of an SCTP Packet. It doesn't include any overhead of

package/worker/include/RTC/SctpAssociation.hpp

@@ -1,5 +1,5 @@
-#ifndef MS_RTC_SCTP_ASSOCIATION_HPP
-#define MS_RTC_SCTP_ASSOCIATION_HPP
+#ifndef MS_RTC_OLD_SCTP_ASSOCIATION_HPP
+#define MS_RTC_OLD_SCTP_ASSOCIATION_HPP
 
 #include "common.hpp"
 #include "Utils.hpp"

package/worker/include/RTC/Transport.hpp

@@ -18,14 +18,12 @@
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RateCalculator.hpp"
 #include "RTC/RtpListener.hpp"
-#ifdef MS_SCTP_STACK
 #include "RTC/SCTP/public/AssociationInterface.hpp"
 #include "RTC/SCTP/public/AssociationListener.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
-#else
+// TODO: Remove once we only use built-in SCTP stack.
 #include "RTC/SctpAssociation.hpp"
-#endif
 #include "RTC/SctpListener.hpp"
 #include "RTC/Shared.hpp"
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
@@ -44,11 +42,9 @@ namespace RTC
 	                  public RTC::Consumer::Listener,
 	                  public RTC::DataProducer::Listener,
 	                  public RTC::DataConsumer::Listener,
-#ifdef MS_SCTP_STACK
 	                  public RTC::SCTP::AssociationListener,
-#else
+	                  // TODO: Remove once we only use built-in SCTP stack.
 	                  public RTC::SctpAssociation::Listener,
-#endif
 	                  public RTC::TransportCongestionControlClient::Listener,
 	                  public RTC::TransportCongestionControlServer::Listener,
 	                  public Channel::ChannelSocket::RequestHandler,
@@ -289,9 +285,10 @@ namespace RTC
 		  size_t len,
 		  uint32_t ppid,
 		  onQueuedCallback* cb = nullptr) override;
+		void OnDataConsumerNeedBufferedAmount(
+		  RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) override;
 		void OnDataConsumerDataProducerClosed(RTC::DataConsumer* dataConsumer) override;
 
-#ifdef MS_SCTP_STACK
 		/* Pure virtual methods inherited from RTC::SCTP::AssociationListener. */
 	public:
 		bool OnAssociationSendData(const uint8_t* data, size_t len) override;
@@ -308,9 +305,11 @@ namespace RTC
 		void OnAssociationInboundStreamsReset(std::span<const uint16_t> inboundStreamIds) override;
 		void OnAssociationStreamBufferedAmountLow(uint16_t streamId) override;
 		void OnAssociationTotalBufferedAmountLow() override;
+		bool OnAssociationIsTransportReadyForSctp() override;
 		// TODO: SCTP: Add OnAssociationLifecycleMessageXxxxxx() methods.
-#else
+
 		/* Pure virtual methods inherited from RTC::SctpAssociation::Listener. */
+		// TODO: Remove once we only use built-in SCTP stack.
 	public:
 		void OnSctpAssociationConnecting(RTC::SctpAssociation* sctpAssociation) override;
 		void OnSctpAssociationConnected(RTC::SctpAssociation* sctpAssociation) override;
@@ -326,7 +325,6 @@ namespace RTC
 		  uint32_t ppid) override;
 		void OnSctpAssociationBufferedAmount(
 		  RTC::SctpAssociation* sctpAssociation, uint32_t bufferedAmount) override;
-#endif
 
 		/* Pure virtual methods inherited from RTC::TransportCongestionControlClient::Listener. */
 	public:
@@ -364,11 +362,9 @@ namespace RTC
 		RTC::Shared* shared{ nullptr };
 		size_t maxMessageSize{ 262144u };
 		// Allocated by this.
-#ifdef MS_SCTP_STACK
 		std::unique_ptr<RTC::SCTP::AssociationInterface> sctpAssociation{ nullptr };
-#else
-		RTC::SctpAssociation* sctpAssociation{ nullptr };
-#endif
+		// TODO: Remove once we only use built-in SCTP stack.
+		RTC::SctpAssociation* oldSctpAssociation{ nullptr };
 
 	private:
 		// Passed by argument.

package/worker/include/Settings.hpp

@@ -39,7 +39,8 @@ public:
 		std::string dtlsCertificateFile;
 		std::string dtlsPrivateKeyFile;
 		std::string libwebrtcFieldTrials{ "WebRTC-Bwe-AlrLimitedBackoff/Enabled/" };
-		bool liburingDisabled{ false };
+		bool disableLiburing{ false };
+		bool useBuiltInSctpStack{ false };
 	};
 
 public: