mediasoup 3.19.22 → 3.20.0

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

@@ -2,16 +2,16 @@
 #define MS_RTC_SCTP_RETRANSMISSION_QUEUE_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/common/UnwrappedSequenceNumber.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
 #include "RTC/SCTP/packet/UserData.hpp"
 #include "RTC/SCTP/packet/chunks/ForwardTsnChunk.hpp"
 #include "RTC/SCTP/packet/chunks/IForwardTsnChunk.hpp"
 #include "RTC/SCTP/packet/chunks/SackChunk.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/tx/OutstandingData.hpp"
-#include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
 #include <vector>
 
 namespace RTC
@@ -41,9 +41,6 @@ namespace RTC
 				virtual void OnRetransmissionQueueClearRetransmissionCounter() = 0;
 			};
 
-		public:
-			using UnwrappedTsn = UnwrappedSequenceNumber<uint32_t>;
-
 		private:
 			enum class CongestionAlgorithmPhase : uint8_t
 			{
@@ -57,21 +54,19 @@ namespace RTC
 			 * `localInitialTsn` as the first TSN to use for sent fragments. It will
 			 * poll data from `sendQueue`. When SACKs are received, it will estimate
 			 * the RTT and call `listener->OnRetransmissionQueueNewRttMs()`. When an
-			 * outstanding Chunk has been acked, it will call
+			 * outstanding chunk has been acked, it will call
 			 * `listener->OnRetransmissionQueueClearRetransmissionCounter() and will
 			 * also use `t3RtxTimer`, which is the SCTP retransmission timer to manage
 			 * retransmissions.
 			 */
 			RetransmissionQueue(
 			  Listener* listener,
-			  AssociationListener& associationListener,
+			  AssociationListenerInterface& associationListener,
 			  uint32_t localInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
-			  // TODO: SCTP: Implement
-			  // SendQueue& sendQueue,
+			  SendQueueInterface& sendQueue,
 			  BackoffTimerHandleInterface* t3RtxTimer,
 			  const SctpOptions& sctpOptions,
-			  // TODO: SCTP: I don't like these defaults (true and false), let's be explicit.
 			  bool supportsPartialReliability,
 			  bool useMessageInterleaving);
 
@@ -109,6 +104,19 @@ namespace RTC
 			std::vector<std::pair<uint32_t /*tsn*/, UserData>> GetChunksToSend(
 			  uint64_t nowMs, size_t maxLength);
 
+#ifdef MS_TEST
+			/**
+			 * Returns the internal state of all queued Chunks.
+			 *
+			 * @remarks
+			 * - Used in tests.
+			 */
+			std::vector<std::pair<uint32_t /*tsn*/, OutstandingData::State>> GetChunkStatesForTesting() const
+			{
+				return this->outstandingData.GetChunkStatesForTesting();
+			}
+#endif
+
 			/**
 			 * Returns the next TSN that will be allocated for sent DATA Chunks.
 			 */
@@ -119,7 +127,7 @@ namespace RTC
 
 			uint32_t GetLastAssignedTsn() const
 			{
-				return UnwrappedTsn::AddTo(this->outstandingData.GetNextTsn(), -1).Wrap();
+				return Types::UnwrappedTsn::AddTo(this->outstandingData.GetNextTsn(), -1).Wrap();
 			}
 
 			/**
@@ -181,24 +189,24 @@ namespace RTC
 			bool ShouldSendForwardTsn(uint64_t nowMs);
 
 			/**
-			 * Creates a FORWARD-TSN Chunk and adds it to the given Packet.
+			 * Adds a FORWARD-TSN Chunk to the given Packet and returns it.
 			 */
-			void CreateForwardTsn(Packet* packet) const
+			const ForwardTsnChunk* AddForwardTsn(Packet* packet) const
 			{
-				this->outstandingData.CreateForwardTsn(packet);
+				return this->outstandingData.AddForwardTsn(packet);
 			}
 
 			/**
-			 * Creates an I-FORWARD-TSN Chunk and adds it to the given Packet.
+			 * Adds an I-FORWARD-TSN Chunk to the given Packet and returns it.
 			 */
-			void CreateIForwardTsn(Packet* packet) const
+			const IForwardTsnChunk* AddIForwardTsn(Packet* packet) const
 			{
-				this->outstandingData.CreateIForwardTsn(packet);
+				return this->outstandingData.AddIForwardTsn(packet);
 			}
 
 			/**
-			 * @see SendQueue for a longer description of these methods related
-			 * to stream resetting.
+			 * @see SendQueueInterface for a longer description of these methods
+			 * related to stream resetting.
 			 */
 			void PrepareResetStream(uint16_t streamId);
 			bool HasStreamsReadyToBeReset() const;
@@ -206,19 +214,6 @@ namespace RTC
 			void CommitResetStreams();
 			void RollbackResetStreams();
 
-#ifdef MS_TEST
-			/**
-			 * Returns the internal state of all queued Chunks.
-			 *
-			 * @remarks
-			 * - This is only used in tests.
-			 */
-			std::vector<std::pair<uint32_t /*tsn*/, OutstandingData::State>> GetChunkStatesForTesting() const
-			{
-				return this->outstandingData.GetChunkStatesForTesting();
-			}
-#endif
-
 		private:
 			/**
 			 * Returns how large a chunk will be, serialized, carrying the data.
@@ -245,13 +240,13 @@ namespace RTC
 			 * When a SACK Chunk is received, this method will be called which may
 			 * call into the `RetransmissionTimeout` to update the RTO.
 			 */
-			void UpdateRttMs(uint64_t nowMs, UnwrappedTsn cumulativeTsnAck);
+			void UpdateRttMs(uint64_t nowMs, Types::UnwrappedTsn cumulativeTsnAck);
 
 			/**
 			 * If the congestion control is in "fast recovery mode", this may be
 			 * exited now.
 			 */
-			void MayExitFastRecovery(UnwrappedTsn cumulativeTsnAck);
+			void MayExitFastRecovery(Types::UnwrappedTsn cumulativeTsnAck);
 
 			/**
 			 * If Chunks have been ACKed, stop the retransmission timer.
@@ -260,7 +255,7 @@ namespace RTC
 			 * - This method is NOT defined in dcsctp! See bug report:
 			 *   https://issues.webrtc.org/issues/505751236
 			 */
-			void StopT3RtxTimerOnIncreasedCumulativeTsnAck(UnwrappedTsn cumulativeTsnAck);
+			void StopT3RtxTimerOnIncreasedCumulativeTsnAck(Types::UnwrappedTsn cumulativeTsnAck);
 
 			/**
 			 * Update the congestion control algorithm given as the cumulative ack TSN
@@ -272,7 +267,7 @@ namespace RTC
 			 * Update the congestion control algorithm, given as packet loss has been
 			 * detected, as reported in an incoming SACK Chunk.
 			 */
-			void HandlePacketLoss(UnwrappedTsn highestTsnAcked);
+			void HandlePacketLoss(Types::UnwrappedTsn highestTsnAcked);
 
 			/**
 			 * Update the view of the receiver window size.
@@ -296,7 +291,7 @@ namespace RTC
 
 		private:
 			Listener* listener;
-			AssociationListener& associationListener;
+			AssociationListenerInterface& associationListener;
 			const SctpOptions sctpOptions;
 			// If the peer supports RFC3758 "SCTP Partial Reliability Extension".
 			bool supportsPartialReliability;
@@ -305,7 +300,7 @@ namespace RTC
 			// The retransmission timer.
 			BackoffTimerHandleInterface* t3RtxTimer;
 			// Unwraps TSNs.
-			UnwrappedTsn::Unwrapper tsnUnwrapper;
+			Types::UnwrappedTsn::Unwrapper tsnUnwrapper;
 			// Congestion Window. Number of bytes that may be in-flight (sent, not
 			// acked).
 			size_t cwnd;
@@ -320,15 +315,13 @@ namespace RTC
 			uint64_t rtxBytesCount{ 0 };
 			// If set, fast recovery is enabled until this TSN has been cumulative
 			// acked.
-			std::optional<UnwrappedTsn> fastRecoveryExitTsn{ std::nullopt };
+			std::optional<Types::UnwrappedTsn> fastRecoveryExitTsn{ std::nullopt };
 			// The send queue.
-			// TODO: SCTP: Implement.
-			// SendQueue& sendQueue;
+			SendQueueInterface& sendQueue;
 			// All the outstanding data Chunks that are in-flight and that have not
 			// been cumulative acked. Note that it also contains chunks that have been
 			// acked in gap-ack-blocks.
 			OutstandingData outstandingData;
-			// TODO: SCTP.
 		};
 	} // namespace SCTP
 } // namespace RTC

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

@@ -52,13 +52,13 @@ namespace RTC
 			}
 
 		private:
-			uint64_t minRtoMs{ 0 };
-			uint64_t maxRtoMs{ 0 };
-			uint64_t maxRttMs{ 0 };
-			uint64_t minRttVarianceMs{ 0 };
-			double srttMs{ 0 };
+			uint64_t minRtoMs;
+			uint64_t maxRtoMs;
+			uint64_t maxRttMs;
+			uint64_t minRttVarianceMs;
+			double srttMs;
+			double rtoMs;
 			double rttVarMs{ 0 };
-			double rtoMs{ 0 };
 			bool firstMeasurement{ false };
 		};
 	} // namespace SCTP

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

@@ -0,0 +1,356 @@
+#ifndef MS_RTC_SCTP_ROUND_ROBIN_SEND_QUEUE_HPP
+#define MS_RTC_SCTP_ROUND_ROBIN_SEND_QUEUE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include "RTC/SCTP/public/Message.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
+#include "RTC/SCTP/tx/StreamScheduler.hpp"
+#include <deque>
+#include <map>
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * The Round Robin send queue holds all messages that the client wants to
+		 * send, but that haven't yet been split into chunks and fully sent on the
+		 * wire.
+		 *
+		 * As defined in https://datatracker.ietf.org/doc/html/rfc8260#section-3.2,
+		 * it will cycle to send messages from different streams. It will send all
+		 * fragments from one message before continuing with a different message on
+		 * possibly a different stream, until support for message interleaving has
+		 * been implemented.
+		 *
+		 * As messages can be (requested to be) sent before the connection is
+		 * properly established, this send queue is always present - even for closed
+		 * connections.
+		 *
+		 * The send queue may trigger callbacks. `OnAssociationStreamBufferedAmountLow()`
+		 * and `OnAssociationTotalBufferedAmountLow()` will be triggered as defined in
+		 * their documentation. `OnAssociationLifecycleMessageExpired()` with
+		 * `maybeDelivered=false` and `OnAssociationLifecycleMessageEnd()` will be
+		 * triggered when messages have been expired, abandoned or discarded from the
+		 * send queue. If a message is fully produced, meaning that the last fragment
+		 * has been produced, the responsibility to send lifecycle events is then
+		 * transferred to the retransmission queue, which is the one asking to
+		 * produce the message.
+		 */
+		class RoundRobinSendQueue : public SendQueueInterface
+		{
+		private:
+			struct MessageAttributes
+			{
+				bool isUnordered;
+				uint16_t maxRetransmissions;
+				uint64_t expiresAtMs;
+				std::optional<uint64_t> lifecycleId;
+			};
+
+		private:
+			/**
+			 * Represents a value and a "low threshold" that when the value reaches or
+			 * goes under the "low threshold", will trigger `onThresholdReached()`
+			 * callback.
+			 */
+			class ThresholdWatcher
+			{
+			public:
+				explicit ThresholdWatcher(std::function<void()> onThresholdReached)
+				  : onThresholdReached(std::move(onThresholdReached))
+				{
+				}
+
+				/**
+				 * Increases the value.
+				 */
+				void Increase(size_t bytes)
+				{
+					this->value += bytes;
+				}
+
+				/**
+				 * Decreases the value and triggers `onThresholdReached()` if it's at
+				 * or below `this->lowThreshold`.
+				 */
+				void Decrease(size_t bytes);
+
+				size_t GetValue() const
+				{
+					return this->value;
+				}
+
+				size_t GetLowThreshold() const
+				{
+					return this->lowThreshold;
+				}
+
+				void SetLowThreshold(size_t lowThreshold);
+
+			private:
+				const std::function<void()> onThresholdReached;
+				size_t value{ 0 };
+				size_t lowThreshold{ 0 };
+			};
+
+		private:
+			/**
+			 * Per-stream information.
+			 */
+			class OutgoingStream : public StreamScheduler::StreamProducer
+			{
+			public:
+				OutgoingStream(
+				  RoundRobinSendQueue* parent,
+				  StreamScheduler* scheduler,
+				  uint16_t streamId,
+				  uint16_t priority,
+				  std::function<void()> onBufferedAmountLow)
+				  : parent(*parent),
+				    schedulerStream(scheduler->CreateStream(this, streamId, priority)),
+				    bufferedAmountThresholdWatcher(std::move(onBufferedAmountLow))
+				{
+				}
+
+				uint16_t GetStreamId() const
+				{
+					return this->schedulerStream->GetStreamId();
+				}
+
+				/**
+				 * Enqueues a message to this stream.
+				 */
+				void AddMessage(Message message, MessageAttributes attributes);
+
+				// Implementing `StreamScheduler::StreamProducer`.
+
+				std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength) override;
+
+				size_t GetBytesToSendInNextMessage() const override;
+
+				const ThresholdWatcher& GetBufferedAmount() const
+				{
+					return bufferedAmountThresholdWatcher;
+				}
+
+				ThresholdWatcher& GetBufferedAmount()
+				{
+					return bufferedAmountThresholdWatcher;
+				}
+
+				/**
+				 * Discards a partially sent message, see `SendQueue::Discard()`.
+				 */
+				bool Discard(uint32_t outgoingMessageId);
+
+				/**
+				 * Pauses this stream, which is used before resetting it.
+				 */
+				void Pause();
+
+				/**
+				 * Resumes a paused stream.
+				 */
+				void Resume();
+
+				bool IsReadyToBeReset() const
+				{
+					return this->pauseState == PauseState::PAUSED;
+				}
+
+				bool IsResetting() const
+				{
+					return this->pauseState == PauseState::RESETTING;
+				}
+
+				void SetAsResetting();
+
+				/**
+				 * Resets this stream, meaning MIDs and SSNs are set to zero.
+				 */
+				void Reset();
+
+				/**
+				 * Indicates if this stream has a partially sent message in it.
+				 */
+				bool HasPartiallySentMessage() const;
+
+				uint16_t GetPriority() const
+				{
+					return this->schedulerStream->GetPriority();
+				}
+
+				void SetPriority(uint16_t priority)
+				{
+					this->schedulerStream->SetPriority(priority);
+				}
+
+			private:
+				/**
+				 * Streams are paused before they can be reset. To reset a stream, the
+				 * socket sends an outgoing stream reset command with the TSN of the last
+				 * fragment of the last message, so that receivers and senders can agree
+				 * on when it stopped. And if the send queue is in the middle of sending
+				 * a message, and without fragments not yet sent and without TSNs
+				 * allocated to them, it will keep sending data until that message has
+				 * ended.
+				 */
+				enum class PauseState : uint8_t
+				{
+					/**
+					 * The stream is not paused, and not scheduled to be reset.
+					 */
+					NOT_PAUSED,
+
+					/**
+					 * The stream has requested to be reset/paused but is still producing
+					 * fragments of a message that hasn't ended yet. When it does, it will
+					 * transition to the `PAUSED` state.
+					 */
+					PENDING,
+
+					/**
+					 * The stream is fully paused and can be reset.
+					 */
+					PAUSED,
+
+					/**
+					 * The stream has been added to an outgoing stream reset request and a
+					 * response from the peer hasn't been received yet.
+					 */
+					RESETTING,
+				};
+
+				// An enqueued message and metadata.
+				struct Item
+				{
+					explicit Item(uint32_t outgoingMessageId, Message msg, MessageAttributes attributes)
+					  : outgoingMessageId(outgoingMessageId),
+					    message(std::move(msg)),
+					    attributes(attributes),
+					    remainingLength(message.GetPayloadLength())
+					{
+					}
+
+					uint32_t outgoingMessageId;
+					Message message;
+					MessageAttributes attributes;
+					// The remaining payload (offset and length) to be sent, when it has
+					// been fragmented.
+					size_t remainingOffset{ 0 };
+					size_t remainingLength;
+					// If set, an allocated Message ID and SSN. Will be allocated when the
+					// first fragment is sent.
+					std::optional<uint32_t> mid{ std::nullopt };
+					std::optional<uint16_t> ssn{ std::nullopt };
+					// The current Fragment Sequence Number, incremented for each fragment.
+					uint32_t currentFsn{ 0 };
+				};
+
+				void HandleMessageExpired(OutgoingStream::Item& item);
+
+				void AssertIsConsistent() const;
+
+			private:
+				RoundRobinSendQueue& parent;
+				const std::unique_ptr<StreamScheduler::Stream> schedulerStream;
+				// The current amount of buffered data.
+				ThresholdWatcher bufferedAmountThresholdWatcher;
+				PauseState pauseState = PauseState::NOT_PAUSED;
+				// MIDs are different for unordered and ordered messages sent on a
+				// stream.
+				uint32_t nextUnorderedMid{ 0 };
+				uint32_t nextOrderedMid{ 0 };
+				uint16_t nextSsn{ 0 };
+				// Enqueued messages, and metadata.
+				std::deque<Item> items;
+			};
+
+		public:
+			RoundRobinSendQueue(
+			  AssociationListenerInterface& associationListener,
+			  size_t mtu,
+			  uint16_t defaultPriority,
+			  size_t totalBufferedAmountLowThreshold);
+
+			~RoundRobinSendQueue() override;
+
+		public:
+			/**
+			 * Indicates if the buffer is empty.
+			 */
+			bool IsEmpty() const
+			{
+				return GetTotalBufferedAmount() == 0;
+			}
+
+			/**
+			 * Adds the message to be sent using the `sendMessageOptions` provided.
+			 * The current time should be in `nowMs`. Note that it's the responsibility
+			 * of the caller to ensure that the buffer is not full (by calling
+			 * `IsFull()`) before adding messages to it.
+			 */
+			void AddMessage(
+			  uint64_t nowMs, Message message, const SendMessageOptions& sendMessageOptions = {});
+
+			uint16_t GetStreamPriority(uint16_t streamId) const;
+
+			void SetStreamPriority(uint16_t streamId, uint16_t priority);
+
+			// Methods implementing `SendQueueInterface`.
+		public:
+			void EnableMessageInterleaving(bool enabled) override
+			{
+				this->scheduler.EnableMessageInterleaving(enabled);
+			}
+
+			std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength) override;
+
+			bool Discard(uint16_t streamId, uint32_t outgoingMessageId) override;
+
+			void PrepareResetStream(uint16_t streamId) override;
+
+			bool HasStreamsReadyToBeReset() const override;
+
+			std::vector<uint16_t> GetStreamsReadyToBeReset() override;
+
+			void CommitResetStreams() override;
+
+			void RollbackResetStreams() override;
+
+			void Reset() override;
+
+			size_t GetStreamBufferedAmount(uint16_t streamId) const override;
+
+			size_t GetTotalBufferedAmount() const override
+			{
+				return this->totalBufferedAmountThresholdWatcher.GetValue();
+			}
+
+			size_t GetStreamBufferedAmountLowThreshold(uint16_t streamId) const override;
+
+			void SetStreamBufferedAmountLowThreshold(uint16_t streamId, size_t bytes) override;
+
+		private:
+			OutgoingStream& GetOrCreateStreamInfo(uint16_t streamId);
+
+			void AssertIsConsistent() const;
+
+		private:
+			AssociationListenerInterface& associationListener;
+			const uint16_t defaultPriority;
+			StreamScheduler scheduler;
+			// The total amount of buffer data, for all streams.
+			ThresholdWatcher totalBufferedAmountThresholdWatcher;
+			uint32_t currentOutgoingMessageId{ 0 };
+			// All streams, and messages added to those.
+			std::map<uint16_t, OutgoingStream> streams;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif