mediasoup 3.13.4 → 3.13.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.13.4",
+  "version": "3.13.5",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -105,8 +105,8 @@
   "devDependencies": {
     "@octokit/rest": "^20.0.2",
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.9",
-    "@types/node": "^20.9.3",
+    "@types/jest": "^29.5.10",
+    "@types/node": "^20.9.4",
     "@typescript-eslint/eslint-plugin": "^6.12.0",
     "@typescript-eslint/parser": "^6.12.0",
     "eslint": "^8.54.0",

package/worker/include/RTC/RTCP/CompoundPacket.hpp

@@ -48,14 +48,16 @@ namespace RTC
 			// Adds the given data and returns true if there is enough space to hold it,
 			// false otherwise.
 			bool Add(
-			  SenderReport* senderReport, SdesChunk* sdesChunk, DelaySinceLastRr* delaySinceLastRrReport);
+			  SenderReport* senderReport,
+			  SdesChunk* sdesChunk,
+			  DelaySinceLastRr::SsrcInfo* delaySinceLastRrSsrcInfo);
 			// RTCP additions per Consumer (pipe).
 			// Adds the given data and returns true if there is enough space to hold it,
 			// false otherwise.
 			bool Add(
 			  std::vector<SenderReport*>& senderReports,
 			  std::vector<SdesChunk*>& sdesChunks,
-			  std::vector<DelaySinceLastRr*>& delaySinceLastRrReports);
+			  std::vector<DelaySinceLastRr::SsrcInfo*>& delaySinceLastRrSsrcInfos);
 			// RTCP additions per Producer.
 			// Adds the given data and returns true if there is enough space to hold it,
 			// false otherwise.
@@ -63,8 +65,6 @@ namespace RTC
 			void AddSenderReport(SenderReport* report);
 			void AddReceiverReport(ReceiverReport* report);
 			void AddSdesChunk(SdesChunk* chunk);
-			void AddReceiverReferenceTime(ReceiverReferenceTime* report);
-			void AddDelaySinceLastRr(DelaySinceLastRr* report);
 			bool HasSenderReport()
 			{
 				return this->senderReportPacket.Begin() != this->senderReportPacket.End();
@@ -77,6 +77,14 @@ namespace RTC
 				  [](const ExtendedReportBlock* report)
 				  { return report->GetType() == ExtendedReportBlock::Type::RRT; });
 			}
+			bool HasDelaySinceLastRr()
+			{
+				return std::any_of(
+				  this->xrPacket.Begin(),
+				  this->xrPacket.End(),
+				  [](const ExtendedReportBlock* report)
+				  { return report->GetType() == ExtendedReportBlock::Type::DLRR; });
+			}
 			void Serialize(uint8_t* data);
 
 		private:
@@ -85,6 +93,7 @@ namespace RTC
 			ReceiverReportPacket receiverReportPacket;
 			SdesPacket sdesPacket;
 			ExtendedReportPacket xrPacket;
+			DelaySinceLastRr* delaySinceLastRr{ nullptr };
 		};
 	} // namespace RTCP
 } // namespace RTC

package/worker/include/RTC/RTCP/Sdes.hpp

@@ -214,7 +214,7 @@ namespace RTC
 				// A serialized packet can contain a maximum of 31 chunks.
 				// If number of chunks exceeds 31 then the required number of packets
 				// will be serialized which will take the size calculated below.
-				size_t size = Packet::CommonHeaderSize * ((this->GetCount() / MaxChunksPerPacket) + 1);
+				size_t size = Packet::CommonHeaderSize * ((this->GetCount() / (MaxChunksPerPacket + 1)) + 1);
 
 				for (auto* chunk : this->chunks)
 				{

package/worker/include/RTC/RTCP/XrDelaySinceLastRr.hpp

@@ -119,6 +119,19 @@ namespace RTC
 			{
 				this->ssrcInfos.push_back(ssrcInfo);
 			}
+			// NOTE: This method not only removes given number of ssrc info sub-blocks
+			// but also deletes their SsrcInfo instances.
+			void RemoveLastSsrcInfos(size_t number)
+			{
+				while (!this->ssrcInfos.empty() && number-- > 0)
+				{
+					auto* ssrcInfo = this->ssrcInfos.back();
+
+					this->ssrcInfos.pop_back();
+
+					delete ssrcInfo;
+				}
+			}
 			Iterator Begin()
 			{
 				return this->ssrcInfos.begin();

package/worker/include/RTC/RtpStreamSend.hpp

@@ -37,7 +37,7 @@ namespace RTC
 		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
 		void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report);
 		RTC::RTCP::SenderReport* GetRtcpSenderReport(uint64_t nowMs);
-		RTC::RTCP::DelaySinceLastRr::SsrcInfo* GetRtcpXrDelaySinceLastRr(uint64_t nowMs);
+		RTC::RTCP::DelaySinceLastRr::SsrcInfo* GetRtcpXrDelaySinceLastRrSsrcInfo(uint64_t nowMs);
 		RTC::RTCP::SdesChunk* GetRtcpSdesChunk();
 		void Pause() override;
 		void Resume() override;

package/worker/src/RTC/PipeConsumer.cpp

@@ -345,7 +345,7 @@ namespace RTC
 
 		std::vector<RTCP::SenderReport*> senderReports;
 		std::vector<RTCP::SdesChunk*> sdesChunks;
-		std::vector<RTCP::DelaySinceLastRr*> xrReports;
+		std::vector<RTCP::DelaySinceLastRr::SsrcInfo*> delaySinceLastRrSsrcInfos;
 
 		for (auto* rtpStream : this->rtpStreams)
 		{
@@ -362,19 +362,16 @@ namespace RTC
 			auto* sdesChunk = rtpStream->GetRtcpSdesChunk();
 			sdesChunks.push_back(sdesChunk);
 
-			auto* dlrr = rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
+			auto* delaySinceLastRrSsrcInfo = rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowMs);
 
-			if (dlrr)
+			if (delaySinceLastRrSsrcInfo)
 			{
-				auto* report = new RTC::RTCP::DelaySinceLastRr();
-				report->AddSsrcInfo(dlrr);
-
-				xrReports.push_back(report);
+				delaySinceLastRrSsrcInfos.push_back(delaySinceLastRrSsrcInfo);
 			}
 		}
 
 		// RTCP Compound packet buffer cannot hold the data.
-		if (!packet->Add(senderReports, sdesChunks, xrReports))
+		if (!packet->Add(senderReports, sdesChunks, delaySinceLastRrSsrcInfos))
 		{
 			return false;
 		}

package/worker/src/RTC/RTCP/CompoundPacket.cpp

@@ -72,7 +72,9 @@ namespace RTC
 		}
 
 		bool CompoundPacket::Add(
-		  SenderReport* senderReport, SdesChunk* sdesChunk, DelaySinceLastRr* delaySinceLastRrReport)
+		  SenderReport* senderReport,
+		  SdesChunk* sdesChunk,
+		  DelaySinceLastRr::SsrcInfo* delaySinceLastRrSsrcInfo)
 		{
 			// Add the items into the packet.
 
@@ -86,9 +88,16 @@ namespace RTC
 				this->sdesPacket.AddChunk(sdesChunk);
 			}
 
-			if (delaySinceLastRrReport)
+			if (delaySinceLastRrSsrcInfo)
 			{
-				this->xrPacket.AddReport(delaySinceLastRrReport);
+				// Add a DLRR block into the XR packet if no present.
+				if (!this->delaySinceLastRr)
+				{
+					this->delaySinceLastRr = new RTC::RTCP::DelaySinceLastRr();
+					this->xrPacket.AddReport(this->delaySinceLastRr);
+				}
+
+				this->delaySinceLastRr->AddSsrcInfo(delaySinceLastRrSsrcInfo);
 			}
 
 			// New items can hold in the packet, report it.
@@ -112,10 +121,10 @@ namespace RTC
 				delete sdesChunk;
 			}
 
-			if (delaySinceLastRrReport)
+			if (delaySinceLastRrSsrcInfo)
 			{
-				this->xrPacket.RemoveReport(delaySinceLastRrReport);
-				delete delaySinceLastRrReport;
+				// NOTE: This method deletes the removed instances in place.
+				this->delaySinceLastRr->RemoveLastSsrcInfos(1);
 			}
 
 			return false;
@@ -124,7 +133,7 @@ namespace RTC
 		bool CompoundPacket::Add(
 		  std::vector<SenderReport*>& senderReports,
 		  std::vector<SdesChunk*>& sdesChunks,
-		  std::vector<DelaySinceLastRr*>& delaySinceLastRrReports)
+		  std::vector<DelaySinceLastRr::SsrcInfo*>& delaySinceLastRrSsrcInfos)
 		{
 			// Add the items into the packet.
 
@@ -138,9 +147,16 @@ namespace RTC
 				this->sdesPacket.AddChunk(chunk);
 			}
 
-			for (auto* report : delaySinceLastRrReports)
+			// Add a DLRR block into the XR packet if no present.
+			if (!delaySinceLastRrSsrcInfos.empty() && !this->delaySinceLastRr)
 			{
-				this->xrPacket.AddReport(report);
+				this->delaySinceLastRr = new RTC::RTCP::DelaySinceLastRr();
+				this->xrPacket.AddReport(this->delaySinceLastRr);
+			}
+
+			for (auto* ssrcInfo : delaySinceLastRrSsrcInfos)
+			{
+				this->delaySinceLastRr->AddSsrcInfo(ssrcInfo);
 			}
 
 			// New items can hold in the packet, report it.
@@ -164,10 +180,10 @@ namespace RTC
 				delete chunk;
 			}
 
-			for (auto* report : delaySinceLastRrReports)
+			if (!delaySinceLastRrSsrcInfos.empty())
 			{
-				this->xrPacket.RemoveReport(report);
-				delete report;
+				// NOTE: This method deletes the instances in place.
+				this->delaySinceLastRr->RemoveLastSsrcInfos(delaySinceLastRrSsrcInfos.size());
 			}
 
 			return false;
@@ -266,19 +282,5 @@ namespace RTC
 
 			this->sdesPacket.AddChunk(chunk);
 		}
-
-		void CompoundPacket::AddReceiverReferenceTime(ReceiverReferenceTime* report)
-		{
-			MS_TRACE();
-
-			this->xrPacket.AddReport(report);
-		}
-
-		void CompoundPacket::AddDelaySinceLastRr(DelaySinceLastRr* report)
-		{
-			MS_TRACE();
-
-			this->xrPacket.AddReport(report);
-		}
 	} // namespace RTCP
 } // namespace RTC

package/worker/src/RTC/RtpStreamSend.cpp

@@ -274,7 +274,7 @@ namespace RTC
 		return report;
 	}
 
-	RTC::RTCP::DelaySinceLastRr::SsrcInfo* RtpStreamSend::GetRtcpXrDelaySinceLastRr(uint64_t nowMs)
+	RTC::RTCP::DelaySinceLastRr::SsrcInfo* RtpStreamSend::GetRtcpXrDelaySinceLastRrSsrcInfo(uint64_t nowMs)
 	{
 		MS_TRACE();
 

package/worker/src/RTC/SimpleConsumer.cpp

@@ -439,18 +439,10 @@ namespace RTC
 		// Build SDES chunk for this sender.
 		auto* sdesChunk = this->rtpStream->GetRtcpSdesChunk();
 
-		RTC::RTCP::DelaySinceLastRr* delaySinceLastRrReport{ nullptr };
-
-		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
-
-		if (dlrr)
-		{
-			delaySinceLastRrReport = new RTC::RTCP::DelaySinceLastRr();
-			delaySinceLastRrReport->AddSsrcInfo(dlrr);
-		}
+		auto* delaySinceLastRrSsrcInfo = this->rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowMs);
 
 		// RTCP Compound packet buffer cannot hold the data.
-		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrReport))
+		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrSsrcInfo))
 		{
 			return false;
 		}

package/worker/src/RTC/SimulcastConsumer.cpp

@@ -1081,18 +1081,10 @@ namespace RTC
 		// Build SDES chunk for this sender.
 		auto* sdesChunk = this->rtpStream->GetRtcpSdesChunk();
 
-		RTC::RTCP::DelaySinceLastRr* delaySinceLastRrReport{ nullptr };
-
-		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
-
-		if (dlrr)
-		{
-			delaySinceLastRrReport = new RTC::RTCP::DelaySinceLastRr();
-			delaySinceLastRrReport->AddSsrcInfo(dlrr);
-		}
+		auto* delaySinceLastRrSsrcInfo = this->rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowMs);
 
 		// RTCP Compound packet buffer cannot hold the data.
-		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrReport))
+		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrSsrcInfo))
 		{
 			return false;
 		}

package/worker/src/RTC/SvcConsumer.cpp

@@ -795,18 +795,10 @@ namespace RTC
 		// Build SDES chunk for this sender.
 		auto* sdesChunk = this->rtpStream->GetRtcpSdesChunk();
 
-		RTC::RTCP::DelaySinceLastRr* delaySinceLastRrReport{ nullptr };
-
-		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
-
-		if (dlrr)
-		{
-			delaySinceLastRrReport = new RTC::RTCP::DelaySinceLastRr();
-			delaySinceLastRrReport->AddSsrcInfo(dlrr);
-		}
+		auto* delaySinceLastRrSsrcInfo = this->rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowMs);
 
 		// RTCP Compound packet buffer cannot hold the data.
-		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrReport))
+		if (!packet->Add(senderReport, sdesChunk, delaySinceLastRrSsrcInfo))
 		{
 			return false;
 		}

package/worker/test/src/RTC/Codecs/TestVP8.cpp

@@ -1,7 +1,7 @@
 #include "common.hpp"
 #include "RTC/Codecs/VP8.hpp"
 #include <catch2/catch.hpp>
-#include <cstring> // std::memcmp()
+#include <cstring> // std::memcmp(), std::memcpy()
 
 using namespace RTC;
 

package/worker/test/src/RTC/RTCP/TestSdes.cpp

@@ -1,4 +1,5 @@
 #include "common.hpp"
+#include "RTC/RTCP/Packet.hpp"
 #include "RTC/RTCP/Sdes.hpp"
 #include <catch2/catch.hpp>
 #include <cstring> // std::memcmp()
@@ -383,40 +384,118 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 		REQUIRE(!packet);
 	}
 
+	SECTION("create SDES packet with 31 chunks")
+	{
+		const size_t count = 31;
+
+		SdesPacket packet;
+		// Create a chunk and an item to obtain their size.
+		SdesChunk* chunk = new SdesChunk(1234 /*ssrc*/);
+		auto* item1 =
+		  new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, item1Value.size(), item1Value.c_str());
+
+		chunk->AddItem(item1);
+
+		auto chunkSize = chunk->GetSize();
+
+		delete chunk;
+
+		for (auto i{ 1 }; i <= count; ++i)
+		{
+			// Create chunk and add to packet.
+			SdesChunk* chunk = new SdesChunk(i /*ssrc*/);
+
+			auto* item1 =
+			  new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, item1Value.size(), item1Value.c_str());
+
+			chunk->AddItem(item1);
+
+			packet.AddChunk(chunk);
+		}
+
+		REQUIRE(packet.GetCount() == count);
+		REQUIRE(packet.GetSize() == Packet::CommonHeaderSize + (count * chunkSize));
+
+		uint8_t buffer1[1500] = { 0 };
+
+		// Serialization must contain 1 SDES packet since report count doesn't
+		// exceed 31.
+		packet.Serialize(buffer1);
+
+		auto* packet2 = static_cast<SdesPacket*>(Packet::Parse(buffer1, sizeof(buffer1)));
+
+		REQUIRE(packet2 != nullptr);
+		REQUIRE(packet2->GetCount() == count);
+		REQUIRE(packet2->GetSize() == Packet::CommonHeaderSize + (count * chunkSize));
+
+		auto reportIt = packet2->Begin();
+
+		for (auto i{ 1 }; i <= 31; ++i, reportIt++)
+		{
+			auto* chunk = *reportIt;
+
+			REQUIRE(chunk->GetSsrc() == i);
+
+			auto* item = *(chunk->Begin());
+
+			REQUIRE(item->GetType() == SdesItem::Type::CNAME);
+			REQUIRE(item->GetSize() == 2 + item1Value.size());
+			REQUIRE(std::string(item->GetValue()) == item1Value);
+		}
+
+		SdesPacket* packet3 = static_cast<SdesPacket*>(packet2->GetNext());
+
+		REQUIRE(packet3 == nullptr);
+
+		delete packet3;
+	}
+
 	SECTION("create SDES packet with more than 31 chunks")
 	{
 		const size_t count = 33;
 
 		SdesPacket packet;
+		// Create a chunk and an item to obtain their size.
+		SdesChunk* chunk = new SdesChunk(1234 /*ssrc*/);
+		auto* item1 =
+		  new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, item1Value.size(), item1Value.c_str());
+
+		chunk->AddItem(item1);
+
+		auto chunkSize = chunk->GetSize();
+
+		delete chunk;
 
-		for (auto i = 1; i <= count; i++)
+		for (auto i{ 1 }; i <= count; ++i)
 		{
 			// Create chunk and add to packet.
-			SdesChunk* chunk1 = new SdesChunk(i /*ssrc*/);
+			SdesChunk* chunk = new SdesChunk(i /*ssrc*/);
 
 			auto* item1 =
 			  new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, item1Value.size(), item1Value.c_str());
 
-			chunk1->AddItem(item1);
+			chunk->AddItem(item1);
 
-			packet.AddChunk(chunk1);
+			packet.AddChunk(chunk);
 		}
 
 		REQUIRE(packet.GetCount() == count);
+		REQUIRE(packet.GetSize() == Packet::CommonHeaderSize + (31 * chunkSize) + Packet::CommonHeaderSize + ((count - 31) * chunkSize));
 
 		uint8_t buffer1[1500] = { 0 };
 
-		// Serialization must contain 2 RR packets since report count exceeds 31.
+		// Serialization must contain 2 SDES packets since report count exceeds 31.
 		packet.Serialize(buffer1);
 
 		auto* packet2 = static_cast<SdesPacket*>(Packet::Parse(buffer1, sizeof(buffer1)));
 
 		REQUIRE(packet2 != nullptr);
 		REQUIRE(packet2->GetCount() == 31);
+		REQUIRE(packet2->GetSize() == Packet::CommonHeaderSize + (31 * chunkSize));
 
 		auto reportIt = packet2->Begin();
 
-		for (auto i = 1; i <= 31; i++, reportIt++)
+		for (auto i{ 1 }; i <= 31; ++i, reportIt++)
 		{
 			auto* chunk = *reportIt;
 
@@ -432,11 +511,12 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 		SdesPacket* packet3 = static_cast<SdesPacket*>(packet2->GetNext());
 
 		REQUIRE(packet3 != nullptr);
-		REQUIRE(packet3->GetCount() == 2);
+		REQUIRE(packet3->GetCount() == count - 31);
+		REQUIRE(packet3->GetSize() == Packet::CommonHeaderSize + ((count - 31) * chunkSize));
 
 		reportIt = packet3->Begin();
 
-		for (auto i = 1; i <= 2; i++, reportIt++)
+		for (auto i{ 1 }; i <= 2; ++i, reportIt++)
 		{
 			auto* chunk = *reportIt;
 

package/worker/test/src/RTC/RTCP/TestXr.cpp

@@ -3,7 +3,7 @@
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTCP/XrReceiverReferenceTime.hpp"
 #include <catch2/catch.hpp>
-#include <cstring> // std::memcmp
+#include <cstring> // std::memcmp(), std::memcpy()
 
 using namespace RTC::RTCP;
 
@@ -12,7 +12,7 @@ SCENARIO("RTCP XR parsing", "[parser][rtcp][xr]")
 	// clang-format off
 	uint8_t buffer[] =
 	{
-		0xa0, 0xcf, 0x00, 0x08, // Padding, Type: 207 (XR), Length: 8
+		0xa0, 0xcf, 0x00, 0x09, // Padding, Type: 207 (XR), Length: 9
 		0x5d, 0x93, 0x15, 0x34, // Sender SSRC: 0x5d931534
 		// Extended Report DLRR
 		0x05, 0x00, 0x00, 0x06, // BT: 5 (DLRR), Block Length: 6
@@ -33,6 +33,7 @@ SCENARIO("RTCP XR parsing", "[parser][rtcp][xr]")
 		REQUIRE(packet);
 		// Despite total buffer size is 40 bytes, our GetSize() method doesn't not
 		// consider RTCP padding (4 bytes in this case).
+		// https://github.com/versatica/mediasoup/issues/1233
 		REQUIRE(packet->GetSize() == 36);
 		REQUIRE(packet->GetCount() == 0);
 		REQUIRE(packet->GetSsrc() == 0x5d931534);
@@ -89,6 +90,40 @@ SCENARIO("RTCP XR parsing", "[parser][rtcp][xr]")
 		// There are 1 block (the DLRR block).
 		REQUIRE(blockIdx == 1);
 
+		SECTION("serialize packet instance")
+		{
+			// NOTE: Padding in RTCP is removed (if not needed) when serializing the
+			// packet, so we must mangle the buffer content (padding bit) and the
+			// buffer length before comparing the serialized packet with and original
+			// buffer.
+
+			const size_t paddingBytes{ 4 };
+			const size_t serializedBufferLength        = sizeof(buffer) - paddingBytes;
+			uint8_t serialized[serializedBufferLength] = { 0 };
+
+			// Clone the original buffer into a new buffer without padding.
+			uint8_t clonedBuffer[serializedBufferLength] = { 0 };
+			std::memcpy(clonedBuffer, buffer, serializedBufferLength);
+
+			// Remove the padding bit in the first byte of the cloned buffer.
+			clonedBuffer[0] = 0x80;
+
+			// Change RTCP length field in the cloned buffer.
+			clonedBuffer[3] = clonedBuffer[3] - 1;
+
+			packet->Serialize(serialized);
+
+			auto* packet2 = ExtendedReportPacket::Parse(serialized, serializedBufferLength);
+
+			REQUIRE(packet2->GetType() == Type::XR);
+			REQUIRE(packet2->GetCount() == 0);
+			REQUIRE(packet2->GetSize() == 36);
+
+			REQUIRE(std::memcmp(clonedBuffer, serialized, serializedBufferLength) == 0);
+
+			delete packet2;
+		}
+
 		delete packet;
 	}
 }