mediasoup 3.27.0 → 3.28.0

package/worker/include/RTC/RateCalculator.hpp

@@ -16,12 +16,25 @@ namespace RTC
 	 * and GetRate() are O(1) amortized.
 	 *
 	 * It is considered that the time source increases monotonically. Timestamps
-	 * going backwards are however tolerated (time comparisons are wrap safe):
-	 * data still within the window is added to the newest item, older data is
-	 * ignored, and nothing is ever expired ahead of time.
+	 * going backwards are however tolerated (time comparisons are wrap safe): no
+	 * data is ever lost nor expired ahead of time, and whatever is given with an
+	 * instant that is not newer than the newest item is added to that item.
 	 */
 	class RateCalculator
 	{
+	private:
+		struct Item
+		{
+			/**
+			 * Sum of the sizes given to Update() within this item.
+			 */
+			uint64_t count{ 0 };
+			/**
+			 * Number of Update() calls accounted for within this item.
+			 */
+			uint64_t samples{ 0 };
+		};
+
 	public:
 		static constexpr int64_t DefaultWindowSizeMs{ 1000 };
 		static constexpr float DefaultBpsScale{ 8000.0f };
@@ -33,11 +46,43 @@ namespace RTC
 		  float scale          = DefaultBpsScale,
 		  uint16_t windowItems = DefaultWindowItems);
 
+		/**
+		 * Accounts for `size` units of data taken at `nowMs`.
+		 *
+		 * @remarks
+		 * - A sample that arrives when the window holds none starts a new measured
+		 *   period, unless the previous sample is recent enough for both to be taken
+		 *   as the same stretch of traffic. That is what keeps a stream which sends
+		 *   less often than the window from restarting its period at every sample and
+		 *   hence never being measured at all.
+		 */
 		void Update(size_t size, int64_t nowMs);
 
-		int64_t GetRate(int64_t nowMs);
-
-		size_t GetBytes() const
+		/**
+		 * Rate of the data within the window ending at `nowMs`, computed over the
+		 * period the data actually spans rather than over the whole window, so that
+		 * a window which has not filled yet is not reported as a fraction of the
+		 * rate it is measuring.
+		 *
+		 * While that period starts at a sample rather than at the edge of the window,
+		 * the data of that sample is left out, since the period does not cover the
+		 * time it took to arrive.
+		 *
+		 * Returns no value when there is nothing to measure, which is any of:
+		 *
+		 * - Not a single sample within the window.
+		 * - A period of a single millisecond, which gives no duration to divide by.
+		 * - A single sample while the window has not filled, since one sample says
+		 *   how much data arrived at an instant but nothing about how fast it is
+		 *   arriving.
+		 *
+		 * Returns zero when there are enough samples to measure but the data they
+		 * add up to rounds down to zero at the configured scale, which takes
+		 * Update() calls of size zero.
+		 */
+		std::optional<int64_t> GetRate(int64_t nowMs);
+
+		uint64_t GetBytes() const
 		{
 			return this->bytes;
 		}
@@ -52,31 +97,56 @@ namespace RTC
 		int64_t windowSizeMs{ DefaultWindowSizeMs };
 		// Item size (in milliseconds). Always >= 1.
 		int64_t itemSizeMs{ 1 };
-		// Precomputed `scale / windowSizeMs`.
-		double rateScale{ 0.0 };
-		// Ring of items, each one holding the count of the data within it. Never
-		// empty, and always long enough to cover the whole window.
-		std::vector<size_t> buffer;
+		// Factor the in-window count is multiplied by before being divided by the
+		// period it spans.
+		double scale{ 0.0 };
+		// How long after a sample the next one still counts as the same stretch of
+		// traffic (in milliseconds). Derived from the window size.
+		int64_t recentSampleMarginMs{ 0 };
+		// Ring of items. Never empty, and always long enough to cover the whole
+		// window.
+		std::vector<Item> buffer;
 		// Index of the newest item. Always < buffer.size().
 		size_t newestItemIndex{ 0 };
 		// Time (in milliseconds) at which the newest item starts.
 		int64_t newestItemStartTimeMs{ 0 };
+		// Time (in milliseconds) at which the measured period starts. Unset until the
+		// very first sample, and from then on only ever moved forward by a sample
+		// that finds the window empty after long enough without traffic.
+		// NOTE: Expiration does not move it, so once the data reaches back beyond the
+		// window it names a sample that is already gone. That is on purpose: from
+		// that point on the period is the window itself, which is what the reader
+		// clamps it to.
+		std::optional<int64_t> firstSampleTimeMs;
+		// Count of the sample that starts the measured period, which is left out of
+		// the rate for as long as the period is anchored to it.
+		uint64_t firstSampleCount{ 0 };
+		// Time (in milliseconds) of the latest sample, which together with the window
+		// still holding it is what tells a stream that simply sends less often than
+		// the window apart from one that stopped.
+		std::optional<int64_t> lastSampleTimeMs;
 		// Sum of the count of every item.
-		size_t totalCount{ 0 };
+		uint64_t totalCount{ 0 };
+		// Sum of the samples of every item.
+		uint64_t totalSamples{ 0 };
 		// Total bytes accounted for. Not affected by Reset().
-		size_t bytes{ 0 };
-		// Rate memoized by GetRate(), only valid while both `lastTimeMs` and
-		// `lastTotalCount` below still match. `lastTotalCount` is the one that makes
-		// any Update() changing the rate invalidate this implicitly, so that the hot
-		// path needs no memoization store.
+		// NOTE: Nothing bounds this one, unlike the in-window total above, so it is
+		// as wide as the stats field it ends up in.
+		uint64_t bytes{ 0 };
+		// Rate memoized by GetRate(), only valid while `lastTimeMs`,
+		// `lastTotalCount` and `lastTotalSamples` below all still match.
+		// `lastTotalSamples` is the one that makes any Update() invalidate this
+		// implicitly, so that the hot path needs no memoization store.
 		// NOTE: No "not calculated yet" mark is needed, since the initial and post
-		// Reset() state is a valid entry on its own: a zero rate for a zero count.
-		int64_t lastRate{ 0 };
+		// Reset() state is a valid entry on its own: no rate for no samples.
+		std::optional<int64_t> lastRate;
 		// Time of the latest GetRate() call. Prevents reusing `lastRate` once time
 		// has moved on and there is data pending expiration.
 		int64_t lastTimeMs{ 0 };
 		// Total count at the latest GetRate() call.
-		size_t lastTotalCount{ 0 };
+		uint64_t lastTotalCount{ 0 };
+		// Total samples at the latest GetRate() call.
+		uint64_t lastTotalSamples{ 0 };
 	};
 
 	class RtpDataCounter
@@ -91,17 +161,25 @@ namespace RTC
 	public:
 		void Update(const RTC::RTP::Packet* packet);
 
-		int64_t GetBitrate(int64_t nowMs)
+		/**
+		 * Bitrate (bps) of the RTP traffic within the window ending at `nowMs`,
+		 * measured over the period that traffic actually spans.
+		 *
+		 * @returns No value while there is nothing to measure, which is any of: no
+		 *   packet within the window, a period of a single millisecond, and a single
+		 *   packet while the window has not filled.
+		 */
+		std::optional<int64_t> GetBitrate(int64_t nowMs)
 		{
 			return this->rate.GetRate(nowMs);
 		}
 
-		size_t GetPacketCount() const
+		uint64_t GetPacketCount() const
 		{
 			return this->packets;
 		}
 
-		size_t GetBytes() const
+		uint64_t GetBytes() const
 		{
 			return this->rate.GetBytes();
 		}
@@ -112,7 +190,8 @@ namespace RTC
 		// account.
 		bool ignorePaddingOnlyPackets{ false };
 		RateCalculator rate;
-		size_t packets{ 0 };
+		// Total packets accounted for, which nothing bounds either.
+		uint64_t packets{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/RemoteCaptureTimeEstimator.hpp

@@ -14,14 +14,19 @@ namespace RTC
 	 * The capture instant is read from one of two sources, and the same one is used
 	 * for every stream of the sender. Mixing them would reintroduce the very inter
 	 * stream skew this is meant to remove, since they do not carry the same residual
-	 * error: `abs-capture-time` is exact while a Sender Report is biased by its own
+	 * error: 'abs-capture-time' is exact while a Sender Report is biased by its own
 	 * one way delay.
 	 *
 	 * The source is chosen from what the Producers of the sender negotiated. The
 	 * first Producer chooses it, and a single Producer that did not negotiate
-	 * `abs-capture-time` moves it to Sender Report for the rest of the life of this
+	 * 'abs-capture-time' moves it to Sender Report for the rest of the life of this
 	 * object, never back.
 	 *
+	 * A sender may negotiate that extension and then never send it, which would
+	 * leave every stream of it without a capture instant forever. So the source also
+	 * falls back to Sender Report when no stream of this sender has carried the
+	 * extension for long enough since its first packet.
+	 *
 	 * A single instance is meant to be shared by all the RTP streams of a given
 	 * CNAME, which is what identifies media coming from a same machine and hence
 	 * from a same wall clock.
@@ -76,17 +81,42 @@ namespace RTC
 		 *
 		 * @param rtpStream - RTP stream the RTP timestamp belongs to.
 		 * @param ts - RTP timestamp whose capture instant is wanted.
+		 * @param nowUs - Current instant, which is also what the fall back to Sender
+		 *   Report is timed against.
 		 *
 		 * @returns No value while the capture instant cannot be told yet.
 		 */
 		std::optional<int64_t> GetLocalCaptureAtUs(
-		  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const;
+		  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts, int64_t nowUs);
+
+	private:
+		/**
+		 * Move the source to Sender Report when 'abs-capture-time' was negotiated but
+		 * no stream of this sender has ever carried it, which is told apart from it
+		 * being merely early by how long this sender has been sending.
+		 *
+		 * @param rtpStream - RTP stream whose packet is being looked at.
+		 * @param nowUs - Current instant.
+		 */
+		void MayFallBackToSenderReport(const RTC::RTP::RtpStreamRecv* rtpStream, int64_t nowUs);
 
 	private:
 		// Offset between the wall clock of the sender and our monotonic one.
 		RTC::RemoteClockOffsetEstimator clockOffsetEstimator;
 		// Source the capture instant is read from, for every stream of this sender.
 		std::optional<Source> source;
+		// Instant the first packet of this sender was asked about, or no value until
+		// then. The fall back to Sender Report is measured against it, so it must be
+		// something that exists even when the extension never arrives.
+		//
+		// NOTE: Not every packet is asked about, only the one holding the highest RTP
+		// timestamp of its stream, so this is the first one that got here rather than
+		// the first one that arrived.
+		std::optional<int64_t> firstPacketAtUs;
+		// Whether any stream of this sender has ever carried 'abs-capture-time', which
+		// is what tells a sender that does not send it from a stream whose first
+		// packets carrying it are still on their way.
+		bool absCaptureTimeReceived{ false };
 	};
 } // namespace RTC
 

package/worker/include/RTC/{RtcLogger.hpp → RtcLogger/RtpPacket.hpp}

@@ -1,8 +1,9 @@
-#ifndef MS_RTC_RTC_LOGGER_HPP
-#define MS_RTC_RTC_LOGGER_HPP
+#ifndef MS_RTC_RTC_LOGGER_RTP_PACKET_HPP
+#define MS_RTC_RTC_LOGGER_RTP_PACKET_HPP
 
 #include "common.hpp"
 #include <ankerl/unordered_dense.h>
+#include <string>
 
 namespace RTC
 {
@@ -55,6 +56,7 @@ namespace RTC
 			bool discarded{};
 			DiscardReason discardReason{ DiscardReason::NONE };
 		};
-	}; // namespace RtcLogger
+	} // namespace RtcLogger
 } // namespace RTC
+
 #endif

package/worker/include/RTC/RtcLogger/SendBurst.hpp

@@ -0,0 +1,88 @@
+#ifndef MS_RTC_RTC_LOGGER_SEND_BURST_HPP
+#define MS_RTC_RTC_LOGGER_SEND_BURST_HPP
+
+#include "common.hpp"
+#include <map>
+#include <string>
+
+namespace RTC
+{
+	namespace RtcLogger
+	{
+		/**
+		 * How many RTP packets a transport sends within a single iteration of the event
+		 * loop.
+		 *
+		 * Nothing spaces those packets out, so a whole iteration's worth of them reaches
+		 * the wire back to back and lands in the first queue of the path as a single
+		 * lump. This gathers how big those lumps are and how much of each one is
+		 * retransmissions, which is what says whether there is anything worth pacing.
+		 */
+		class SendBurst
+		{
+		private:
+			/**
+			 * What all the bursts of a given size added up to.
+			 */
+			struct Counters
+			{
+				/**
+				 * How many of them there were.
+				 */
+				uint64_t count{ 0 };
+				/**
+				 * Retransmissions they carried between all of them, so that the tail of
+				 * the distribution can be attributed.
+				 */
+				uint64_t retransmissions{ 0 };
+				/**
+				 * Probation packets they carried between all of them.
+				 */
+				uint64_t probations{ 0 };
+			};
+
+		public:
+			SendBurst()  = default;
+			~SendBurst() = default;
+
+			/**
+			 * Account for a packet that is about to be sent.
+			 *
+			 * @param loopTimeMs - Time at which the current iteration of the event loop
+			 * began, which is what tells one burst from the next.
+			 */
+			void Sent(uint64_t loopTimeMs, size_t length, bool isRetransmission, bool isProbation);
+
+			/**
+			 * Print what has been gathered so far and start over.
+			 */
+			void Log();
+
+		private:
+			/**
+			 * Add the burst in progress, if there is one, to the distribution.
+			 */
+			void CloseBurst();
+
+			void Clear();
+
+		public:
+			std::string transportId;
+
+		private:
+			// Time of the iteration of the event loop that the burst in progress belongs
+			// to.
+			uint64_t loopTimeMs{ 0 };
+			size_t packets{ 0 };
+			size_t retransmissions{ 0 };
+			size_t probations{ 0 };
+			size_t bytes{ 0 };
+			// Bursts seen, keyed by how many packets each of them carried.
+			std::map<size_t /*packets*/, Counters> bursts;
+			size_t maxPackets{ 0 };
+			size_t maxBytes{ 0 };
+		};
+	} // namespace RtcLogger
+} // namespace RTC
+
+#endif

package/worker/include/RTC/RtpDictionaries.hpp

@@ -123,10 +123,9 @@ namespace RTC
 			SSRC_AUDIO_LEVEL       = 6,
 			DEPENDENCY_DESCRIPTOR  = 7,
 			VIDEO_ORIENTATION      = 8,
-			TIME_OFFSET            = 9,
-			ABS_CAPTURE_TIME       = 10,
-			PLAYOUT_DELAY          = 11,
-			MEDIASOUP_PACKET_ID    = 12
+			ABS_CAPTURE_TIME       = 9,
+			PLAYOUT_DELAY          = 10,
+			MEDIASOUP_PACKET_ID    = 11
 		};
 
 	public:

package/worker/include/RTC/SCTP/association/Association.hpp

@@ -128,7 +128,7 @@ namespace RTC
 						return "SHUTDOWN_ACK_SENT";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/association/StreamResetHandler.hpp

@@ -163,6 +163,25 @@ namespace RTC
 				bool isDeferred{ false };
 			};
 
+			/**
+			 * Represents a received outgoing stream reset request whose processing
+			 * had to be deferred because the sender's last assigned TSN had not been
+			 * reached yet (aka "deferred reset processing").
+			 */
+			struct DeferredIncomingRequest
+			{
+				/**
+				 * The sender's (that's the peer) last assigned TSN. Deferred reset
+				 * processing must end once the cumulative ack TSN reaches it.
+				 */
+				uint32_t senderLastAssignedTsn;
+
+				/**
+				 * The streams that are to be reset.
+				 */
+				std::vector<uint16_t> streamIds;
+			};
+
 		private:
 			using UnwrappedReConfigRequestSn = Utils::UnwrappedSequenceNumber<uint32_t>;
 
@@ -211,6 +230,18 @@ namespace RTC
 			 */
 			void HandleReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk);
 
+			/**
+			 * Called at the end of processing a received SCTP packet. If this
+			 * association is in "deferred reset processing" and the cumulative ack TSN
+			 * has reached the sender's last assigned TSN, the deferred stream reset is
+			 * performed and deferred reset processing ends.
+			 *
+			 * Returns `true` if deferred reset processing ended, in which case the
+			 * chunks queued while it lasted have been released and there may be
+			 * messages to deliver.
+			 */
+			bool MayLeaveDeferredReset();
+
 		private:
 			/**
 			 * Called to validate a received RE-CONFIG chunk.
@@ -279,6 +310,11 @@ namespace RTC
 			ReconfigurationResponseParameter::Result lastProcessedReqResult;
 			// The current stream request operation.
 			std::optional<CurrentRequest> currentRequest;
+			// The received request being deferred, if in deferred reset processing.
+			std::optional<DeferredIncomingRequest> deferredIncomingRequest;
+			// The received request that was performed when deferred reset processing
+			// ended, until the peer retries it and gets the final response.
+			std::optional<DeferredIncomingRequest> performedDeferredRequest;
 		};
 	} // namespace SCTP
 } // namespace RTC

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

@@ -2,7 +2,6 @@
 #define MS_RTC_SCTP_ASSOCIATION_METRICS_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/StateCookie.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 
 namespace RTC

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

@@ -48,7 +48,7 @@ namespace RTC
 				SHUTTING_DOWN
 			};
 
-			constexpr std::string_view AssociationStateToString(AssociationState associationState)
+			constexpr std::string_view associationStateToString(AssociationState associationState)
 			{
 				switch (associationState)
 				{
@@ -77,7 +77,7 @@ namespace RTC
 						return "SHUTTING_DOWN";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -128,7 +128,7 @@ namespace RTC
 				UNSUPPORTED_OPERATION
 			};
 
-			constexpr std::string_view ErrorKindToString(ErrorKind errorKind)
+			constexpr std::string_view errorKindToString(ErrorKind errorKind)
 			{
 				switch (errorKind)
 				{
@@ -179,7 +179,7 @@ namespace RTC
 						return "UNSUPPORTED_OPERATION";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -195,7 +195,7 @@ namespace RTC
 				USRSCTP
 			};
 
-			constexpr std::string_view SctpImplementationToString(SctpImplementation sctpImplementation)
+			constexpr std::string_view sctpImplementationToString(SctpImplementation sctpImplementation)
 			{
 				switch (sctpImplementation)
 				{
@@ -219,7 +219,7 @@ namespace RTC
 						return "usrsctp";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -246,7 +246,7 @@ namespace RTC
 				NOT_SUPPORTED
 			};
 
-			constexpr std::string_view ResetStreamsStatusToString(ResetStreamsStatus status)
+			constexpr std::string_view resetStreamsStatusToString(ResetStreamsStatus status)
 			{
 				switch (status)
 				{
@@ -303,7 +303,7 @@ namespace RTC
 				ERROR_SHUTTING_DOWN
 			};
 
-			constexpr std::string_view SendMessageStatusToString(SendMessageStatus status)
+			constexpr std::string_view sendMessageStatusToString(SendMessageStatus status)
 			{
 				switch (status)
 				{
@@ -332,7 +332,7 @@ namespace RTC
 						return "ERROR_SHUTTING_DOWN";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/rx/DataTracker.hpp

@@ -105,7 +105,7 @@ namespace RTC
 						return "IMMEDIATE";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/rx/ReassemblyQueue.hpp

@@ -57,7 +57,7 @@ namespace RTC
 			 * SCTP association should restrict incoming data to avoid filling up the
 			 * queue.
 			 */
-			static constexpr float HighWatermarkLimit{ 0.9 };
+			static constexpr double HighWatermarkLimit{ 0.9 };
 
 		private:
 			struct DeferredResetStreams
@@ -141,9 +141,19 @@ namespace RTC
 
 			/**
 			 * The remaining bytes until the queue has reached the watermark limit.
+			 *
+			 * @remarks
+			 * - The queued bytes are allowed to go above the watermark limit (data is
+			 *   only rejected once the queue is full), so this returns 0 rather than
+			 *   wrapping around.
 			 */
 			size_t GetRemainingBytes() const
 			{
+				if (this->queuedBytes >= this->watermarkBytes)
+				{
+					return 0;
+				}
+
 				return this->watermarkBytes - this->queuedBytes;
 			}
 

package/worker/include/RTC/SctpDictionaries.hpp

@@ -18,8 +18,8 @@ namespace RTC
 	public:
 		uint16_t streamId{ 0 };
 		bool ordered{ true };
-		uint16_t maxPacketLifeTime{ 0 };
-		uint16_t maxRetransmits{ 0 };
+		std::optional<uint16_t> maxPacketLifeTime;
+		std::optional<uint16_t> maxRetransmits;
 	};
 } // namespace RTC
 

package/worker/include/RTC/TcpConnection.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_TCP_CONNECTION_HPP
 
 #include "common.hpp"
+#include "handles/SendCallbacks.hpp"
 #include "handles/TcpConnectionHandle.hpp"
 #include "SharedInterface.hpp"
 
@@ -29,7 +30,7 @@ namespace RTC
 		~TcpConnection() override;
 
 	public:
-		void Send(const uint8_t* data, size_t len, ::TcpConnectionHandle::onSendCallback* cb);
+		void Send(const uint8_t* data, size_t len, onSendCallback cb);
 
 		/* Pure virtual methods inherited from ::TcpConnectionHandle. */
 	public: