mediasoup 3.11.17 → 3.11.18

package/node/lib/Worker.js

@@ -90,7 +90,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.11.17',
+                MEDIASOUP_VERSION: '3.11.18',
                 // Let the worker process inherit all environment variables, useful
                 // if a custom and not in the path GCC is used so the user can set
                 // LD_LIBRARY_PATH environment variable for runtime.

package/node/lib/index.d.ts

@@ -9,7 +9,7 @@ export { types };
 /**
  * Expose mediasoup version.
  */
-export declare const version = "3.11.17";
+export declare const version = "3.11.18";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

@@ -11,7 +11,7 @@ exports.types = types;
 /**
  * Expose mediasoup version.
  */
-exports.version = '3.11.17';
+exports.version = '3.11.18';
 /**
  * Expose parseScalabilityMode() function.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.11.17",
+  "version": "3.11.18",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",

package/worker/include/RTC/RtpRetransmissionBuffer.hpp

@@ -46,7 +46,7 @@ namespace RTC
 		Item* GetNewest() const;
 		void RemoveOldest();
 		void RemoveOldest(uint16_t numItems);
-		void ClearTooOld();
+		bool ClearTooOld(uint32_t newestTimestamp);
 		bool IsTooOld(uint32_t timestamp, uint32_t newestTimestamp) const;
 		Item* FillItem(
 		  Item* item, RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) const;

package/worker/src/RTC/RtpRetransmissionBuffer.cpp

@@ -81,11 +81,41 @@ namespace RTC
 			return;
 		}
 
+		auto* oldestItem = GetOldest();
+		auto* newestItem = GetNewest();
+
 		// Clear too old packets in the buffer.
-		ClearTooOld();
+		// NOTE: Here we must consider the case in which, due for example to huge
+		// packet loss, received packet has higher timestamp but "older" seq number
+		// than the newest packet in the buffer and, if so, use it to clear too old
+		// packets rather than the newest packet in the buffer.
+		auto newestTimestamp =
+		  RTC::SeqManager<uint32_t>::IsSeqHigherThan(timestamp, newestItem->timestamp)
+		    ? timestamp
+		    : newestItem->timestamp;
+
+		// ClearTooOld() returns true if at least one packet has been removed from
+		// the front.
+		if (ClearTooOld(newestTimestamp))
+		{
+			// Buffer content has been modified so we must check it again.
+			if (this->buffer.empty())
+			{
+				MS_DEBUG_DEV(
+				  "buffer empty after clearing too old packets [seq:%" PRIu16 ", timestamp:%" PRIu32 "]",
+				  seq,
+				  timestamp);
 
-		const auto* oldestItem = GetOldest();
-		const auto* newestItem = GetNewest();
+				auto* item = new Item();
+
+				this->buffer.push_back(FillItem(item, packet, sharedPacket));
+
+				return;
+			}
+
+			oldestItem = GetOldest();
+			newestItem = GetNewest();
+		}
 
 		MS_ASSERT(oldestItem != nullptr, "oldest item doesn't exist");
 		MS_ASSERT(newestItem != nullptr, "newest item doesn't exist");
@@ -456,26 +486,22 @@ namespace RTC
 		}
 	}
 
-	void RtpRetransmissionBuffer::ClearTooOld()
+	bool RtpRetransmissionBuffer::ClearTooOld(uint32_t newestTimestamp)
 	{
 		MS_TRACE();
 
-		const auto* newestItem = GetNewest();
-
-		if (!newestItem)
-		{
-			return;
-		}
-
 		RtpRetransmissionBuffer::Item* oldestItem{ nullptr };
+		bool itemsRemoved{ false };
 
 		// Go through all buffer items starting with the first and free all items
 		// that contain too old packets.
 		while ((oldestItem = GetOldest()))
 		{
-			if (IsTooOld(oldestItem->timestamp, newestItem->timestamp))
+			if (IsTooOld(oldestItem->timestamp, newestTimestamp))
 			{
 				RemoveOldest();
+
+				itemsRemoved = true;
 			}
 			// If current oldest stored packet is not too old, exit the loop since we
 			// know that packets stored after it are guaranteed to be newer.
@@ -484,6 +510,8 @@ namespace RTC
 				break;
 			}
 		}
+
+		return itemsRemoved;
 	}
 
 	bool RtpRetransmissionBuffer::IsTooOld(uint32_t timestamp, uint32_t newestTimestamp) const

package/worker/src/RTC/RtpStream.cpp

@@ -193,7 +193,7 @@ namespace RTC
 			this->maxSeq = seq;
 		}
 		// Too old packet received (older than the allowed misorder).
-		// Or to new packet (more than acceptable dropout).
+		// Or too new packet (more than acceptable dropout).
 		else if (udelta <= RtpSeqMod - MaxMisorder)
 		{
 			// The sequence number made a very large jump. If two sequential packets

package/worker/src/RTC/RtpStreamSend.cpp

@@ -12,7 +12,7 @@ namespace RTC
 	/* Static. */
 
 	// Limit max number of items in the retransmission buffer.
-	static constexpr size_t RetransmissionBufferMaxItems{ 5000u };
+	static constexpr size_t RetransmissionBufferMaxItems{ 2500u };
 	// 17: 16 bit mask + the initial sequence number.
 	static constexpr size_t MaxRequestedPackets{ 17u };
 	thread_local static std::vector<RTC::RtpRetransmissionBuffer::Item*> RetransmissionContainer(

package/worker/test/src/RTC/TestRtpRetransmissionBuffer.cpp

@@ -230,6 +230,29 @@ SCENARIO("RtpRetransmissionBuffer", "[rtp][rtx]")
 		// clang-format on
 	}
 
+	SECTION("packet with very newest timestamp is inserted as newest item despite its seq is old")
+	{
+		uint16_t maxItems{ 4 };
+		uint32_t maxRetransmissionDelayMs{ 2000u };
+		uint32_t clockRate{ 90000 };
+
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+
+		// Scenario based on https://github.com/versatica/mediasoup/issues/1037.
+
+		myRetransmissionBuffer.Insert(24816, 1024930187);
+		myRetransmissionBuffer.Insert(24980, 1025106407);
+		myRetransmissionBuffer.Insert(18365, 1026593387);
+
+		// clang-format off
+		myRetransmissionBuffer.AssertBuffer(
+			{
+				{ true, 18365, 1026593387 }
+			}
+		);
+		// clang-format on
+	}
+
 	SECTION("fuzzer generated packets")
 	{
 		uint16_t maxItems{ 2500u };