mediasoup 3.11.14 → 3.11.15

package/node/lib/Worker.js

@@ -90,7 +90,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.11.14',
+                MEDIASOUP_VERSION: '3.11.15',
                 // 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.14";
+export declare const version = "3.11.15";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.11.14",
+  "version": "3.11.15",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -93,10 +93,10 @@
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "@types/jest": "^29.5.0",
-    "@types/node": "^18.15.3",
+    "@types/node": "^18.15.5",
     "@types/uuid": "^9.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.55.0",
-    "@typescript-eslint/parser": "^5.55.0",
+    "@typescript-eslint/eslint-plugin": "^5.56.0",
+    "@typescript-eslint/parser": "^5.56.0",
     "eslint": "^8.36.0",
     "eslint-plugin-jest": "^27.2.1",
     "jest": "^29.5.0",

package/worker/fuzzer/include/RTC/FuzzerRtpRetransmissionBuffer.hpp

@@ -0,0 +1,17 @@
+#ifndef MS_FUZZER_RTC_RTP_RETRANSMISSION_BUFFER_HPP
+#define MS_FUZZER_RTC_RTP_RETRANSMISSION_BUFFER_HPP
+
+#include "common.hpp"
+
+namespace Fuzzer
+{
+	namespace RTC
+	{
+		namespace RtpRetransmissionBuffer
+		{
+			void Fuzz(const uint8_t* data, size_t len);
+		}
+	} // namespace RTC
+} // namespace Fuzzer
+
+#endif

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -12,10 +12,13 @@ void Fuzzer::Utils::Fuzz(const uint8_t* data, size_t len)
 	/* IP class. */
 
 	std::string ip;
+
 	ip = std::string(reinterpret_cast<const char*>(data2), INET6_ADDRSTRLEN / 2);
 	::Utils::IP::GetFamily(ip);
+
 	ip = std::string(reinterpret_cast<const char*>(data2), INET6_ADDRSTRLEN);
 	::Utils::IP::GetFamily(ip);
+
 	ip = std::string(reinterpret_cast<const char*>(data2), INET6_ADDRSTRLEN * 2);
 	::Utils::IP::GetFamily(ip);
 
@@ -23,6 +26,7 @@ void Fuzzer::Utils::Fuzz(const uint8_t* data, size_t len)
 	try
 	{
 		auto ip = std::string(reinterpret_cast<const char*>(data2), len);
+
 		::Utils::IP::NormalizeIp(ip);
 	}
 	catch (const MediaSoupError& error)
@@ -60,6 +64,7 @@ void Fuzzer::Utils::Fuzz(const uint8_t* data, size_t len)
 	try
 	{
 		size_t outLen;
+
 		::Utils::String::Base64Encode(data2, len);
 		::Utils::String::Base64Decode(data2, len, outLen);
 	}
@@ -70,6 +75,7 @@ void Fuzzer::Utils::Fuzz(const uint8_t* data, size_t len)
 	/* Time class. */
 
 	auto ntp = ::Utils::Time::TimeMs2Ntp(static_cast<uint64_t>(len));
+
 	::Utils::Time::Ntp2TimeMs(ntp);
 	::Utils::Time::IsNewerTimestamp(static_cast<uint32_t>(len), static_cast<uint32_t>(len * len));
 	::Utils::Time::IsNewerTimestamp(static_cast<uint32_t>(len * len), static_cast<uint32_t>(len));

package/worker/fuzzer/src/RTC/FuzzerRtpPacket.cpp

@@ -7,7 +7,9 @@
 void Fuzzer::RTC::RtpPacket::Fuzz(const uint8_t* data, size_t len)
 {
 	if (!::RTC::RtpPacket::IsRtp(data, len))
+	{
 		return;
+	}
 
 	// We need to clone the given data into a separate buffer because setters
 	// below will try to write into packet memory.
@@ -31,7 +33,9 @@ void Fuzzer::RTC::RtpPacket::Fuzz(const uint8_t* data, size_t len)
 	::RTC::RtpPacket* packet = ::RTC::RtpPacket::Parse(data2, len);
 
 	if (!packet)
+	{
 		return;
+	}
 
 	// packet->Dump();
 	packet->GetData();

package/worker/fuzzer/src/RTC/FuzzerRtpRetransmissionBuffer.cpp

@@ -0,0 +1,44 @@
+#include "RTC/FuzzerRtpRetransmissionBuffer.hpp"
+#include "Utils.hpp"
+#include "RTC/RtpPacket.hpp"
+#include "RTC/RtpRetransmissionBuffer.hpp"
+
+void Fuzzer::RTC::RtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
+{
+	uint16_t maxItems{ 2500u };
+	uint32_t maxRetransmissionDelayMs{ 2000u };
+	uint32_t clockRate{ 90000 };
+
+	// Trick to initialize our stuff just once (use static).
+	static ::RTC::RtpRetransmissionBuffer retransmissionBuffer(
+	  maxItems, maxRetransmissionDelayMs, clockRate);
+
+	// clang-format off
+	uint8_t buffer[] =
+	{
+		0b10000000, 0b01111011, 0b01010010, 0b00001110,
+		0b01011011, 0b01101011, 0b11001010, 0b10110101,
+		0, 0, 0, 2
+	};
+	// clang-format on
+
+	// Create base RtpPacket instance.
+	auto* packet = ::RTC::RtpPacket::Parse(buffer, 12);
+	size_t offset{ 0u };
+
+	while (len >= 4u)
+	{
+		std::shared_ptr<::RTC::RtpPacket> sharedPacket;
+
+		// Set 'random' sequence number and timestamp.
+		packet->SetSequenceNumber(Utils::Byte::Get2Bytes(data, offset));
+		packet->SetTimestamp(Utils::Byte::Get4Bytes(data, offset));
+
+		retransmissionBuffer.Insert(packet, sharedPacket);
+
+		len -= 4u;
+		offset += 4;
+	}
+
+	delete packet;
+}

package/worker/fuzzer/src/RTC/FuzzerRtpStreamSend.cpp

@@ -27,7 +27,6 @@ void Fuzzer::RTC::RtpStreamSend::Fuzz(const uint8_t* data, size_t len)
 
 	// Create base RtpPacket instance.
 	auto* packet = ::RTC::RtpPacket::Parse(buffer, 12);
-	size_t offset{ 0u };
 
 	// Create a RtpStreamSend instance.
 	TestRtpStreamListener testRtpStreamListener;
@@ -44,6 +43,7 @@ void Fuzzer::RTC::RtpStreamSend::Fuzz(const uint8_t* data, size_t len)
 
 	std::string mid;
 	auto* stream = new ::RTC::RtpStreamSend(&testRtpStreamListener, params, mid);
+	size_t offset{ 0u };
 
 	while (len >= 4u)
 	{

package/worker/fuzzer/src/RTC/FuzzerStunPacket.cpp

@@ -4,12 +4,16 @@
 void Fuzzer::RTC::StunPacket::Fuzz(const uint8_t* data, size_t len)
 {
 	if (!::RTC::StunPacket::IsStun(data, len))
+	{
 		return;
+	}
 
 	::RTC::StunPacket* packet = ::RTC::StunPacket::Parse(data, len);
 
 	if (!packet)
+	{
 		return;
+	}
 
 	// packet->Dump();
 	packet->GetClass();

package/worker/fuzzer/src/fuzzer.cpp

@@ -10,6 +10,7 @@
 #include "Settings.hpp"
 #include "Utils.hpp"
 #include "RTC/FuzzerRtpPacket.hpp"
+#include "RTC/FuzzerRtpRetransmissionBuffer.hpp"
 #include "RTC/FuzzerRtpStreamSend.hpp"
 #include "RTC/FuzzerStunPacket.hpp"
 #include "RTC/FuzzerTrendCalculator.hpp"
@@ -19,11 +20,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-bool fuzzStun      = false;
-bool fuzzRtp       = false;
-bool fuzzRtcp      = false;
-bool fuzzRtpStream = false;
-bool fuzzUtils     = false;
+bool fuzzStun  = false;
+bool fuzzRtp   = false;
+bool fuzzRtcp  = false;
+bool fuzzUtils = false;
 
 int Init();
 
@@ -36,16 +36,21 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t len)
 	unused++;
 
 	if (fuzzStun)
+	{
 		Fuzzer::RTC::StunPacket::Fuzz(data, len);
+	}
 
 	if (fuzzRtp)
+	{
 		Fuzzer::RTC::RtpPacket::Fuzz(data, len);
+		Fuzzer::RTC::RtpStreamSend::Fuzz(data, len);
+		Fuzzer::RTC::RtpRetransmissionBuffer::Fuzz(data, len);
+	}
 
 	if (fuzzRtcp)
+	{
 		Fuzzer::RTC::RTCP::Packet::Fuzz(data, len);
-
-	if (fuzzRtpStream)
-		Fuzzer::RTC::RtpStreamSend::Fuzz(data, len);
+	}
 
 	if (fuzzUtils)
 	{
@@ -64,11 +69,17 @@ int Init()
 	if (std::getenv("MS_FUZZ_LOG_LEVEL"))
 	{
 		if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "debug")
+		{
 			logLevel = LogLevel::LOG_DEBUG;
+		}
 		else if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "warn")
+		{
 			logLevel = LogLevel::LOG_WARN;
+		}
 		else if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "error")
+		{
 			logLevel = LogLevel::LOG_ERROR;
+		}
 	}
 
 	// Select what to fuzz.
@@ -90,27 +101,20 @@ int Init()
 
 		fuzzRtcp = true;
 	}
-	if (std::getenv("MS_FUZZ_RTP_STREAM") && std::string(std::getenv("MS_FUZZ_RTP_STREAM")) == "1")
-	{
-		std::cout << "[fuzzer] RTP Stream fuzzers enabled" << std::endl;
-
-		fuzzRtpStream = true;
-	}
 	if (std::getenv("MS_FUZZ_UTILS") && std::string(std::getenv("MS_FUZZ_UTILS")) == "1")
 	{
 		std::cout << "[fuzzer] Utils fuzzers enabled" << std::endl;
 
 		fuzzUtils = true;
 	}
-	if (!fuzzUtils && !fuzzStun && !fuzzRtcp && !fuzzRtp && !fuzzRtpStream)
+	if (!fuzzUtils && !fuzzStun && !fuzzRtcp && !fuzzRtp)
 	{
 		std::cout << "[fuzzer] all fuzzers enabled" << std::endl;
 
-		fuzzStun      = true;
-		fuzzRtp       = true;
-		fuzzRtcp      = true;
-		fuzzRtpStream = true;
-		fuzzUtils     = true;
+		fuzzStun  = true;
+		fuzzRtp   = true;
+		fuzzRtcp  = true;
+		fuzzUtils = true;
 	}
 
 	Settings::configuration.logLevel = logLevel;

package/worker/include/RTC/{RetransmissionBuffer.hpp → RtpRetransmissionBuffer.hpp}

@@ -11,7 +11,7 @@ namespace RTC
 	// sequence number, while only taking as little memory as necessary to store
 	// the range covering a maximum of `MaxRetransmissionDelayForVideoMs` or
 	//  `MaxRetransmissionDelayForAudioMs` ms.
-	class RetransmissionBuffer
+	class RtpRetransmissionBuffer
 	{
 	public:
 		struct Item
@@ -33,8 +33,8 @@ namespace RTC
 		};
 
 	public:
-		RetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate);
-		~RetransmissionBuffer();
+		RtpRetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate);
+		~RtpRetransmissionBuffer();
 
 		Item* Get(uint16_t seq) const;
 		void Insert(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket);

package/worker/include/RTC/RtpStreamSend.hpp

@@ -2,7 +2,7 @@
 #define MS_RTC_RTP_STREAM_SEND_HPP
 
 #include "RTC/RateCalculator.hpp"
-#include "RTC/RetransmissionBuffer.hpp"
+#include "RTC/RtpRetransmissionBuffer.hpp"
 #include "RTC/RtpStream.hpp"
 
 namespace RTC
@@ -61,7 +61,7 @@ namespace RTC
 		std::string mid;
 		uint16_t rtxSeq{ 0u };
 		RTC::RtpDataCounter transmissionCounter;
-		RTC::RetransmissionBuffer* retransmissionBuffer{ nullptr };
+		RTC::RtpRetransmissionBuffer* retransmissionBuffer{ nullptr };
 		// The middle 32 bits out of 64 in the NTP timestamp received in the most
 		// recent receiver reference timestamp.
 		uint32_t lastRrTimestamp{ 0u };

package/worker/meson.build

@@ -84,12 +84,12 @@ common_sources = [
   'src/RTC/PortManager.cpp',
   'src/RTC/Producer.cpp',
   'src/RTC/RateCalculator.cpp',
-  'src/RTC/RetransmissionBuffer.cpp',
   'src/RTC/Router.cpp',
   'src/RTC/RtpListener.cpp',
   'src/RTC/RtpObserver.cpp',
   'src/RTC/RtpPacket.cpp',
   'src/RTC/RtpProbationGenerator.cpp',
+  'src/RTC/RtpRetransmissionBuffer.cpp',
   'src/RTC/RtpStream.cpp',
   'src/RTC/RtpStreamRecv.cpp',
   'src/RTC/RtpStreamSend.cpp',
@@ -288,9 +288,9 @@ mediasoup_worker_test = executable(
     'test/src/RTC/TestKeyFrameRequestManager.cpp',
     'test/src/RTC/TestNackGenerator.cpp',
     'test/src/RTC/TestRateCalculator.cpp',
-    'test/src/RTC/TestRetransmissionBuffer.cpp',
     'test/src/RTC/TestRtpPacket.cpp',
     'test/src/RTC/TestRtpPacketH264Svc.cpp',
+    'test/src/RTC/TestRtpRetransmissionBuffer.cpp',
     'test/src/RTC/TestRtpStreamSend.cpp',
     'test/src/RTC/TestRtpStreamRecv.cpp',
     'test/src/RTC/TestSeqManager.cpp',
@@ -354,6 +354,7 @@ executable(
     'fuzzer/src/FuzzerUtils.cpp',
     'fuzzer/src/RTC/FuzzerStunPacket.cpp',
     'fuzzer/src/RTC/FuzzerRtpPacket.cpp',
+    'fuzzer/src/RTC/FuzzerRtpRetransmissionBuffer.cpp',
     'fuzzer/src/RTC/FuzzerRtpStreamSend.cpp',
     'fuzzer/src/RTC/FuzzerTrendCalculator.cpp',
     'fuzzer/src/RTC/RTCP/FuzzerBye.cpp',

package/worker/src/RTC/{RetransmissionBuffer.cpp → RtpRetransmissionBuffer.cpp}

@@ -1,7 +1,7 @@
-#define MS_CLASS "RTC::RetransmissionBuffer"
+#define MS_CLASS "RTC::RtpRetransmissionBuffer"
 // #define MS_LOG_DEV_LEVEL 3
 
-#include "RTC/RetransmissionBuffer.hpp"
+#include "RTC/RtpRetransmissionBuffer.hpp"
 #include "Logger.hpp"
 #include "RTC/SeqManager.hpp"
 
@@ -9,7 +9,7 @@ namespace RTC
 {
 	/* Instance methods. */
 
-	RetransmissionBuffer::RetransmissionBuffer(
+	RtpRetransmissionBuffer::RtpRetransmissionBuffer(
 	  uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate)
 	  : maxItems(maxItems), maxRetransmissionDelayMs(maxRetransmissionDelayMs), clockRate(clockRate)
 	{
@@ -18,14 +18,14 @@ namespace RTC
 		MS_ASSERT(maxItems > 0u, "maxItems must be greater than 0");
 	}
 
-	RetransmissionBuffer::~RetransmissionBuffer()
+	RtpRetransmissionBuffer::~RtpRetransmissionBuffer()
 	{
 		MS_TRACE();
 
 		Clear();
 	}
 
-	RetransmissionBuffer::Item* RetransmissionBuffer::Get(uint16_t seq) const
+	RtpRetransmissionBuffer::Item* RtpRetransmissionBuffer::Get(uint16_t seq) const
 	{
 		MS_TRACE();
 
@@ -56,7 +56,8 @@ namespace RTC
 	 * not properly fit (by ensuring that elements in the buffer are not only
 	 * ordered by increasing seq but also that their timestamp are incremental).
 	 */
-	void RetransmissionBuffer::Insert(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
+	void RtpRetransmissionBuffer::Insert(
+	  RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -135,7 +136,11 @@ namespace RTC
 					  timestamp);
 
 					numBlankSlots = 0u;
+
 					Clear();
+
+					// After clearing the buffer, update startSeq.
+					this->startSeq = seq;
 				}
 				else
 				{
@@ -331,7 +336,7 @@ namespace RTC
 		  this->maxItems);
 	}
 
-	void RetransmissionBuffer::Clear()
+	void RtpRetransmissionBuffer::Clear()
 	{
 		MS_TRACE();
 
@@ -352,12 +357,16 @@ namespace RTC
 		this->startSeq = 0u;
 	}
 
-	void RetransmissionBuffer::Dump() const
+	void RtpRetransmissionBuffer::Dump() const
 	{
 		MS_TRACE();
 
-		MS_DUMP("<RetransmissionBuffer>");
-		MS_DUMP("  buffer [size:%zu, maxSize:%" PRIu16 "]", this->buffer.size(), this->maxItems);
+		MS_DUMP("<RtpRetransmissionBuffer>");
+		MS_DUMP(
+		  "  buffer [size:%zu, maxSize:%" PRIu16 ", startSeq:%" PRIu16 "]",
+		  this->buffer.size(),
+		  this->maxItems,
+		  this->startSeq);
 		if (this->buffer.size() > 0)
 		{
 			const auto* oldestItem = GetOldest();
@@ -376,24 +385,24 @@ namespace RTC
 			  static_cast<uint32_t>(newestItem->timestamp * 1000 / this->clockRate) -
 			    static_cast<uint32_t>(oldestItem->timestamp * 1000 / this->clockRate));
 		}
-		MS_DUMP("</RetransmissionBuffer>");
+		MS_DUMP("</RtpRetransmissionBuffer>");
 	}
 
-	RetransmissionBuffer::Item* RetransmissionBuffer::GetOldest() const
+	RtpRetransmissionBuffer::Item* RtpRetransmissionBuffer::GetOldest() const
 	{
 		MS_TRACE();
 
 		return this->Get(this->startSeq);
 	}
 
-	RetransmissionBuffer::Item* RetransmissionBuffer::GetNewest() const
+	RtpRetransmissionBuffer::Item* RtpRetransmissionBuffer::GetNewest() const
 	{
 		MS_TRACE();
 
 		return this->Get(this->startSeq + this->buffer.size() - 1);
 	}
 
-	void RetransmissionBuffer::RemoveOldest()
+	void RtpRetransmissionBuffer::RemoveOldest()
 	{
 		MS_TRACE();
 
@@ -438,7 +447,7 @@ namespace RTC
 		}
 	}
 
-	void RetransmissionBuffer::RemoveOldest(uint16_t numItems)
+	void RtpRetransmissionBuffer::RemoveOldest(uint16_t numItems)
 	{
 		MS_TRACE();
 
@@ -457,7 +466,7 @@ namespace RTC
 		}
 	}
 
-	void RetransmissionBuffer::ClearTooOld()
+	void RtpRetransmissionBuffer::ClearTooOld()
 	{
 		MS_TRACE();
 
@@ -468,7 +477,7 @@ namespace RTC
 			return;
 		}
 
-		RetransmissionBuffer::Item* oldestItem{ nullptr };
+		RtpRetransmissionBuffer::Item* oldestItem{ nullptr };
 
 		// Go through all buffer items starting with the first and free all items
 		// that contain too old packets.
@@ -487,7 +496,7 @@ namespace RTC
 		}
 	}
 
-	bool RetransmissionBuffer::IsTooOld(uint32_t timestamp, uint32_t newestTimestamp) const
+	bool RtpRetransmissionBuffer::IsTooOld(uint32_t timestamp, uint32_t newestTimestamp) const
 	{
 		MS_TRACE();
 
@@ -501,8 +510,8 @@ namespace RTC
 		return static_cast<uint32_t>(diffTs * 1000 / this->clockRate) > this->maxRetransmissionDelayMs;
 	}
 
-	RetransmissionBuffer::Item* RetransmissionBuffer::FillItem(
-	  RetransmissionBuffer::Item* item,
+	RtpRetransmissionBuffer::Item* RtpRetransmissionBuffer::FillItem(
+	  RtpRetransmissionBuffer::Item* item,
 	  RTC::RtpPacket* packet,
 	  std::shared_ptr<RTC::RtpPacket>& sharedPacket) const
 	{
@@ -530,7 +539,7 @@ namespace RTC
 		return item;
 	}
 
-	void RetransmissionBuffer::Item::Reset()
+	void RtpRetransmissionBuffer::Item::Reset()
 	{
 		MS_TRACE();
 

package/worker/src/RTC/RtpStreamSend.cpp

@@ -15,7 +15,7 @@ namespace RTC
 	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::RetransmissionBuffer::Item*> RetransmissionContainer(
+	thread_local static std::vector<RTC::RtpRetransmissionBuffer::Item*> RetransmissionContainer(
 	  MaxRequestedPackets + 1);
 	static constexpr uint32_t DefaultRtt{ 100u };
 
@@ -58,7 +58,7 @@ namespace RTC
 				}
 			}
 
-			this->retransmissionBuffer = new RTC::RetransmissionBuffer(
+			this->retransmissionBuffer = new RTC::RtpRetransmissionBuffer(
 			  RetransmissionBufferMaxItems, maxRetransmissionDelayMs, params.clockRate);
 		}
 	}

package/worker/test/src/RTC/{TestRetransmissionBuffer.cpp → TestRtpRetransmissionBuffer.cpp}

@@ -1,14 +1,14 @@
 #include "common.hpp"
-#include "RTC/RetransmissionBuffer.hpp"
 #include "RTC/RtpPacket.hpp"
+#include "RTC/RtpRetransmissionBuffer.hpp"
 #include <catch2/catch.hpp>
 #include <vector>
 
 using namespace RTC;
 
-// Class inheriting from RetransmissionBuffer so we can access its protected
+// Class inheriting from RtpRetransmissionBuffer so we can access its protected
 // buffer member.
-class MyRetransmissionBuffer : public RetransmissionBuffer
+class RtpMyRetransmissionBuffer : public RtpRetransmissionBuffer
 {
 public:
 	struct VerificationItem
@@ -19,8 +19,8 @@ public:
 	};
 
 public:
-	MyRetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate)
-	  : RetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate)
+	RtpMyRetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate)
+	  : RtpRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate)
 	{
 	}
 
@@ -43,7 +43,7 @@ public:
 
 		std::shared_ptr<RtpPacket> sharedPacket;
 
-		RetransmissionBuffer::Insert(packet, sharedPacket);
+		RtpRetransmissionBuffer::Insert(packet, sharedPacket);
 	}
 
 	void AssertBuffer(std::vector<VerificationItem> verificationBuffer)
@@ -66,7 +66,7 @@ public:
 	}
 };
 
-SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
+SCENARIO("RtpRetransmissionBuffer", "[rtp][rtx]")
 {
 	SECTION("proper packets received in order")
 	{
@@ -74,7 +74,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		myRetransmissionBuffer.Insert(10001, 1000000000);
 		myRetransmissionBuffer.Insert(10002, 1000000000);
@@ -99,7 +99,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		myRetransmissionBuffer.Insert(20004, 2000000200);
 		myRetransmissionBuffer.Insert(20001, 2000000000);
@@ -124,7 +124,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		myRetransmissionBuffer.Insert(30001, 3000000000);
 		myRetransmissionBuffer.Insert(30002, 3000000000);
@@ -146,7 +146,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		myRetransmissionBuffer.Insert(40002, 4000000002);
 		// Packet must be discarded since its timestamp is lower than in seq 40002.
@@ -184,7 +184,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		myRetransmissionBuffer.Insert(10001, 1000000001);
 		myRetransmissionBuffer.Insert(10002, 1000000002);
@@ -209,7 +209,7 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		uint32_t maxRetransmissionDelayMs{ 2000u };
 		uint32_t clockRate{ 90000 };
 
-		MyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
 
 		auto maxDiffTs = static_cast<uint32_t>(maxRetransmissionDelayMs * clockRate / 1000);
 
@@ -229,4 +229,44 @@ SCENARIO("RetransmissionBuffer", "[rtp][rtx]")
 		);
 		// clang-format on
 	}
+
+	SECTION("fuzzer generated packets")
+	{
+		uint16_t maxItems{ 2500u };
+		uint32_t maxRetransmissionDelayMs{ 2000u };
+		uint32_t clockRate{ 90000 };
+
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+
+		// These packets reproduce an already fixed crash reported here:
+		// https://github.com/versatica/mediasoup/issues/1027#issuecomment-1478464584
+		// I've commented first packets and just left those that produce the crash.
+
+		// myRetransmissionBuffer.Insert(14906, 976891962);
+		// myRetransmissionBuffer.Insert(14906, 976891962);
+		// myRetransmissionBuffer.Insert(14906, 976892730);
+		// myRetransmissionBuffer.Insert(13157, 862283031);
+		// myRetransmissionBuffer.Insert(13114, 859453491);
+		// myRetransmissionBuffer.Insert(14906, 976892264);
+		// myRetransmissionBuffer.Insert(14906, 976897098);
+		// myRetransmissionBuffer.Insert(13114, 859464290);
+		// myRetransmissionBuffer.Insert(14906, 976889088);
+		// myRetransmissionBuffer.Insert(13056, 855638184);
+		// myRetransmissionBuffer.Insert(14906, 976891950);
+		// myRetransmissionBuffer.Insert(17722, 1161443894);
+		// myRetransmissionBuffer.Insert(12846, 841888049);
+		// myRetransmissionBuffer.Insert(14906, 976905830);
+		// myRetransmissionBuffer.Insert(15677, 1027420485);
+		// myRetransmissionBuffer.Insert(33742, 2211317269);
+		// myRetransmissionBuffer.Insert(14906, 976892672);
+		// myRetransmissionBuffer.Insert(13102, 858665774);
+		// myRetransmissionBuffer.Insert(12850, 842150702);
+		// myRetransmissionBuffer.Insert(14906, 976891941);
+		// myRetransmissionBuffer.Insert(15677, 1027423549);
+		// myRetransmissionBuffer.Insert(12346, 809120580);
+		// myRetransmissionBuffer.Insert(12645, 828715313);
+		myRetransmissionBuffer.Insert(12645, 828702743);
+		myRetransmissionBuffer.Insert(33998, 2228092928);
+		myRetransmissionBuffer.Insert(33998, 2228092928);
+	}
 }