mediasoup 3.19.22 → 3.20.0

package/worker/include/RTC/SCTP/tx/SendQueueInterface.hpp

@@ -0,0 +1,180 @@
+#ifndef MS_RTC_SCTP_SEND_QUEUE_INTERFACE_HPP
+#define MS_RTC_SCTP_SEND_QUEUE_INTERFACE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/UserData.hpp"
+#include "RTC/SCTP/public/SctpTypes.hpp"
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		class SendQueueInterface
+		{
+		public:
+			/**
+			 * Container for a data chunk that is produced by the send queue.
+			 */
+			struct DataToSend
+			{
+				DataToSend(uint32_t outgoingMessageId, UserData data)
+				  : outgoingMessageId(outgoingMessageId), data(std::move(data))
+				{
+				}
+
+				uint32_t outgoingMessageId;
+
+				/**
+				 * The data to send, including all parameters.
+				 */
+				UserData data;
+
+				/**
+				 * Partial reliability (RFC 3758).
+				 */
+				uint16_t maxRetransmissions{ Types::MaxRetransmitsNoLimit };
+
+				/**
+				 * Time when it expires.
+				 */
+				uint64_t expiresAtMs{ Types::ExpiresAtMsInfinite };
+
+				/**
+				 * Lifecycle. Set for the last fragment and `std::nullopt` for all
+				 * other fragments.
+				 */
+				std::optional<uint64_t> lifecycleId;
+			};
+
+		public:
+			virtual ~SendQueueInterface() = default;
+
+			/**
+			 * Configures the send queue to support interleaved message sending as
+			 * described in RFC 8260. Every send queue starts with this value set as
+			 * disabled, but can later change it when the capabilities of the
+			 * connection have been negotiated. This affects the behavior of the
+			 * `Produce()` method.
+			 */
+			virtual void EnableMessageInterleaving(bool enabled) = 0;
+
+			/**
+			 * Produce a chunk to be sent. `maxLength` refers to how many payload bytes
+			 * that may be produced, not including any headers.
+			 *
+			 * @todo
+			 * - As in dcsctp, this interface is obviously missing an "AddMessage()"
+			 *   method, but that is postponed a bit until the story around how to
+			 *   model message prioritization, which is important for any advanced
+			 *   stream scheduler, is further clarified.
+			 */
+			virtual std::optional<DataToSend> Produce(uint64_t nowMs, size_t maxLength) = 0;
+
+			/**
+			 * Discards a partially sent message identified by the parameters `streamId`
+			 * and `outgoingMessageId`. The `outgoingMessageId` comes from the returned
+			 * information when having called `Produce()`. A partially sent message
+			 * means that it has had at least one fragment of it returned when
+			 * `Produce()` was called prior to calling this method.
+			 *
+			 * This is used when a message has been found to be expired (by the partial
+			 * reliability extension), and the retransmission queue will signal the
+			 * receiver that any partially received message fragments should be
+			 * skipped. This means that any remaining fragments in the send queue must
+			 * be removed as well so that they are not sent.
+			 *
+			 * This method returns true if this message had unsent fragments still in
+			 * the queue that were discarded, and false if there were no such
+			 * fragments.
+			 */
+			virtual bool Discard(uint16_t streamId, uint32_t outgoingMessageId) = 0;
+
+			/**
+			 * Prepares the stream to be reset. This is used to close a SCTP stream
+			 * and will be signaled to the other side.
+			 *
+			 * Concretely, it discards all whole (not partly sent) messages in the
+			 * given stream and pauses that stream so that future added messages are
+			 * not produced until resumed.
+			 *
+			 * This method can be called multiple times to add more streams to be
+			 * reset, and paused while they are resetting. This is the first part of
+			 * the two-phase commit protocol to reset streams, where the caller
+			 * completes the procedure by either calling `CommitResetStreams()` or
+			 * `RollbackResetStreams()`.
+			 *
+			 * @todo
+			 * - As in dcsctp, investigate if it really should discard any message at
+			 *   all. RFC 8831 only mentions that "RFC 6525 also guarantees that all
+			 *   the messages are delivered (or abandoned) before the stream is reset".
+			 */
+			virtual void PrepareResetStream(uint16_t streamId) = 0;
+
+			/**
+			 * Indicates if there are any streams that are ready to be reset.
+			 */
+			virtual bool HasStreamsReadyToBeReset() const = 0;
+
+			/**
+			 * Returns a list of streams that are ready to be included in an outgoing
+			 * stream reset request. Any streams that are returned here must be
+			 * included in an outgoing stream reset request, and there must not be
+			 * concurrent requests.
+			 */
+			virtual std::vector<uint16_t> GetStreamsReadyToBeReset() = 0;
+
+			/**
+			 * Called to commit to reset the streams returned by
+			 * `GetStreamsReadyToBeReset()`. It will reset the stream sequence numbers
+			 * (SSNs) and message identifiers (MIDs) and resume the paused streams.
+			 */
+			virtual void CommitResetStreams() = 0;
+
+			/**
+			 * Called to abort the resetting of streams returned by
+			 * `GetStreamsReadyToBeReset()`. Will resume the paused streams without
+			 * resetting the stream sequence numbers (SSNs) or message identifiers
+			 * (MIDs). Note that the non-partial messages that were discarded when
+			 * calling `PrepareResetStreams()` will not be recovered, to better match
+			 * the intention from the sender to "close the channel".
+			 */
+			virtual void RollbackResetStreams() = 0;
+
+			/**
+			 * Resets all message identifier counters (MID, SSN) and makes all
+			 * partially messages be ready to be re-sent in full. This is used when
+			 * the peer has been detected to have restarted and is used to try to
+			 * minimize the amount of data loss. However, data loss cannot be
+			 * completely guaranteed when a peer restarts.
+			 */
+			virtual void Reset() = 0;
+
+			/**
+			 * Returns the amount of buffered data. This doesn't include packets that
+			 * are e.g. inflight.
+			 */
+			virtual size_t GetStreamBufferedAmount(uint16_t streamId) const = 0;
+
+			/**
+			 * Returns the total amount of buffer data, for all streams.
+			 */
+			virtual size_t GetTotalBufferedAmount() const = 0;
+
+			/**
+			 * Returns the limit for the `OnAssociationStreamBufferedAmountLow()`
+			 * event. Default value is 0.
+			 */
+			virtual size_t GetStreamBufferedAmountLowThreshold(uint16_t streamId) const = 0;
+
+			/**
+			 * Sets a limit for the `OnAssociationStreamBufferedAmountLow()` event.
+			 * @param streamId [description]
+			 * @param bytes    [description]
+			 */
+			virtual void SetStreamBufferedAmountLowThreshold(uint16_t streamId, size_t bytes) = 0;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/tx/StreamScheduler.hpp

@@ -0,0 +1,235 @@
+#ifndef MS_RTC_SCTP_STREAM_SCHEDULER_HPP
+#define MS_RTC_SCTP_STREAM_SCHEDULER_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/chunks/IDataChunk.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
+#include <set>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * A parameterized stream scheduler. Currently, it implements the round robin
+		 *  scheduling algorithm using virtual finish time. It is to be used as a
+		 *  part of a send queue and will track all active streams (streams that have
+		 *  any data that can be sent).
+		 *
+		 * The stream scheduler works with the concept of associating active streams
+		 * with a "virtual finish time", which is the time when a stream is allowed
+		 * to produce data. Streams are ordered by their virtual finish time, and
+		 * the "current virtual time" will advance to the next following virtual
+		 * finish time whenever a chunk is to be produced.
+		 *
+		 * In the round robin scheduling algorithm, a stream's virtual finish time
+		 * will just increment by one (1) after having produced a chunk, which
+		 * results in a round-robin scheduling.
+		 *
+		 * In WFQ scheduling algorithm, a stream's virtual finish time will be
+		 * defined as the number of bytes in the next fragment to be sent, multiplied
+		 * by theinverse of the stream's priority, meaning that a high priority - or
+		 * a smaller fragment - results in a closer virtual finish time, compared to
+		 * a stream with either a lower priority or a larger fragment to be sent.
+		 *
+		 * @remarks
+		 * - When message interleaving is enabled, the WFQ (Weighted Fair Queueing)
+		 * 	 scheduling algorithm will be used. And when it's not, round-robin
+		 * 	 scheduling will be used instead.
+		 */
+		class StreamScheduler
+		{
+		public:
+			class StreamProducer
+			{
+			public:
+				virtual ~StreamProducer() = default;
+
+			public:
+				/**
+				 * Produces a fragment of data to send. The current wall time is specified
+				 * as `nowMs` and should be used to skip chunks with expired limited
+				 * lifetime. The parameter `maxLength` specifies the maximum amount of
+				 * actual payload that may be returned. If these constraints prevents the
+				 * stream from sending some data, `std::nullopt` should be returned.
+				 */
+				virtual std::optional<SendQueueInterface::DataToSend> Produce(
+				  uint64_t nowMs, size_t maxLength) = 0;
+
+				/**
+				 * Returns the number of payload bytes that is scheduled to be sent in the
+				 * next enqueued message, or zero if there are no enqueued messages or if
+				 * the stream has been actively paused.
+				 */
+				virtual size_t GetBytesToSendInNextMessage() const = 0;
+			};
+
+		public:
+			class Stream
+			{
+			private:
+				friend class StreamScheduler;
+
+			private:
+				Stream(StreamScheduler* parent, StreamProducer* producer, uint16_t streamId, uint16_t priority)
+				  : parent(*parent),
+				    producer(*producer),
+				    streamId(streamId),
+				    priority(priority),
+				    inverseWeight(1.0 / std::max(static_cast<double>(priority), 1e-6))
+				{
+				}
+
+			public:
+				uint16_t GetStreamId() const
+				{
+					return this->streamId;
+				}
+
+				uint16_t GetPriority() const
+				{
+					return this->priority;
+				}
+
+				void SetPriority(uint16_t priority);
+
+				/**
+				 * Will activate the stream if it has any data to send. That is, if the
+				 * callback to `GetBytesToSendInNextMessage()` returns non-zero. If the
+				 * callback returns zero, the stream will not be made active.
+				 */
+				void MayMakeActive();
+
+				/**
+				 * Will remove the stream from the list of active streams, and will not
+				 * try to produce data from it. To make it active again, call
+				 * `MayMakeActive()`.
+				 */
+				void MakeInactive();
+
+				/**
+				 * Make the scheduler move to another message, or another stream. This
+				 * is used to abort the scheduler from continuing producing fragments
+				 * for the current message in case it's deleted.
+				 */
+				void ForceReschedule()
+				{
+					this->parent.ForceReschedule();
+				}
+
+			private:
+				/**
+				 * Produces a message from this stream. This will only be called on
+				 * streams that have data.
+				 */
+				std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+
+				void MakeActive(size_t bytesToSendNext);
+
+				void ForceMarkInactive();
+
+				double GetCurrentTime() const
+				{
+					return this->currentVirtualTime;
+				}
+
+				double GetNextFinishTime() const
+				{
+					return this->nextFinishTime;
+				}
+
+				size_t GetBytesToSendInNextMessage() const
+				{
+					return this->producer.GetBytesToSendInNextMessage();
+				}
+
+				double CalculateFinishTime(size_t bytesToSendNext) const;
+
+			private:
+				StreamScheduler& parent;
+				StreamProducer& producer;
+				const uint16_t streamId;
+				uint16_t priority;
+				double inverseWeight;
+				// This outgoing stream's "current" virtual time.
+				double currentVirtualTime{ 0.0 };
+				double nextFinishTime{ 0.0 };
+			};
+
+		private:
+			struct ActiveStreamComparator
+			{
+				// Ordered by virtual finish time (primary), stream-id (secondary).
+				bool operator()(Stream* a, Stream* b) const
+				{
+					const double aVft = a->GetNextFinishTime();
+					const double bVft = b->GetNextFinishTime();
+
+					if (aVft == bVft)
+					{
+						return a->GetStreamId() < b->GetStreamId();
+					}
+
+					return aVft < bVft;
+				}
+			};
+
+		public:
+			explicit StreamScheduler(size_t mtu)
+			  : maxPayloadBytes(mtu - Packet::CommonHeaderLength - IDataChunk::IDataChunkHeaderLength)
+			{
+			}
+
+		public:
+			std::unique_ptr<Stream> CreateStream(StreamProducer* producer, uint16_t streamId, uint16_t priority)
+			{
+				return std::unique_ptr<Stream>(new Stream(this, producer, streamId, priority));
+			}
+
+			void EnableMessageInterleaving(bool enabled)
+			{
+				this->enableMessageInterleaving = enabled;
+			}
+
+			/**
+			 * Makes the scheduler stop producing message from the current stream and
+			 * re-evaluates which stream to produce from.
+			 */
+			void ForceReschedule()
+			{
+				this->currentlySendingAMessage = false;
+			}
+
+			/**
+			 * Produces a fragment of data to send. The current wall time is specified
+			 * as `nowMs` and will be used to skip chunks with expired limited
+			 * lifetime. The parameter `maxLength` specifies the maximum amount of
+			 * actual payload that may be returned. If no data can be produced,
+			 * `std::nullopt` is returned.
+			 */
+			std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+
+			std::set<uint16_t> GetActiveStreamsForTesting() const;
+
+		private:
+			void AssertIsConsistent() const;
+
+		private:
+			const size_t maxPayloadBytes;
+			// The current virtual time, as defined in the WFQ algorithm.
+			double virtualTime{ 0.0 };
+			// The current stream to send chunks from.
+			Stream* currentStream{ nullptr };
+			bool enableMessageInterleaving{ false };
+			// Indicates if the streams is currently sending a message, and should
+			// then (if message interleaving is not enabled) continue sending from
+			// this stream until that message has been sent in full.
+			bool currentlySendingAMessage{ false };
+			// The currently active streams, ordered by virtual finish time.
+			std::set<Stream*, ActiveStreamComparator> activeStreams;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SenderBandwidthEstimator.hpp

@@ -6,6 +6,7 @@
 #include "RTC/RateCalculator.hpp"
 #include "RTC/SeqManager.hpp"
 #include "RTC/TrendCalculator.hpp"
+#include "SharedInterface.hpp"
 #include <map>
 
 namespace RTC
@@ -82,7 +83,9 @@ namespace RTC
 
 	public:
 		SenderBandwidthEstimator(
-		  RTC::SenderBandwidthEstimator::Listener* listener, uint32_t initialAvailableBitrate);
+		  RTC::SenderBandwidthEstimator::Listener* listener,
+		  SharedInterface* shared,
+		  uint32_t initialAvailableBitrate);
 		virtual ~SenderBandwidthEstimator();
 
 	public:
@@ -98,6 +101,7 @@ namespace RTC
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Others.
 		uint32_t initialAvailableBitrate{ 0u };
 		uint32_t availableBitrate{ 0u };

package/worker/include/RTC/Serializable.hpp

@@ -213,11 +213,11 @@ namespace RTC
 
 	private:
 		// Buffer holding the Serializable content.
-		uint8_t* buffer{ nullptr };
+		uint8_t* buffer;
 		// Length of the buffer. This is the maximum length the Serializable can
 		// take.
-		size_t bufferLength{ 0u };
-		// Serializable exact length (includes padding bytes).
+		size_t bufferLength;
+		// Serializable current exact length (includes padding bytes).
 		size_t length{ 0u };
 		// Event listener invoked when the current buffer is released (no longer
 		// used by this Serializable)-

package/worker/include/RTC/TcpServer.hpp

@@ -2,10 +2,10 @@
 #define MS_RTC_TCP_SERVER_HPP
 
 #include "common.hpp"
-#include "RTC/TcpConnection.hpp"
-#include "RTC/Transport.hpp"
 #include "handles/TcpConnectionHandle.hpp"
 #include "handles/TcpServerHandle.hpp"
+#include "RTC/TcpConnection.hpp"
+#include "RTC/Transport.hpp"
 #include <string>
 
 namespace RTC