mediasoup 3.11.19 → 3.11.21

package/worker/src/RTC/SeqManager.cpp

@@ -113,15 +113,29 @@ namespace RTC
 
 		output = (input + base) & MaxValue;
 
-		// New input is higher than the maximum seen. But less than acceptable units higher.
-		// Keep it as the maximum seen. See Drop().
-		if (IsSeqHigherThan(input, this->maxInput))
-			this->maxInput = input;
-
-		// New output is higher than the maximum seen. But less than acceptable units higher.
-		// Keep it as the maximum seen. See Sync().
-		if (IsSeqHigherThan(output, this->maxOutput))
+		if (!this->started)
+		{
+			this->started = true;
+
+			this->maxInput  = input;
 			this->maxOutput = output;
+		}
+		else
+		{
+			// New input is higher than the maximum seen. But less than acceptable units higher.
+			// Keep it as the maximum seen. See Drop().
+			if (IsSeqHigherThan(input, this->maxInput))
+			{
+				this->maxInput = input;
+			}
+
+			// New output is higher than the maximum seen. But less than acceptable units higher.
+			// Keep it as the maximum seen. See Sync().
+			if (IsSeqHigherThan(output, this->maxOutput))
+			{
+				this->maxOutput = output;
+			}
+		}
 
 		ClearDropped();
 
@@ -172,7 +186,19 @@ namespace RTC
 		// There are many values in the range.
 		else
 		{
-			this->dropped.erase(it1, it2);
+			// Measure the distance of it1 and it2 to the beggining of dropped.
+			auto distanceIt1 = std::distance(this->dropped.begin(), it1);
+			auto distanceIt2 = std::distance(this->dropped.begin(), it2);
+
+			// it2 goes out of range, only it1 is within the range.
+			if (distanceIt2 < distanceIt1)
+			{
+				this->dropped.erase(it1);
+			}
+			else
+			{
+				this->dropped.erase(it1, it2);
+			}
 		}
 
 		// Adapt base.

package/worker/src/RTC/TransportCongestionControlClient.cpp

@@ -215,14 +215,21 @@ namespace RTC
 		MS_TRACE();
 
 		// Update packet loss history.
-		const size_t expected_packets = feedback->GetPacketStatusCount();
-		size_t lost_packets           = 0;
+		const size_t expectedPackets = feedback->GetPacketStatusCount();
+		size_t lostPackets           = 0;
+
 		for (const auto& result : feedback->GetPacketResults())
 		{
 			if (!result.received)
-				lost_packets += 1;
+			{
+				lostPackets += 1;
+			}
+		}
+
+		if (expectedPackets > 0)
+		{
+			this->UpdatePacketLoss(static_cast<double>(lostPackets) / expectedPackets);
 		}
-		this->UpdatePacketLoss(static_cast<double>(lost_packets) / expected_packets);
 
 		if (this->rtpTransportControllerSend == nullptr)
 		{
@@ -236,7 +243,9 @@ namespace RTC
 	{
 		// Add the score into the histogram.
 		if (this->packetLossHistory.size() == PacketLossHistogramLength)
+		{
 			this->packetLossHistory.pop_front();
+		}
 
 		this->packetLossHistory.push_back(packetLoss);
 
@@ -303,9 +312,13 @@ namespace RTC
 		// Manage it via trending and increase it a bit to avoid immediate oscillations.
 #ifdef USE_TREND_CALCULATOR
 		if (!force)
+		{
 			this->desiredBitrateTrend.Update(desiredBitrate, nowMs);
+		}
 		else
+		{
 			this->desiredBitrateTrend.ForceUpdate(desiredBitrate, nowMs);
+		}
 #endif
 
 		this->bitrates.desiredBitrate = desiredBitrate;
@@ -512,9 +525,13 @@ namespace RTC
 		// Update availableBitrate.
 		// NOTE: Just in case.
 		if (targetTransferRate.target_rate.bps() > std::numeric_limits<uint32_t>::max())
+		{
 			this->bitrates.availableBitrate = std::numeric_limits<uint32_t>::max();
+		}
 		else
+		{
 			this->bitrates.availableBitrate = static_cast<uint32_t>(targetTransferRate.target_rate.bps());
+		}
 
 		MS_DEBUG_DEV("new available bitrate:%" PRIu32, this->bitrates.availableBitrate);
 

package/worker/src/RTC/TransportCongestionControlServer.cpp

@@ -120,7 +120,9 @@ namespace RTC
 				uint16_t wideSeqNumber;
 
 				if (!packet->ReadTransportWideCc01(wideSeqNumber))
+				{
 					break;
+				}
 
 				// Update the RTCP media SSRC of the ongoing Transport-CC Feedback packet.
 				this->transportCcFeedbackSenderSsrc = 0u;
@@ -186,7 +188,9 @@ namespace RTC
 				uint32_t absSendTime;
 
 				if (!packet->ReadAbsSendTime(absSendTime))
+				{
 					break;
+				}
 
 				// NOTE: nowMs is uint64_t but we need to "convert" it to int64_t before
 				// we give it to libwebrtc lib (althought this is implicit in the
@@ -221,8 +225,12 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		this->transportCcFeedbackPacket->Finish();
+
 		if (!this->transportCcFeedbackPacket->IsSerializable())
+		{
 			return;
+		}
 
 		auto latestWideSeqNumber = this->transportCcFeedbackPacket->GetLatestSequenceNumber();
 		auto latestTimestamp     = this->transportCcFeedbackPacket->GetLatestTimestamp();
@@ -232,15 +240,21 @@ namespace RTC
 		  this, this->transportCcFeedbackPacket.get());
 
 		// Update packet loss history.
-		const size_t expected_packets = this->transportCcFeedbackPacket->GetPacketStatusCount();
-		size_t lost_packets           = 0;
+		const size_t expectedPackets = this->transportCcFeedbackPacket->GetPacketStatusCount();
+		size_t lostPackets           = 0;
+
 		for (const auto& result : this->transportCcFeedbackPacket->GetPacketResults())
 		{
 			if (!result.received)
-				lost_packets += 1;
+			{
+				lostPackets += 1;
+			}
 		}
 
-		this->UpdatePacketLoss(static_cast<double>(lost_packets) / expected_packets);
+		if (expectedPackets > 0)
+		{
+			this->UpdatePacketLoss(static_cast<double>(lostPackets) / expectedPackets);
+		}
 
 		// Create a new feedback packet.
 		this->transportCcFeedbackPacket.reset(new RTC::RTCP::FeedbackRtpTransportPacket(
@@ -265,7 +279,9 @@ namespace RTC
 
 		// May fix unlimitedRembCounter.
 		if (this->unlimitedRembCounter > 0u && this->maxIncomingBitrate != 0u)
+		{
 			this->unlimitedRembCounter = 0u;
+		}
 
 		// In case this is the first unlimited REMB packet, send it fast.
 		// clang-format off
@@ -295,7 +311,9 @@ namespace RTC
 			this->limitationRembSentAtMs = nowMs;
 
 			if (this->unlimitedRembCounter > 0u)
+			{
 				this->unlimitedRembCounter--;
+			}
 		}
 	}
 
@@ -303,7 +321,9 @@ namespace RTC
 	{
 		// Add the score into the histogram.
 		if (this->packetLossHistory.size() == PacketLossHistogramLength)
+		{
 			this->packetLossHistory.pop_front();
+		}
 
 		this->packetLossHistory.push_back(packetLoss);
 
@@ -334,7 +354,9 @@ namespace RTC
 
 		// Limit announced bitrate if requested via API.
 		if (this->maxIncomingBitrate != 0u)
+		{
 			availableBitrate = std::min(availableBitrate, this->maxIncomingBitrate);
+		}
 
 #if MS_LOG_DEV_LEVEL == 3
 		std::ostringstream ssrcsStream;
@@ -366,6 +388,8 @@ namespace RTC
 		MS_TRACE();
 
 		if (timer == this->transportCcFeedbackSendPeriodicTimer)
+		{
 			SendTransportCcFeedback();
+		}
 	}
 } // namespace RTC

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

@@ -253,6 +253,28 @@ SCENARIO("RtpRetransmissionBuffer", "[rtp][rtx]")
 		// clang-format on
 	}
 
+	SECTION(
+	  "packet with lower seq than newest packet in the buffer and higher timestamp forces buffer emptying")
+	{
+		uint16_t maxItems{ 4 };
+		uint32_t maxRetransmissionDelayMs{ 2000u };
+		uint32_t clockRate{ 90000 };
+
+		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
+
+		myRetransmissionBuffer.Insert(33331, 1000000001);
+		myRetransmissionBuffer.Insert(33332, 1000000002);
+		myRetransmissionBuffer.Insert(33330, 1000000003);
+
+		// clang-format off
+		myRetransmissionBuffer.AssertBuffer(
+			{
+				{ true, 33330, 1000000003 }
+			}
+		);
+		// clang-format on
+	}
+
 	SECTION("fuzzer generated packets")
 	{
 		uint16_t maxItems{ 2500u };

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

@@ -123,11 +123,11 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 5);
 
-		auto rtxPacket1 = testRtpStreamListener.retransmittedPackets[0];
-		auto rtxPacket2 = testRtpStreamListener.retransmittedPackets[1];
-		auto rtxPacket3 = testRtpStreamListener.retransmittedPackets[2];
-		auto rtxPacket4 = testRtpStreamListener.retransmittedPackets[3];
-		auto rtxPacket5 = testRtpStreamListener.retransmittedPackets[4];
+		auto* rtxPacket1 = testRtpStreamListener.retransmittedPackets[0];
+		auto* rtxPacket2 = testRtpStreamListener.retransmittedPackets[1];
+		auto* rtxPacket3 = testRtpStreamListener.retransmittedPackets[2];
+		auto* rtxPacket4 = testRtpStreamListener.retransmittedPackets[3];
+		auto* rtxPacket5 = testRtpStreamListener.retransmittedPackets[4];
 
 		testRtpStreamListener.retransmittedPackets.clear();
 
@@ -294,8 +294,8 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		REQUIRE(testRtpStreamListener1.retransmittedPackets.size() == 2);
 
-		auto rtxPacket1 = testRtpStreamListener1.retransmittedPackets[0];
-		auto rtxPacket2 = testRtpStreamListener1.retransmittedPackets[1];
+		auto* rtxPacket1 = testRtpStreamListener1.retransmittedPackets[0];
+		auto* rtxPacket2 = testRtpStreamListener1.retransmittedPackets[1];
 
 		testRtpStreamListener1.retransmittedPackets.clear();
 
@@ -330,7 +330,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		auto* packet2 = CreateRtpPacket(rtpBuffer2, 21007, secondTs - 1);
 
 		// Create a RtpStreamSend instance.
-		TestRtpStreamListener testRtpStreamListener1;
+		TestRtpStreamListener testRtpStreamListener;
 
 		RtpStream::Params params1;
 
@@ -340,7 +340,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto* stream = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
+		auto* stream = new RtpStreamSend(&testRtpStreamListener, params1, mid);
 
 		// Receive all the packets.
 		SendRtpPacket({ { stream, params1.ssrc } }, packet1);
@@ -358,12 +358,12 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		// Process the NACK packet on stream1.
 		stream->ReceiveNack(&nackPacket);
 
-		REQUIRE(testRtpStreamListener1.retransmittedPackets.size() == 2);
+		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 2);
 
-		auto rtxPacket1 = testRtpStreamListener1.retransmittedPackets[0];
-		auto rtxPacket2 = testRtpStreamListener1.retransmittedPackets[1];
+		auto* rtxPacket1 = testRtpStreamListener.retransmittedPackets[0];
+		auto* rtxPacket2 = testRtpStreamListener.retransmittedPackets[1];
 
-		testRtpStreamListener1.retransmittedPackets.clear();
+		testRtpStreamListener.retransmittedPackets.clear();
 
 		CheckRtxPacket(rtxPacket1, packet1->GetSequenceNumber(), packet1->GetTimestamp());
 		CheckRtxPacket(rtxPacket2, packet2->GetSequenceNumber(), packet2->GetTimestamp());
@@ -386,7 +386,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		auto* packet3 = CreateRtpPacket(rtpBuffer3, 21008, thirdTs);
 
 		// Create a RtpStreamSend instance.
-		TestRtpStreamListener testRtpStreamListener1;
+		TestRtpStreamListener testRtpStreamListener;
 
 		RtpStream::Params params1;
 
@@ -396,14 +396,14 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto* stream = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
+		auto* stream = new RtpStreamSend(&testRtpStreamListener, params1, mid);
 
 		// Receive all the packets.
 		SendRtpPacket({ { stream, params1.ssrc } }, packet1);
 		SendRtpPacket({ { stream, params1.ssrc } }, packet2);
 		SendRtpPacket({ { stream, params1.ssrc } }, packet3);
 
-		// Create a NACK item that request for all the packets.
+		// Create a NACK item that requests for all packets.
 		RTCP::FeedbackRtpNackPacket nackPacket(0, params1.ssrc);
 		auto* nackItem = new RTCP::FeedbackRtpNackItem(21006, 0b0000000000000001);
 
@@ -415,17 +415,62 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		// Process the NACK packet on stream1.
 		stream->ReceiveNack(&nackPacket);
 
-		REQUIRE(testRtpStreamListener1.retransmittedPackets.size() == 1);
+		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 1);
 
-		auto rtxPacket2 = testRtpStreamListener1.retransmittedPackets[0];
+		auto* rtxPacket2 = testRtpStreamListener.retransmittedPackets[0];
 
-		testRtpStreamListener1.retransmittedPackets.clear();
+		testRtpStreamListener.retransmittedPackets.clear();
 
 		CheckRtxPacket(rtxPacket2, packet2->GetSequenceNumber(), packet2->GetTimestamp());
 
 		delete stream;
 	}
 
+	SECTION("packets get removed from the retransmission buffer if seq number of the stream is reset")
+	{
+		// This scenario reproduce the "too bad sequence number" and "bad sequence
+		// number" scenarios in RtpStream::UpdateSeq().
+		auto* packet1 = CreateRtpPacket(rtpBuffer1, 50001, 1000001);
+		auto* packet2 = CreateRtpPacket(rtpBuffer2, 50002, 1000002);
+		// Third packet has bad sequence number (its seq is more than MaxDropout=3000
+		// older than current max seq) and will be dropped.
+		auto* packet3 = CreateRtpPacket(rtpBuffer3, 40003, 1000003);
+		// Forth packet has seq=badSeq+1 so will be accepted and will trigger a
+		// stream reset.
+		auto* packet4 = CreateRtpPacket(rtpBuffer4, 40004, 1000004);
+
+		// Create a RtpStreamSend instance.
+		TestRtpStreamListener testRtpStreamListener;
+
+		RtpStream::Params params1;
+
+		params1.ssrc          = 1111;
+		params1.clockRate     = 90000;
+		params1.useNack       = true;
+		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
+
+		std::string mid;
+		auto* stream = new RtpStreamSend(&testRtpStreamListener, params1, mid);
+
+		SendRtpPacket({ { stream, params1.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet2);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet4);
+
+		// Create a NACK item that requests for packets 1 and 2.
+		RTCP::FeedbackRtpNackPacket nackPacket2(0, params1.ssrc);
+		auto* nackItem2 = new RTCP::FeedbackRtpNackItem(50001, 0b0000000000000001);
+
+		nackPacket2.AddItem(nackItem2);
+
+		// Process the NACK packet on stream1.
+		stream->ReceiveNack(&nackPacket2);
+
+		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 0);
+
+		delete stream;
+	}
+
 #ifdef PERFORMANCE_TEST
 	SECTION("Performance")
 	{

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

@@ -649,4 +649,83 @@ SCENARIO("SeqManager", "[rtc][SeqMananger]")
 		SeqManager<uint8_t, 3> seqManager;
 		validate(seqManager, inputs);
 	}
+
+	SECTION("dropped inputs to be removed going out of range, 1.")
+	{
+		// clang-format off
+		std::vector<TestSeqManagerInput<uint16_t>> inputs =
+		{
+			{ 36964, 36964, false, false,  0 },
+			{ 25923,     0, false, true,   0 }, // Drop.
+			{ 25701, 25701, false, false,  0 },
+			{ 17170,     0, false, true,   0 }, // Drop.
+			{ 25923, 25923, false, false,  0 },
+			{  4728,     0, false, true,   0 }, // Drop.
+			{ 17170, 17170, false, false,  0 },
+			{ 30738,     0, false, true,   0 }, // Drop.
+			{  4728,  4728, false, false,  0 },
+			{  4806,     0, false, true,   0 }, // Drop.
+			{ 30738, 30738, false, false,  0 },
+			{ 50886,     0, false, true,   0 }, // Drop.
+			{  4806,  4805, false, false,  0 }, // Previously dropped.
+			{ 50774,     0, false, true,   0 }, // Drop.
+			{ 50886, 50884, false, false,  0 }, // Previously dropped.
+			{ 22136,     0, false, true,   0 }, // Drop.
+			{ 50774, 50884, false, false,  0 }, // Previously dropped.
+			{ 30910,     0, false, true,   0 }, // Drop.
+			{ 22136, 22134, false, false,  0 },
+			{ 48862,     0, false, true,   0 }, // Drop.
+			{ 30910, 30909, false, false,  0 },
+			{ 56832,     0, false, true,   0 }, // Drop.
+			{ 48862, 48861, false, false,  0 },
+			{     2,     0, false, true,   0 }, // Drop.
+			{ 56832, 56828, false, false,  0 },
+			{   530,     0, false, true,   0 }, // Drop.
+			{     2, 65534, false, false,  0 },
+		};
+		// clang-format on
+
+		SeqManager<uint16_t> seqManager;
+		validate(seqManager, inputs);
+	}
+
+	SECTION("dropped inputs to be removed go out of range, 2.")
+	{
+		// clang-format off
+		std::vector<TestSeqManagerInput<uint16_t>> inputs =
+		{
+			{ 36960, 36960, false, false, 0 },
+			{  3328,     0, false, true,  0 }, // Drop.
+			{ 24589, 24588, false, false, 0 },
+			{   120,     0, false, true,  0 }, // Drop.
+			{  3328,  3326, false, false, 0 },
+			{ 30848,     0, false, true,  0 }, // Drop.
+			{   120,  3326, false, false, 0 }, // Previously dropped.
+		};
+		// clang-format on
+
+		SeqManager<uint16_t> seqManager;
+		validate(seqManager, inputs);
+	}
+
+	SECTION("dropped inputs to be removed go out of range, 3.")
+	{
+		// clang-format off
+		std::vector<TestSeqManagerInput<uint16_t>> inputs =
+		{
+			{ 36964, 36964, false, false, 0 },
+			{ 65396 ,    0, false, true,  0 }, // Drop.
+			{ 25855, 25854, false, false, 0 },
+			{ 29793 ,    0, false, true,  0 }, // Drop.
+			{ 65396, 65395, false, false, 0 },
+			{ 25087,    0,  false, true,  0 }, // Drop.
+			{ 29793, 29791, false, false, 0 },
+			{ 65535 ,    0, false, true,  0 }, // Drop.
+			{ 25087, 29791, false, false, 0 }, // Previously dropped.
+		};
+		// clang-format on
+
+		SeqManager<uint16_t> seqManager;
+		validate(seqManager, inputs);
+	}
 }