mediasoup 3.19.21 → 3.20.0

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

@@ -1,274 +0,0 @@
-#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/SctpAssociation.hpp

@@ -1,147 +0,0 @@
-#ifndef MS_RTC_OLD_SCTP_ASSOCIATION_HPP
-#define MS_RTC_OLD_SCTP_ASSOCIATION_HPP
-
-#include "common.hpp"
-#include "Utils.hpp"
-#include "RTC/DataConsumer.hpp"
-#include "RTC/DataProducer.hpp"
-#include <usrsctp.h>
-
-namespace RTC
-{
-	class SctpAssociation
-	{
-	public:
-		enum class SctpState : uint8_t
-		{
-			NEW = 1,
-			CONNECTING,
-			CONNECTED,
-			FAILED,
-			CLOSED
-		};
-
-	private:
-		enum class StreamDirection : uint8_t
-		{
-			INCOMING = 1,
-			OUTGOING
-		};
-
-	protected:
-		using onQueuedCallback = const std::function<void(bool queued, bool sctpSendBufferFull)>;
-
-	public:
-		class Listener
-		{
-		public:
-			virtual ~Listener() = default;
-
-		public:
-			virtual void OnSctpAssociationConnecting(RTC::SctpAssociation* sctpAssociation) = 0;
-			virtual void OnSctpAssociationConnected(RTC::SctpAssociation* sctpAssociation)  = 0;
-			virtual void OnSctpAssociationFailed(RTC::SctpAssociation* sctpAssociation)     = 0;
-			virtual void OnSctpAssociationClosed(RTC::SctpAssociation* sctpAssociation)     = 0;
-			virtual void OnSctpAssociationSendData(
-			  RTC::SctpAssociation* sctpAssociation, const uint8_t* data, size_t len) = 0;
-			virtual void OnSctpAssociationMessageReceived(
-			  RTC::SctpAssociation* sctpAssociation,
-			  uint16_t streamId,
-			  const uint8_t* msg,
-			  size_t len,
-			  uint32_t ppid) = 0;
-			virtual void OnSctpAssociationBufferedAmount(
-			  RTC::SctpAssociation* sctpAssociation, uint32_t len) = 0;
-		};
-
-	public:
-		static bool IsSctp(const uint8_t* data, size_t len)
-		{
-			// clang-format off
-			return (
-				(len >= 12) &&
-				// Must have Source Port Number and Destination Port Number set to 5000 (hack).
-				(Utils::Byte::Get2Bytes(data, 0) == 5000) &&
-				(Utils::Byte::Get2Bytes(data, 2) == 5000)
-			);
-			// clang-format on
-		}
-
-	public:
-		SctpAssociation(
-		  Listener* listener,
-		  uint16_t os,
-		  uint16_t mis,
-		  size_t maxSctpMessageSize,
-		  size_t sctpSendBufferSize,
-		  bool isDataChannel);
-		~SctpAssociation();
-
-	public:
-		flatbuffers::Offset<FBS::SctpParameters::SctpParameters> FillBuffer(
-		  flatbuffers::FlatBufferBuilder& builder) const;
-		void TransportConnected();
-		void TransportDisconnected();
-		SctpState GetState() const
-		{
-			return this->state;
-		}
-		size_t GetSctpBufferedAmount() const
-		{
-			return this->sctpBufferedAmount;
-		}
-		void ProcessSctpData(const uint8_t* data, size_t len);
-		void SendSctpMessage(
-		  RTC::DataConsumer* dataConsumer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
-		  onQueuedCallback* cb = nullptr);
-		void HandleDataProducer(RTC::DataProducer* dataProducer);
-		void HandleDataConsumer(RTC::DataConsumer* dataConsumer);
-		void DataProducerClosed(RTC::DataProducer* dataProducer);
-		void DataConsumerClosed(RTC::DataConsumer* dataConsumer);
-
-	private:
-		void MayConnect();
-		void ResetSctpStream(uint16_t streamId, StreamDirection direction) const;
-		void AddOutgoingStreams(bool force = false);
-
-		/* Callbacks fired by usrsctp events. */
-	public:
-		void OnUsrSctpSendSctpData(void* buffer, size_t len);
-		void OnUsrSctpReceiveSctpData(
-		  uint16_t streamId, uint16_t ssn, uint32_t ppid, int flags, const uint8_t* data, size_t len);
-		void OnUsrSctpReceiveSctpNotification(union sctp_notification* notification, size_t len);
-		void OnUsrSctpSentData(uint32_t freeBuffer);
-
-	public:
-		uintptr_t id{ 0u };
-
-	private:
-		// Passed by argument.
-		Listener* listener{ nullptr };
-		uint16_t os{ 1024u };
-		uint16_t mis{ 1024u };
-		size_t maxSctpMessageSize{ 262144u };
-		size_t sctpSendBufferSize{ 262144u };
-		size_t sctpBufferedAmount{ 0u };
-		bool isDataChannel{ false };
-		// Allocated by this.
-		uint8_t* messageBuffer{ nullptr };
-		// Others.
-		SctpState state{ SctpState::NEW };
-		struct socket* socket{ nullptr };
-		uint16_t desiredOs{ 0u };
-		size_t messageBufferLen{ 0u };
-		bool transportConnected{ false };
-		// Whether at least one SCTP stream (AKA DataProducer or DataConsumer) has
-		// already been created, no matter it's still alive.
-		bool firstStreamCreated{ false };
-		// Whether we have received STCP data from the remote peer.
-		bool sctpDataReceived{ false };
-		uint16_t lastSsnReceived{ 0u }; // Valid for us since no SCTP I-DATA support.
-	};
-} // namespace RTC
-
-#endif

package/worker/include/RTC/Shared.hpp

@@ -1,23 +0,0 @@
-#ifndef MS_RTC_SHARED_HPP
-#define MS_RTC_SHARED_HPP
-
-#include "ChannelMessageRegistrator.hpp"
-#include "Channel/ChannelNotifier.hpp"
-
-namespace RTC
-{
-	class Shared
-	{
-	public:
-		explicit Shared(
-		  ChannelMessageRegistrator* channelMessageRegistrator,
-		  Channel::ChannelNotifier* channelNotifier);
-		~Shared();
-
-	public:
-		ChannelMessageRegistrator* channelMessageRegistrator{ nullptr };
-		Channel::ChannelNotifier* channelNotifier{ nullptr };
-	};
-} // namespace RTC
-
-#endif

package/worker/src/ChannelMessageRegistrator.cpp

@@ -1,119 +0,0 @@
-#define MS_CLASS "ChannelMessageRegistrator"
-// #define MS_LOG_DEV_LEVEL 3
-
-#include "ChannelMessageRegistrator.hpp"
-#include "Logger.hpp"
-#include "MediaSoupErrors.hpp"
-
-ChannelMessageRegistrator::ChannelMessageRegistrator()
-{
-	MS_TRACE();
-}
-
-ChannelMessageRegistrator::~ChannelMessageRegistrator()
-{
-	MS_TRACE();
-
-	this->mapChannelRequestHandlers.clear();
-	this->mapChannelNotificationHandlers.clear();
-}
-
-flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> ChannelMessageRegistrator::FillBuffer(
-  flatbuffers::FlatBufferBuilder& builder)
-{
-	// Add channelRequestHandlerIds.
-	std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
-	for (const auto& kv : this->mapChannelRequestHandlers)
-	{
-		const auto& handlerId = kv.first;
-
-		channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
-	}
-
-	// Add channelNotificationHandlerIds.
-	std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
-	for (const auto& kv : this->mapChannelNotificationHandlers)
-	{
-		const auto& handlerId = kv.first;
-
-		channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
-	}
-
-	return FBS::Worker::CreateChannelMessageHandlersDirect(
-	  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
-}
-
-void ChannelMessageRegistrator::RegisterHandler(
-  const std::string& id,
-  Channel::ChannelSocket::RequestHandler* channelRequestHandler,
-  Channel::ChannelSocket::NotificationHandler* channelNotificationHandler)
-{
-	MS_TRACE();
-
-	if (channelRequestHandler != nullptr)
-	{
-		if (this->mapChannelRequestHandlers.find(id) != this->mapChannelRequestHandlers.end())
-		{
-			MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
-		}
-
-		this->mapChannelRequestHandlers[id] = channelRequestHandler;
-	}
-
-	if (channelNotificationHandler != nullptr)
-	{
-		if (this->mapChannelNotificationHandlers.find(id) != this->mapChannelNotificationHandlers.end())
-		{
-			if (channelRequestHandler != nullptr)
-			{
-				this->mapChannelRequestHandlers.erase(id);
-			}
-
-			MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
-		}
-
-		this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
-	}
-}
-
-void ChannelMessageRegistrator::UnregisterHandler(const std::string& id)
-{
-	MS_TRACE();
-
-	this->mapChannelRequestHandlers.erase(id);
-	this->mapChannelNotificationHandlers.erase(id);
-}
-
-Channel::ChannelSocket::RequestHandler* ChannelMessageRegistrator::GetChannelRequestHandler(
-  const std::string& id)
-{
-	MS_TRACE();
-
-	auto it = this->mapChannelRequestHandlers.find(id);
-
-	if (it != this->mapChannelRequestHandlers.end())
-	{
-		return it->second;
-	}
-	else
-	{
-		return nullptr;
-	}
-}
-
-Channel::ChannelSocket::NotificationHandler* ChannelMessageRegistrator::GetChannelNotificationHandler(
-  const std::string& id)
-{
-	MS_TRACE();
-
-	auto it = this->mapChannelNotificationHandlers.find(id);
-
-	if (it != this->mapChannelNotificationHandlers.end())
-	{
-		return it->second;
-	}
-	else
-	{
-		return nullptr;
-	}
-}