mediasoup 3.11.13 → 3.11.15

package/node/lib/Worker.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.11.13",
+  "version": "3.11.15",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -92,15 +92,15 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
-    "@types/jest": "^29.4.0",
-    "@types/node": "^18.14.6",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.5",
     "@types/uuid": "^9.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.54.0",
-    "@typescript-eslint/parser": "^5.54.0",
-    "eslint": "^8.35.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.4.3",
-    "open-cli": "^7.1.0",
+    "jest": "^29.5.0",
+    "open-cli": "^7.2.0",
     "pick-port": "^1.0.1",
     "sctp": "^1.0.0",
     "ts-jest": "^29.0.5",

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/RtpRetransmissionBuffer.hpp

@@ -0,0 +1,68 @@
+#ifndef MS_RTC_RTP_RETRANSMISSION_BUFFER_HPP
+#define MS_RTC_RTP_RETRANSMISSION_BUFFER_HPP
+
+#include "common.hpp"
+#include "RTC/RtpPacket.hpp"
+#include <deque>
+
+namespace RTC
+{
+	// Special container that stores `Item`* elements addressable by their `uint16_t`
+	// sequence number, while only taking as little memory as necessary to store
+	// the range covering a maximum of `MaxRetransmissionDelayForVideoMs` or
+	//  `MaxRetransmissionDelayForAudioMs` ms.
+	class RtpRetransmissionBuffer
+	{
+	public:
+		struct Item
+		{
+			void Reset();
+
+			// Original packet.
+			std::shared_ptr<RTC::RtpPacket> packet{ nullptr };
+			// Correct SSRC since original packet may not have the same.
+			uint32_t ssrc{ 0u };
+			// Correct sequence number since original packet may not have the same.
+			uint16_t sequenceNumber{ 0u };
+			// Correct timestamp since original packet may not have the same.
+			uint32_t timestamp{ 0u };
+			// Last time this packet was resent.
+			uint64_t resentAtMs{ 0u };
+			// Number of times this packet was resent.
+			uint8_t sentTimes{ 0u };
+		};
+
+	public:
+		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);
+		void Clear();
+		void Dump() const;
+
+	private:
+		Item* GetOldest() const;
+		Item* GetNewest() const;
+		void RemoveOldest();
+		void RemoveOldest(uint16_t numItems);
+		void ClearTooOld();
+		bool IsTooOld(uint32_t timestamp, uint32_t newestTimestamp) const;
+		Item* FillItem(
+		  Item* item, RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) const;
+
+	protected:
+		// Make buffer protected for testing purposes.
+		std::deque<Item*> buffer;
+
+	private:
+		// Given as argument.
+		uint16_t maxItems;
+		uint32_t maxRetransmissionDelayMs;
+		uint32_t clockRate;
+		// Others.
+		uint16_t startSeq{ 0u };
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/RtpStream.hpp

@@ -13,6 +13,7 @@
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTCP/XrReceiverReferenceTime.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "RTC/RtpPacket.hpp"
 #include "RTC/RtxStream.hpp"
 #include <nlohmann/json.hpp>
 #include <string>
@@ -180,12 +181,18 @@ namespace RTC
 		Params params;
 		// Others.
 		//   https://tools.ietf.org/html/rfc3550#appendix-A.1 stuff.
-		uint16_t maxSeq{ 0u };      // Highest seq. number seen.
-		uint32_t cycles{ 0u };      // Shifted count of seq. number cycles.
-		uint32_t baseSeq{ 0u };     // Base seq number.
-		uint32_t badSeq{ 0u };      // Last 'bad' seq number + 1.
-		uint32_t maxPacketTs{ 0u }; // Highest timestamp seen.
-		uint64_t maxPacketMs{ 0u }; // When the packet with highest timestammp was seen.
+		// Highest seq. number seen.
+		uint16_t maxSeq{ 0u };
+		// Shifted count of seq. number cycles.
+		uint32_t cycles{ 0u };
+		// Base seq number.
+		uint32_t baseSeq{ 0u };
+		// Last 'bad' seq number + 1.
+		uint32_t badSeq{ 0u };
+		// Highest timestamp seen.
+		uint32_t maxPacketTs{ 0u };
+		// When the packet with highest timestammp was seen.
+		uint64_t maxPacketMs{ 0u };
 		uint32_t packetsLost{ 0u };
 		uint8_t fractionLost{ 0u };
 		size_t packetsDiscarded{ 0u };
@@ -195,12 +202,14 @@ namespace RTC
 		size_t nackPacketCount{ 0u };
 		size_t pliCount{ 0u };
 		size_t firCount{ 0u };
-		size_t repairedPriorScore{ 0u }; // Packets repaired at last interval for score calculation.
-		size_t retransmittedPriorScore{
-			0u
-		}; // Packets retransmitted at last interval for score calculation.
-		uint64_t lastSenderReportNtpMs{ 0u }; // NTP timestamp in last Sender Report (in ms).
-		uint32_t lastSenderReportTs{ 0u };    // RTP timestamp in last Sender Report.
+		// Packets repaired at last interval for score calculation.
+		size_t repairedPriorScore{ 0u };
+		// Packets retransmitted at last interval for score calculation.
+		size_t retransmittedPriorScore{ 0u };
+		// NTP timestamp in last Sender Report (in ms).
+		uint64_t lastSenderReportNtpMs{ 0u };
+		// RTP timestamp in last Sender Report.
+		uint32_t lastSenderReportTs{ 0u };
 		float rtt{ 0 };
 		bool hasRtt{ false };
 		// Instance of RtxStream.

package/worker/include/RTC/RtpStreamRecv.hpp

@@ -93,24 +93,31 @@ namespace RTC
 		// Passed by argument.
 		unsigned int sendNackDelayMs{ 0u };
 		// Others.
-		uint32_t expectedPrior{ 0u };      // Packets expected at last interval.
-		uint32_t expectedPriorScore{ 0u }; // Packets expected at last interval for score calculation.
-		uint32_t receivedPrior{ 0u };      // Packets received at last interval.
-		uint32_t receivedPriorScore{ 0u }; // Packets received at last interval for score calculation.
-		uint32_t lastSrTimestamp{ 0u };    // The middle 32 bits out of 64 in the NTP
-		                                   // timestamp received in the most recent
-		                                   // sender report.
-		uint64_t lastSrReceived{ 0u };     // Wallclock time representing the most recent
-		                                   // sender report arrival.
-		int32_t transit{ 0u };             // Relative transit time for prev packet.
+		// Packets expected at last interval.
+		uint32_t expectedPrior{ 0u };
+		// Packets expected at last interval for score calculation.
+		uint32_t expectedPriorScore{ 0u };
+		// Packets received at last interval.
+		uint32_t receivedPrior{ 0u };
+		// Packets received at last interval for score calculation.
+		uint32_t receivedPriorScore{ 0u };
+		// The middle 32 bits out of 64 in the NTP timestamp received in the most
+		// recent sender report.
+		uint32_t lastSrTimestamp{ 0u };
+		// Wallclock time representing the most recent sender report arrival.
+		uint64_t lastSrReceived{ 0u };
+		// Relative transit time for prev packet.
+		int32_t transit{ 0u };
 		uint32_t jitter{ 0u };
 		uint8_t firSeqNumber{ 0u };
 		uint32_t reportedPacketLost{ 0u };
 		std::unique_ptr<RTC::NackGenerator> nackGenerator;
 		Timer* inactivityCheckPeriodicTimer{ nullptr };
 		bool inactive{ false };
-		TransmissionCounter transmissionCounter;      // Valid media + valid RTX.
-		RTC::RtpDataCounter mediaTransmissionCounter; // Just valid media.
+		// Valid media + valid RTX.
+		TransmissionCounter transmissionCounter;
+		// Just valid media.
+		RTC::RtpDataCounter mediaTransmissionCounter;
 	};
 } // namespace RTC
 

package/worker/include/RTC/RtpStreamSend.hpp

@@ -2,16 +2,14 @@
 #define MS_RTC_RTP_STREAM_SEND_HPP
 
 #include "RTC/RateCalculator.hpp"
+#include "RTC/RtpRetransmissionBuffer.hpp"
 #include "RTC/RtpStream.hpp"
-#include <deque>
 
 namespace RTC
 {
 	class RtpStreamSend : public RTC::RtpStream
 	{
 	public:
-		// Minimum retransmission buffer size (ms).
-		const static uint32_t MinRetransmissionDelayMs;
 		// Maximum retransmission buffer size for video (ms).
 		const static uint32_t MaxRetransmissionDelayForVideoMs;
 		// Maximum retransmission buffer size for audio (ms).
@@ -25,47 +23,6 @@ namespace RTC
 			  RTC::RtpStreamSend* rtpStream, RTC::RtpPacket* packet) = 0;
 		};
 
-	public:
-		struct StorageItem
-		{
-			void Reset();
-
-			// Original packet.
-			std::shared_ptr<RTC::RtpPacket> packet{ nullptr };
-			// Correct SSRC since original packet may not have the same.
-			uint32_t ssrc{ 0 };
-			// Correct sequence number since original packet may not have the same.
-			uint16_t sequenceNumber{ 0 };
-			// Correct timestamp since original packet may not have the same.
-			uint32_t timestamp{ 0 };
-			// Last time this packet was resent.
-			uint64_t resentAtMs{ 0u };
-			// Number of times this packet was resent.
-			uint8_t sentTimes{ 0u };
-		};
-
-	private:
-		// Special container that stores `StorageItem*` elements addressable by
-		// their `uint16_t` sequence number, while only taking as little memory as
-		// necessary to store the range covering a maximum of
-		// MaxRetransmissionDelayForVideoMs or MaxRetransmissionDelayForAudioMs ms.
-		class StorageItemBuffer
-		{
-		public:
-			~StorageItemBuffer();
-
-			StorageItem* GetFirst() const;
-			StorageItem* Get(uint16_t seq) const;
-			size_t GetBufferSize() const;
-			void Insert(uint16_t seq, StorageItem* storageItem);
-			void RemoveFirst();
-			void Clear();
-
-		private:
-			uint16_t startSeq{ 0 };
-			std::deque<StorageItem*> buffer;
-		};
-
 	public:
 		RtpStreamSend(
 		  RTC::RtpStreamSend::Listener* listener, RTC::RtpStream::Params& params, std::string& mid);
@@ -93,25 +50,24 @@ namespace RTC
 
 	private:
 		void StorePacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket);
-		void ClearOldPackets(const RtpPacket* packet);
-		void ClearBuffer();
 		void FillRetransmissionContainer(uint16_t seq, uint16_t bitmask);
 		void UpdateScore(RTC::RTCP::ReceiverReport* report);
 
 	private:
-		uint32_t lostPriorScore{ 0u }; // Packets lost at last interval for score calculation.
-		uint32_t sentPriorScore{ 0u }; // Packets sent at last interval for score calculation.
-		StorageItemBuffer storageItemBuffer;
+		// Packets lost at last interval for score calculation.
+		uint32_t lostPriorScore{ 0u };
+		// Packets sent at last interval for score calculation.
+		uint32_t sentPriorScore{ 0u };
 		std::string mid;
-		uint32_t maxRetransmissionDelayMs;
-		uint32_t retransmissionBufferSize;
 		uint16_t rtxSeq{ 0u };
 		RTC::RtpDataCounter transmissionCounter;
-		uint32_t lastRrTimestamp{ 0u };  // The middle 32 bits out of 64 in the NTP
-		                                 // timestamp received in the most recent
-		                                 // receiver reference timestamp.
-		uint64_t lastRrReceivedMs{ 0u }; // Wallclock time representing the most recent
-		                                 // receiver reference timestamp arrival.
+		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 };
+		// Wallclock time representing the most recent receiver reference timestamp
+		// arrival.
+		uint64_t lastRrReceivedMs{ 0u };
 	};
 } // namespace RTC
 

package/worker/include/common.hpp

@@ -9,7 +9,7 @@
 #include <memory>     // std::addressof()
 #ifdef _WIN32
 #include <winsock2.h>
-// avoid uv/win.h: error C2628 'intptr_t' followed by 'int' is illegal.
+// Avoid uv/win.h: error C2628 'intptr_t' followed by 'int' is illegal.
 #if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)
 #include <BaseTsd.h>
 typedef SSIZE_T ssize_t;
@@ -25,15 +25,17 @@ typedef SSIZE_T ssize_t;
 
 using ChannelReadCtx    = void*;
 using ChannelReadFreeFn = void (*)(uint8_t*, uint32_t, size_t);
-// Returns `ChannelReadFree` on successful read that must be used to free `message`.
+// Returns `ChannelReadFree` on successful read that must be used to free
+// `message`.
 using ChannelReadFn = ChannelReadFreeFn (*)(
   uint8_t** /* message */,
   uint32_t* /* messageLen */,
   size_t* /* messageCtx */,
-  // This is `uv_async_t` handle that can be called later with `uv_async_send()` when there is more
-  // data to read.
+  // This is `uv_async_t` handle that can be called later with `uv_async_send()`
+  // when there is more data to read.
   const void* /* handle */,
-  ChannelReadCtx /* ctx */);
+  ChannelReadCtx /* ctx */
+);
 
 using ChannelWriteCtx = void*;
 using ChannelWriteFn =
@@ -41,7 +43,8 @@ using ChannelWriteFn =
 
 using PayloadChannelReadCtx    = void*;
 using PayloadChannelReadFreeFn = void (*)(uint8_t*, uint32_t, size_t);
-// Returns `PayloadChannelReadFree` on successful read that must be used to free `message` and `payload`.
+// Returns `PayloadChannelReadFree` on successful read that must be used to free
+// `message` and `payload`.
 using PayloadChannelReadFn = PayloadChannelReadFreeFn (*)(
   uint8_t** /* message */,
   uint32_t* /* messageLen */,
@@ -49,8 +52,8 @@ using PayloadChannelReadFn = PayloadChannelReadFreeFn (*)(
   uint8_t** /* payload */,
   uint32_t* /* payloadLen */,
   size_t* /* payloadCapacity */,
-  // This is `uv_async_t` handle that can be called later with `uv_async_send()` when there is more
-  // data to read.
+  // This is `uv_async_t` handle that can be called later with `uv_async_send()`
+  // when there is more data to read.
   const void* /* handle */,
   PayloadChannelReadCtx /* ctx */);
 

package/worker/meson.build

@@ -89,6 +89,7 @@ common_sources = [
   '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',
@@ -289,6 +290,7 @@ mediasoup_worker_test = executable(
     'test/src/RTC/TestRateCalculator.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',
@@ -352,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',