mediasoup 3.9.13 → 3.9.16

package/worker/src/RTC/SimpleConsumer.cpp

@@ -338,6 +338,16 @@ namespace RTC
 
 		packet->AddSdesChunk(sdesChunk);
 
+		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
+
+		if (dlrr)
+		{
+			auto* report = new RTC::RTCP::DelaySinceLastRr();
+
+			report->AddSsrcInfo(dlrr);
+			packet->AddDelaySinceLastRr(report);
+		}
+
 		this->lastRtcpSentTime = nowMs;
 	}
 
@@ -406,6 +416,13 @@ namespace RTC
 		this->rtpStream->ReceiveRtcpReceiverReport(report);
 	}
 
+	void SimpleConsumer::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	{
+		MS_TRACE();
+
+		this->rtpStream->ReceiveRtcpXrReceiverReferenceTime(report);
+	}
+
 	uint32_t SimpleConsumer::GetTransmissionRate(uint64_t nowMs)
 	{
 		MS_TRACE();

package/worker/src/RTC/SimulcastConsumer.cpp

@@ -16,6 +16,7 @@ namespace RTC
 	static constexpr uint64_t StreamMinActiveMs{ 2000u };           // In ms.
 	static constexpr uint64_t BweDowngradeConservativeMs{ 10000u }; // In ms.
 	static constexpr uint64_t BweDowngradeMinActiveMs{ 8000u };     // In ms.
+	static constexpr uint16_t MaxSequenceNumberGap{ 100u };
 
 	/* Instance methods. */
 
@@ -674,7 +675,8 @@ namespace RTC
 			shouldSwitchCurrentSpatialLayer = true;
 
 			// Need to resync the stream.
-			this->syncRequired = true;
+			this->syncRequired       = true;
+			this->spatialLayerToSync = spatialLayer;
 		}
 		// If the packet belongs to different spatial layer than the one being sent,
 		// drop it.
@@ -691,7 +693,7 @@ namespace RTC
 		bool isSyncPacket = this->syncRequired;
 
 		// Sync sequence number and timestamp if required.
-		if (isSyncPacket)
+		if (isSyncPacket && (this->spatialLayerToSync == -1 || this->spatialLayerToSync == spatialLayer))
 		{
 			if (packet->IsKeyFrame())
 				MS_DEBUG_TAG(rtp, "sync key frame received");
@@ -818,9 +820,25 @@ namespace RTC
 			this->encodingContext->SyncRequired();
 
 			this->syncRequired                 = false;
+			this->spatialLayerToSync           = -1;
 			this->keyFrameForTsOffsetRequested = false;
 		}
 
+		if (!shouldSwitchCurrentSpatialLayer && this->checkingForOldPacketsInSpatialLayer)
+		{
+			// If this is a packet previous to the spatial layer switch, ignore the packet.
+			if (SeqManager<uint16_t>::IsSeqLowerThan(
+			      packet->GetSequenceNumber(), this->snReferenceSpatialLayer))
+			{
+				return;
+			}
+			else if (SeqManager<uint16_t>::IsSeqHigherThan(
+			           packet->GetSequenceNumber(), this->snReferenceSpatialLayer + MaxSequenceNumberGap))
+			{
+				this->checkingForOldPacketsInSpatialLayer = false;
+			}
+		}
+
 		bool marker{ false };
 
 		if (shouldSwitchCurrentSpatialLayer)
@@ -828,6 +846,9 @@ namespace RTC
 			// Update current spatial layer.
 			this->currentSpatialLayer = this->targetSpatialLayer;
 
+			this->snReferenceSpatialLayer             = packet->GetSequenceNumber();
+			this->checkingForOldPacketsInSpatialLayer = true;
+
 			// Update target and current temporal layer.
 			this->encodingContext->SetTargetTemporalLayer(this->targetTemporalLayer);
 			this->encodingContext->SetCurrentTemporalLayer(packet->GetTemporalLayer());
@@ -947,6 +968,16 @@ namespace RTC
 
 		packet->AddSdesChunk(sdesChunk);
 
+		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
+
+		if (dlrr)
+		{
+			auto* report = new RTC::RTCP::DelaySinceLastRr();
+
+			report->AddSsrcInfo(dlrr);
+			packet->AddDelaySinceLastRr(report);
+		}
+
 		this->lastRtcpSentTime = nowMs;
 	}
 
@@ -1015,6 +1046,13 @@ namespace RTC
 		this->rtpStream->ReceiveRtcpReceiverReport(report);
 	}
 
+	void SimulcastConsumer::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	{
+		MS_TRACE();
+
+		this->rtpStream->ReceiveRtcpXrReceiverReferenceTime(report);
+	}
+
 	uint32_t SimulcastConsumer::GetTransmissionRate(uint64_t nowMs)
 	{
 		MS_TRACE();
@@ -1037,6 +1075,7 @@ namespace RTC
 		MS_TRACE();
 
 		this->syncRequired                 = true;
+		this->spatialLayerToSync           = -1;
 		this->keyFrameForTsOffsetRequested = false;
 
 		if (IsActive())
@@ -1072,8 +1111,10 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		this->syncRequired                 = true;
-		this->keyFrameForTsOffsetRequested = false;
+		this->syncRequired                        = true;
+		this->spatialLayerToSync                  = -1;
+		this->keyFrameForTsOffsetRequested        = false;
+		this->checkingForOldPacketsInSpatialLayer = false;
 
 		if (IsActive())
 			MayChangeLayers();

package/worker/src/RTC/SvcConsumer.cpp

@@ -685,6 +685,16 @@ namespace RTC
 
 		packet->AddSdesChunk(sdesChunk);
 
+		auto* dlrr = this->rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
+
+		if (dlrr)
+		{
+			auto* report = new RTC::RTCP::DelaySinceLastRr();
+
+			report->AddSsrcInfo(dlrr);
+			packet->AddDelaySinceLastRr(report);
+		}
+
 		this->lastRtcpSentTime = nowMs;
 	}
 
@@ -751,6 +761,13 @@ namespace RTC
 		this->rtpStream->ReceiveRtcpReceiverReport(report);
 	}
 
+	void SvcConsumer::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	{
+		MS_TRACE();
+
+		this->rtpStream->ReceiveRtcpXrReceiverReferenceTime(report);
+	}
+
 	uint32_t SvcConsumer::GetTransmissionRate(uint64_t nowMs)
 	{
 		MS_TRACE();

package/worker/src/RTC/Transport.cpp

@@ -2270,6 +2270,20 @@ namespace RTC
 							break;
 						}
 
+						case RTC::RTCP::ExtendedReportBlock::Type::RRT:
+						{
+							auto* rrt = static_cast<RTC::RTCP::ReceiverReferenceTime*>(report);
+
+							for (auto& kv : this->mapConsumers)
+							{
+								auto* consumer = kv.second;
+
+								consumer->ReceiveRtcpXrReceiverReferenceTime(rrt);
+							}
+
+							break;
+						}
+
 						default:;
 					}
 				}

package/worker/src/RTC/TransportCongestionControlClient.cpp

@@ -262,9 +262,6 @@ namespace RTC
 
 	void TransportCongestionControlClient::SetMaxOutgoingBitrate(uint32_t maxBitrate)
 	{
-		if (maxBitrate < this->initialAvailableBitrate)
-			MS_THROW_ERROR("maxOutgoingBitrate must be >= initialAvailableOutgoingBitrate");
-
 		if (maxBitrate < MinBitrate)
 			MS_THROW_ERROR("maxOutgoingBitrate must be >= 30000bps");
 

package/worker/test/include/helpers.hpp

@@ -5,6 +5,8 @@
 #include <fstream>
 #include <string>
 
+static int BUFFER_SIZE = 65536;
+
 namespace helpers
 {
 	inline bool readBinaryFile(const char* file, uint8_t* buffer, size_t* len)
@@ -25,6 +27,123 @@ namespace helpers
 
 		return true;
 	}
+
+	inline bool addToBuffer(uint8_t* buf, int* size, uint8_t* data, size_t len)
+	{
+		if (*size + len > BUFFER_SIZE)
+			return false;
+
+		int i = 0;
+		if (len == 1)
+		{
+			buf[*size] = *data;
+		}
+		else
+		{
+			for (i = 0; i < len; i++)
+			{
+				buf[*size + i] = data[i];
+			}
+		}
+		*size += len;
+
+		return true;
+	}
+
+	inline bool readPayloadData(const char* file, int pos, int bytes, uint8_t* payload)
+	{
+		std::string filePath = "test/" + std::string(file);
+#ifdef _WIN32
+		std::replace(filePath.begin(), filePath.end(), '/', '\\');
+#endif
+		std::ifstream in(filePath, std::ios::ate | std::ios::binary);
+
+		if (!in)
+			return false;
+
+		in.seekg(pos, std::ios::beg);
+		in.read(reinterpret_cast<char*>(payload), bytes);
+
+		in.close();
+		return true;
+	}
+
+	inline bool writeRtpPacket(
+	  const char* file,
+	  uint8_t nalType,
+	  size_t nalLength,
+	  int32_t sid,
+	  int32_t tid,
+	  int32_t isIdr,
+	  int32_t firstSliceId,
+	  int32_t lastSliceId,
+	  uint8_t* payload,
+	  uint8_t* buf,
+	  size_t* len)
+	{
+		std::string filePath = "test/" + std::string(file);
+#ifdef _WIN32
+		std::replace(filePath.begin(), filePath.end(), '/', '\\');
+#endif
+
+		uint8_t buffer[16] = { 144, 111, 92, 65, 98, 245, 71, 218, 159, 113, 8, 226, 190, 222, 0, 1 };
+
+		int packet_size = 0;
+		uint8_t oneByte = 0;
+
+		// write the RTP header
+		if (!addToBuffer(buf, &packet_size, buffer, 16))
+			return false;
+
+		// write ID and length of frame marking extension
+		// if first layer then length should be 0, else 1
+		oneByte = oneByte | 1 << 4;
+		if (sid != -1)
+		{
+			oneByte = oneByte | 0x01;
+		}
+
+		if (!addToBuffer(buf, &packet_size, &oneByte, 1))
+			return false;
+
+		// write SEIDB TID bits
+		oneByte = 0;
+		if (firstSliceId == 1)
+			oneByte = oneByte | 1 << 7;
+
+		if (lastSliceId == 1)
+			oneByte = oneByte | 1 << 6;
+
+		if (isIdr == 1)
+			oneByte = oneByte | 1 << 5;
+
+		if (tid != -1)
+			oneByte = oneByte | tid;
+
+		if (!addToBuffer(buf, &packet_size, &oneByte, 1))
+			return false;
+
+		// write DID QID bits
+		oneByte = 0;
+		if (sid != -1)
+			oneByte = oneByte | sid << 6;
+
+		if (!addToBuffer(buf, &packet_size, &oneByte, 1))
+			return false;
+
+		// write TL0PICIDX
+		oneByte = 0;
+		if (!addToBuffer(buf, &packet_size, &oneByte, 1))
+			return false;
+
+		// write payload
+		if (!addToBuffer(buf, &packet_size, payload, nalLength))
+			return false;
+
+		*len = packet_size;
+
+		return true;
+	}
 } // namespace helpers
 
 #endif

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

@@ -0,0 +1,30 @@
+#include "common.hpp"
+#include "RTC/Codecs/H264.hpp"
+#include <catch2/catch.hpp>
+#include <cstring> // std::memcmp()
+
+using namespace RTC;
+
+SCENARIO("parse H264 payload descriptor", "[codecs][h264]")
+{
+	SECTION("parse payload descriptor")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x07, 0x80, 0x11, 0x00
+		};
+		// clang-format on
+		//
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		delete payloadDescriptor;
+	}
+}

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

@@ -0,0 +1,181 @@
+#include "common.hpp"
+#include "RTC/Codecs/H264_SVC.hpp"
+#include <catch2/catch.hpp>
+#include <cstring> // std::memcmp()
+
+using namespace RTC;
+
+SCENARIO("parse H264_SVC payload descriptor", "[codecs][h264_svc]")
+{
+	SECTION("parse payload descriptor for NALU 7")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x67,0x42,0xc0,0x33
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->tlIndex == 0);
+		REQUIRE(payloadDescriptor->slIndex == 0);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == true);
+		REQUIRE(payloadDescriptor->hasTlIndex == false);
+		REQUIRE(payloadDescriptor->hasSlIndex == false);
+
+		delete payloadDescriptor;
+	}
+
+	SECTION("parse payload descriptor for NALU 8")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x68,0xce,0x01,0xa8
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->tlIndex == 0);
+		REQUIRE(payloadDescriptor->slIndex == 0);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == false);
+		REQUIRE(payloadDescriptor->hasTlIndex == false);
+		REQUIRE(payloadDescriptor->hasSlIndex == false);
+
+		delete payloadDescriptor;
+	}
+
+	SECTION("parse payload descriptor for NALU 1")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x81,0xe0,0x00,0x4e
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->tlIndex == 0);
+		REQUIRE(payloadDescriptor->slIndex == 0);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == false);
+		REQUIRE(payloadDescriptor->hasTlIndex == false);
+		REQUIRE(payloadDescriptor->hasSlIndex == false);
+
+		delete payloadDescriptor;
+	}
+
+	SECTION("parse payload descriptor for NALU 5")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x85,0xb8,0x00,0x04
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->tlIndex == 0);
+		REQUIRE(payloadDescriptor->slIndex == 0);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == true);
+		REQUIRE(payloadDescriptor->hasTlIndex == false);
+		REQUIRE(payloadDescriptor->hasSlIndex == false);
+
+		delete payloadDescriptor;
+	}
+
+	SECTION("parse payload descriptor for NALU 14")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x6e,0x80,0x90,0x20
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->idr == 0);
+
+		REQUIRE(payloadDescriptor->tlIndex == 1);
+		REQUIRE(payloadDescriptor->slIndex == 1);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == false);
+		REQUIRE(payloadDescriptor->hasTlIndex == true);
+		REQUIRE(payloadDescriptor->hasSlIndex == true);
+
+		delete payloadDescriptor;
+	}
+
+	SECTION("parse payload descriptor for NALU 20")
+	{
+		// clang-format off
+		uint8_t originalBuffer[] =
+		{
+			0x74,0x80,0x90,0x20
+		};
+		// clang-format on
+
+		// Keep a copy of the original buffer for comparing.
+		uint8_t buffer[4] = { 0 };
+
+		std::memcpy(buffer, originalBuffer, sizeof(buffer));
+
+		const auto* payloadDescriptor = Codecs::H264_SVC::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(payloadDescriptor);
+
+		REQUIRE(payloadDescriptor->idr == 0);
+
+		REQUIRE(payloadDescriptor->tlIndex == 1);
+		REQUIRE(payloadDescriptor->slIndex == 1);
+
+		REQUIRE(payloadDescriptor->isKeyFrame == false);
+		REQUIRE(payloadDescriptor->hasTlIndex == true);
+		REQUIRE(payloadDescriptor->hasSlIndex == true);
+
+		delete payloadDescriptor;
+	}
+}

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

@@ -8,6 +8,8 @@
 
 using namespace RTC;
 
+static constexpr unsigned int SendNackDelay{ 0u }; // In ms.
+
 struct TestNackGeneratorInput
 {
 	TestNackGeneratorInput() = default;
@@ -121,7 +123,7 @@ RtpPacket* packet = RtpPacket::Parse(rtpBuffer, sizeof(rtpBuffer));
 void validate(std::vector<TestNackGeneratorInput>& inputs)
 {
 	TestNackGeneratorListener listener;
-	NackGenerator nackGenerator = NackGenerator(&listener);
+	NackGenerator nackGenerator = NackGenerator(&listener, SendNackDelay);
 
 	for (auto input : inputs)
 	{