mediasoup 3.13.3 → 3.13.5

package/node/lib/ortc.js

@@ -656,7 +656,7 @@ function getConsumableRtpParameters(kind, params, caps, rtpMapping) {
             payloadType: matchedCapCodec.preferredPayloadType,
             clockRate: matchedCapCodec.clockRate,
             channels: matchedCapCodec.channels,
-            parameters: codec.parameters,
+            parameters: codec.parameters, // Keep the Producer codec parameters.
             rtcpFeedback: matchedCapCodec.rtcpFeedback
         };
         consumableParams.codecs.push(consumableCodec);

package/node/lib/tests/test-Consumer.js

@@ -185,13 +185,13 @@ const consumerDeviceCapabilities = {
         },
         {
             kind: 'audio',
-            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
+            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time', // eslint-disable-line max-len
             preferredId: 4,
             preferredEncrypt: false
         },
         {
             kind: 'video',
-            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
+            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time', // eslint-disable-line max-len
             preferredId: 4,
             preferredEncrypt: false
         },

package/node/lib/tests/test-multiopus.js

@@ -73,7 +73,7 @@ const consumerDeviceCapabilities = {
         },
         {
             kind: 'audio',
-            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
+            uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time', // eslint-disable-line max-len
             preferredId: 4,
             preferredEncrypt: false
         },

package/node/lib/tests/test-node-sctp.js

@@ -19,8 +19,8 @@ beforeAll(async () => {
     worker = await mediasoup.createWorker();
     router = await worker.createRouter();
     transport = await router.createPlainTransport({
-        listenIp: '127.0.0.1',
-        comedia: true,
+        listenIp: '127.0.0.1', // https://github.com/nodejs/node/issues/14900
+        comedia: true, // So we don't need to call transport.connect().
         enableSctp: true,
         numSctpStreams: { OS: 256, MIS: 256 }
     });
@@ -40,8 +40,8 @@ beforeAll(async () => {
                     return;
                 }
                 sctpSocket = sctp.connect({
-                    localPort: 5000,
-                    port: 5000,
+                    localPort: 5000, // Required for SCTP over UDP in mediasoup.
+                    port: 5000, // Required for SCTP over UDP in mediasoup.
                     OS: OS,
                     MIS: MIS,
                     udpTransport: udpSocket
@@ -53,8 +53,8 @@ beforeAll(async () => {
     // Use UDP disconnected socket if Node < 12.
     else {
         sctpSocket = sctp.connect({
-            localPort: 5000,
-            port: 5000,
+            localPort: 5000, // Required for SCTP over UDP in mediasoup.
+            port: 5000, // Required for SCTP over UDP in mediasoup.
             OS: OS,
             MIS: MIS,
             udpTransport: udpSocket,

package/node/lib/tests/test-ortc.js

@@ -17,7 +17,7 @@ test('generateRouterRtpCapabilities() succeeds', () => {
         {
             kind: 'video',
             mimeType: 'video/VP8',
-            preferredPayloadType: 125,
+            preferredPayloadType: 125, // Let's force it.
             clockRate: 90000
         },
         {
@@ -38,7 +38,7 @@ test('generateRouterRtpCapabilities() succeeds', () => {
     expect(rtpCapabilities.codecs?.[0]).toEqual({
         kind: 'audio',
         mimeType: 'audio/opus',
-        preferredPayloadType: 100,
+        preferredPayloadType: 100, // 100 is the first available dynamic PT.
         clockRate: 48000,
         channels: 2,
         parameters: {
@@ -69,7 +69,7 @@ test('generateRouterRtpCapabilities() succeeds', () => {
     expect(rtpCapabilities.codecs?.[2]).toEqual({
         kind: 'video',
         mimeType: 'video/rtx',
-        preferredPayloadType: 101,
+        preferredPayloadType: 101, // 101 is the second available dynamic PT.
         clockRate: 90000,
         parameters: {
             apt: 125
@@ -80,7 +80,7 @@ test('generateRouterRtpCapabilities() succeeds', () => {
     expect(rtpCapabilities.codecs?.[3]).toEqual({
         kind: 'video',
         mimeType: 'video/H264',
-        preferredPayloadType: 102,
+        preferredPayloadType: 102, // 102 is the third available dynamic PT.
         clockRate: 90000,
         parameters: {
             // Since packetization-mode param was not included in the H264 codec

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.13.3",
+  "version": "3.13.5",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -26,7 +26,7 @@
     "worker/fuzzer/include",
     "worker/fuzzer/src",
     "worker/include",
-    "worker/scripts/*.js",
+    "worker/scripts/*.mjs",
     "worker/scripts/*.json",
     "worker/scripts/*.py",
     "worker/scripts/*.sh",
@@ -105,10 +105,10 @@
   "devDependencies": {
     "@octokit/rest": "^20.0.2",
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.8",
-    "@types/node": "^20.9.2",
-    "@typescript-eslint/eslint-plugin": "^6.11.0",
-    "@typescript-eslint/parser": "^6.11.0",
+    "@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",
     "eslint-plugin-jest": "^27.6.0",
     "jest": "^29.7.0",
@@ -117,6 +117,6 @@
     "pick-port": "^1.0.1",
     "sctp": "^1.0.0",
     "ts-jest": "^29.1.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.2"
   }
 }

package/worker/Makefile

@@ -213,7 +213,7 @@ libmediasoup-worker: setup flatc
 flatc: setup
 	$(MESON) compile -C $(BUILD_DIR) flatbuffers-generator
 
-xcode: setup
+xcode: setup flatc
 	$(MESON) setup --buildtype debug --backend xcode $(MEDIASOUP_OUT_DIR)/xcode
 
 lint:
@@ -234,7 +234,7 @@ else
 	$(BUILD_DIR)/mediasoup-worker-test --invisibles --use-colour=yes $(MEDIASOUP_TEST_TAGS)
 endif
 
-test-asan: setup
+test-asan: setup flatc
 	$(MESON) compile -C $(BUILD_DIR) -j $(CORES) mediasoup-worker-test-asan
 	$(MESON) install -C $(BUILD_DIR) --no-rebuild --tags mediasoup-worker-test-asan
 	ASAN_OPTIONS=detect_leaks=1 $(BUILD_DIR)/mediasoup-worker-test-asan --invisibles --use-colour=yes $(MEDIASOUP_TEST_TAGS)
@@ -249,7 +249,7 @@ tidy:
 		-checks=$(MEDIASOUP_TIDY_CHECKS) \
 		-quiet
 
-fuzzer: setup
+fuzzer: setup flatc
 	$(MESON) compile -C $(BUILD_DIR) -j $(CORES) mediasoup-worker-fuzzer
 	$(MESON) install -C $(BUILD_DIR) --no-rebuild --tags mediasoup-worker-fuzzer
 

package/worker/deps/libwebrtc/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc

@@ -289,6 +289,8 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
     if (payload_size > kMinProbePacketSize &&
         (!remote_rate_.ValidEstimate() ||
          now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs)) {
+
+#if MS_LOG_DEV_LEVEL == 3
       // TODO(holmer): Use a map instead to get correct order?
       if (total_probes_received_ < kMaxProbePackets) {
         int send_delta_ms = -1;
@@ -306,6 +308,8 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
             send_delta_ms,
             recv_delta_ms);
       }
+#endif
+
       probes_.push_back(Probe(send_time_ms, arrival_time_ms, payload_size));
       ++total_probes_received_;
       // Make sure that a probe which updated the bitrate immediately has an

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/scripts/clang-format.mjs

@@ -0,0 +1,89 @@
+import { execSync } from 'node:child_process';
+import { glob } from 'glob';
+import clangFormat from 'clang-format';
+
+const task = process.argv.slice(2).join(' ');
+
+run();
+
+async function run()
+{
+	const clangFormatNativeBinary = clangFormat.getNativeBinary();
+	const workerFiles = await glob(
+		[
+			'../src/**/*.cpp',
+			'../include/**/*.hpp',
+			'../test/src/**/*.cpp',
+			'../test/include/helpers.hpp',
+			'../fuzzer/src/**/*.cpp',
+			'../fuzzer/include/**/*.hpp'
+		]
+	);
+
+	switch (task)
+	{
+		case 'lint':
+		{
+			executeCmd(
+				`${clangFormatNativeBinary} --Werror --dry-run ${workerFiles.join(' ')}`
+			);
+
+			break;
+		}
+
+		case 'format':
+		{
+			executeCmd(
+				`${clangFormatNativeBinary} --Werror -i ${workerFiles.join(' ')}`
+			);
+
+			break;
+		}
+
+		default:
+		{
+			logError('unknown task');
+
+			exitWithError();
+		}
+	}
+}
+
+function executeCmd(command)
+{
+	try
+	{
+		execSync(command, { stdio: [ 'ignore', process.stdout, process.stderr ] });
+	}
+	catch (error)
+	{
+		logError('executeCmd() failed');
+
+		exitWithError();
+	}
+}
+
+// eslint-disable-next-line no-unused-vars
+function logInfo(message)
+{
+	// eslint-disable-next-line no-console
+	console.log(`clang-format.mjs \x1b[36m[INFO] [${task}]\x1b\[0m`, message);
+}
+
+// eslint-disable-next-line no-unused-vars
+function logWarn(message)
+{
+	// eslint-disable-next-line no-console
+	console.warn(`clang-format.mjs \x1b[33m[WARN] [${task}]\x1b\[0m`, message);
+}
+
+function logError(message)
+{
+	// eslint-disable-next-line no-console
+	console.error(`clang-format.mjs \x1b[31m[ERROR] [${task}]\x1b\[0m`, message);
+}
+
+function exitWithError()
+{
+	process.exit(1);
+}

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/RTCP/XrDelaySinceLastRr.cpp

@@ -75,14 +75,12 @@ namespace RTC
 				{
 					report->AddSsrcInfo(ssrcInfo);
 					offset += ssrcInfo->GetSize();
+					reportLength -= ssrcInfo->GetSize();
 				}
 				else
 				{
 					return report.release();
 				}
-
-				offset += ssrcInfo->GetSize();
-				reportLength -= DelaySinceLastRr::SsrcInfo::BodySize;
 			}
 
 			return report.release();

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

@@ -1,11 +1,133 @@
 #include "common.hpp"
+#include "RTC/RTCP/XR.hpp"
 #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;
 
+SCENARIO("RTCP XR parsing", "[parser][rtcp][xr]")
+{
+	// clang-format off
+	uint8_t buffer[] =
+	{
+		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
+		0x11, 0x12, 0x13, 0x14, // SSRC 1
+		0x00, 0x11, 0x00, 0x11, // LRR 1
+		0x11, 0x00, 0x11, 0x00, // DLRR 1
+		0x21, 0x22, 0x23, 0x24, // SSRC 2
+		0x00, 0x22, 0x00, 0x22, // LRR 2
+		0x22, 0x00, 0x22, 0x00, // DLRR 2
+		0x00, 0x00, 0x00, 0x04 // Padding (4 bytes)
+	};
+	// clang-format on
+
+	SECTION("parse XR packet")
+	{
+		auto* packet = ExtendedReportPacket::Parse(buffer, sizeof(buffer));
+
+		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);
+
+		size_t blockIdx{ 0u };
+
+		for (auto it = packet->Begin(); it != packet->End(); ++it, ++blockIdx)
+		{
+			auto* block = *it;
+
+			switch (blockIdx)
+			{
+				case 0:
+				{
+					REQUIRE(block->GetSize() == 28);
+
+					size_t ssrcInfoIdx{ 0u };
+					auto* dlrrBlock = reinterpret_cast<DelaySinceLastRr*>(block);
+
+					for (auto it2 = dlrrBlock->Begin(); it2 != dlrrBlock->End(); ++it2, ++ssrcInfoIdx)
+					{
+						auto* ssrcInfo = *it2;
+
+						switch (ssrcInfoIdx)
+						{
+							case 0:
+							{
+								REQUIRE(ssrcInfo->GetSsrc() == 0x11121314);
+								REQUIRE(ssrcInfo->GetLastReceiverReport() == 0x00110011);
+								REQUIRE(ssrcInfo->GetDelaySinceLastReceiverReport() == 0x11001100);
+
+								break;
+							}
+
+							case 1:
+							{
+								REQUIRE(ssrcInfo->GetSsrc() == 0x21222324);
+								REQUIRE(ssrcInfo->GetLastReceiverReport() == 0x00220022);
+								REQUIRE(ssrcInfo->GetDelaySinceLastReceiverReport() == 0x22002200);
+
+								break;
+							}
+						}
+					}
+
+					// There are 2 SSRC infos.
+					REQUIRE(ssrcInfoIdx == 2);
+
+					break;
+				}
+			}
+		}
+
+		// 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;
+	}
+}
+
 SCENARIO("RTCP XrDelaySinceLastRt parsing", "[parser][rtcp][xr-dlrr]")
 {
 	SECTION("create RRT")