mediasoup 3.27.1 → 3.28.0

package/worker/test/src/RTC/RTP/TestPacket.cpp

@@ -1475,7 +1475,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		// Requires Two-Bytes type extensions due to length > 16.
 		extensions.assign(
 		  {
-		    { RTC::RtpHeaderExtensionUri::Type::TIME_OFFSET, 1, 17, rtpCommon::DataBuffer }
+		    { RTC::RtpHeaderExtensionUri::Type::ABS_CAPTURE_TIME, 1, 17, rtpCommon::DataBuffer }
     });
 		packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::Auto, extensions);
 		REQUIRE(packet->HasTwoBytesExtensions());
@@ -1488,15 +1488,19 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		std::vector<RTC::RTP::Packet::Extension> extensions;
 
+		const uint32_t absSendtime{ 12345678 };
+		const uint16_t wideSeqNumber{ 5555 };
+		const uint64_t absCaptureTimestamp{ 0x83AA7E8000000000 };
+
 		std::string mid{ "mid-€1" };
 		std::string rid{ "r1-ß" };
-		uint32_t absSendtime{ 12345678 };
-		uint16_t wideSeqNumber{ 5555 };
 		uint8_t absSendtimeValue[100]{};
 		uint8_t wideSeqNumberValue[100]{};
+		uint8_t absCaptureTimeValue[100]{};
 
 		Utils::Byte::Set3Bytes(absSendtimeValue, 0, absSendtime);
 		Utils::Byte::Set2Bytes(wideSeqNumberValue, 0, wideSeqNumber);
+		Utils::Byte::Set8Bytes(absCaptureTimeValue, 0, absCaptureTimestamp);
 
 		// clang-format off
 		extensions.assign(
@@ -1524,6 +1528,12 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 					4,
 					2,
 					wideSeqNumberValue
+				},
+				{
+					RTC::RtpHeaderExtensionUri::Type::ABS_CAPTURE_TIME,
+					5,
+					8,
+					absCaptureTimeValue
 				}
 			}
 		);
@@ -1537,6 +1547,8 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		std::string readRid;
 		uint32_t readAbsSendtime;
 		uint16_t readWideSeqNumber;
+		uint64_t readAbsCaptureTimestamp;
+		int64_t readEstimatedCaptureClockOffset;
 
 		REQUIRE(packet->ReadMid(readMid));
 		REQUIRE(readMid == mid);
@@ -1546,14 +1558,18 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(readAbsSendtime == absSendtime);
 		REQUIRE(packet->ReadTransportWideCc01(readWideSeqNumber));
 		REQUIRE(readWideSeqNumber == wideSeqNumber);
+		REQUIRE(packet->ReadAbsCaptureTime(readAbsCaptureTimestamp, readEstimatedCaptureClockOffset));
+		REQUIRE(readAbsCaptureTimestamp == absCaptureTimestamp);
 
 		const std::string newMid{ "mid-®2" };
 		const int64_t newAbsSendtimeUs{ 999999250 };
 		const uint16_t newWideSeqNumber{ 5556 };
+		const uint64_t newAbsCaptureTimestamp{ 0x83AA7E8100000000 };
 
 		REQUIRE(packet->UpdateMid(newMid));
-		REQUIRE(packet->UpdateAbsSendTime(newAbsSendtimeUs));
+		REQUIRE(packet->UpdateAbsSendTime(Utils::Time::TimeUsToAbsSendTime(newAbsSendtimeUs)));
 		REQUIRE(packet->UpdateTransportWideCc01(newWideSeqNumber));
+		REQUIRE(packet->UpdateAbsCaptureTime(newAbsCaptureTimestamp));
 
 		REQUIRE(packet->ReadMid(readMid));
 		REQUIRE(readMid == newMid);
@@ -1563,6 +1579,8 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(readAbsSendtime == Utils::Time::TimeUsToAbsSendTime(newAbsSendtimeUs));
 		REQUIRE(packet->ReadTransportWideCc01(readWideSeqNumber));
 		REQUIRE(readWideSeqNumber == newWideSeqNumber);
+		REQUIRE(packet->ReadAbsCaptureTime(readAbsCaptureTimestamp, readEstimatedCaptureClockOffset));
+		REQUIRE(readAbsCaptureTimestamp == newAbsCaptureTimestamp);
 
 		std::unique_ptr<RTC::RTP::Packet> packet2{ RTC::RTP::Packet::Parse(
 			packet->GetBuffer(), packet->GetLength()) };
@@ -2168,6 +2186,42 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(packet->IsPaddedTo4Bytes() == false);
 	}
 
+	SECTION("Packet::RtxEncode() does not write beyond the new packet length")
+	{
+		std::unique_ptr<RTC::RTP::Packet> packet{ RTC::RTP::Packet::Factory(
+			rtpCommon::FactoryBuffer, sizeof(rtpCommon::FactoryBuffer)) };
+
+		// clang-format off
+		uint8_t payload[] =
+		{
+			0x11, 0x22, 0x33, 0x44,
+			0x55, 0x66, 0x77, 0x88,
+			0x99, 0xAA
+		};
+		// clang-format on
+
+		packet->SetPayload(payload, 10);
+
+		const auto length = packet->GetLength();
+
+		REQUIRE(length == RTC::RTP::Packet::FixedHeaderMinLength + 10);
+
+		// Bytes that will belong to the packet once RTX encoded, and canary bytes
+		// right after them.
+		rtpCommon::FactoryBuffer[length]     = 0x55;
+		rtpCommon::FactoryBuffer[length + 1] = 0x55;
+		rtpCommon::FactoryBuffer[length + 2] = 0xEE;
+		rtpCommon::FactoryBuffer[length + 3] = 0xEE;
+
+		packet->RtxEncode(/*payloadType*/ 111, /*ssrc*/ 999999, /*seq*/ 666);
+
+		REQUIRE(packet->GetLength() == length + 2);
+		REQUIRE(packet->GetPayloadLength() == 12);
+		REQUIRE(rtpCommon::FactoryBuffer[length + 2] == 0xEE);
+		REQUIRE(rtpCommon::FactoryBuffer[length + 3] == 0xEE);
+		REQUIRE(std::memcmp(packet->GetPayload() + 2, payload, 10) == 0);
+	}
+
 	SECTION("Packet::SetBufferReleasedListener() when Packet is destroyed succeeds")
 	{
 		std::unique_ptr<RTC::RTP::Packet> packet{ RTC::RTP::Packet::Factory(

package/worker/test/src/RTC/RTP/TestProbationGenerator.cpp

@@ -1,4 +1,5 @@
 #include "common.hpp"
+#include "RTC/Consts.hpp"
 #include "RTC/RTP/ProbationGenerator.hpp"
 #include <catch2/catch_test_macros.hpp>
 
@@ -11,8 +12,8 @@ SCENARIO("RTP ProbationGenerator", "[rtp][probation-generator]")
 		const auto* packet = probationGenerator.GetNextPacket(1000);
 		const auto seq     = packet->GetSequenceNumber();
 
-		REQUIRE(packet->GetSsrc() == RTC::RTP::ProbationGenerator::Ssrc);
-		REQUIRE(packet->GetPayloadType() == RTC::RTP::ProbationGenerator::PayloadType);
+		REQUIRE(packet->GetSsrc() == RTC::Consts::BweProbeRtpSsrc);
+		REQUIRE(packet->GetPayloadType() == RTC::Consts::BweProbeRtpPayloadType);
 		REQUIRE(packet->GetLength() == 1000);
 		REQUIRE(packet->IsPaddedTo4Bytes());
 

package/worker/test/src/RTC/RTP/TestRtpStreamRecv.cpp

@@ -1,6 +1,7 @@
 #include "common.hpp"
 #include "RTC/RTCP/FeedbackPs.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
@@ -243,6 +244,55 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		listener.nackedSeqNumbers.clear();
 	}
 
+	SECTION("RTT is computed from Extended Reports")
+	{
+		RtpStreamRecvListener listener;
+		RTC::RTP::RtpStreamRecv rtpStream(
+		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
+
+		auto receiveDelaySinceLastRr = [&](int64_t receivedAtUs, uint32_t lastRr, uint32_t dlrr)
+		{
+			RTC::RTCP::DelaySinceLastRr::SsrcInfo ssrcInfo;
+
+			ssrcInfo.SetSsrc(params.ssrc);
+			ssrcInfo.SetLastReceiverReport(lastRr);
+			ssrcInfo.SetDelaySinceLastReceiverReport(dlrr);
+
+			rtpStream.ReceiveRtcpXrDelaySinceLastRr(std::addressof(ssrcInfo), receivedAtUs);
+		};
+
+		// The compact NTP representation has 16 bits of seconds, so it wraps around
+		// every 65536 seconds.
+		constexpr int64_t WrapUs{ 65536 * 1000000LL };
+
+		// The Receiver Reference Time is sent 1 second before the wrap, the remote
+		// endpoint holds it for half a second, and its answer arrives right at the wrap.
+		receiveDelaySinceLastRr(WrapUs, 0xFFFF0000, 0x8000);
+
+		REQUIRE(rtpStream.GetRttMs() == 500.0f);
+
+		// No Receiver Reference Time was received by the remote endpoint yet, so the
+		// last RTT is kept.
+		receiveDelaySinceLastRr(WrapUs, 0, 0);
+
+		REQUIRE(rtpStream.GetRttMs() == 500.0f);
+
+		// The remote endpoint answers the Receiver Reference Time right away.
+		receiveDelaySinceLastRr((10 * 1000000) + 500000, 0x000A0000, 0);
+
+		REQUIRE(rtpStream.GetRttMs() == 500.0f);
+
+		// A negative RTT yields 1 millisecond.
+		receiveDelaySinceLastRr(20 * 1000000, 0x00140000, 0x8000);
+
+		REQUIRE(rtpStream.GetRttMs() == 1.0f);
+
+		// So does a RTT too small to be true.
+		receiveDelaySinceLastRr(20 * 1000000, 0x0013FFFF, 0);
+
+		REQUIRE(rtpStream.GetRttMs() == 1.0f);
+	}
+
 	SECTION("require key frame")
 	{
 		RtpStreamRecvListener listener;

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

@@ -1,5 +1,6 @@
 #include "common.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/ReceiverReport.hpp"
 #include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTP/Codecs/AV1.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
@@ -1244,6 +1245,64 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		REQUIRE_FALSE(staleReport);
 	}
 
+	SECTION("RTT is computed from Receiver Reports")
+	{
+		TestRtpStreamListener testRtpStreamListener;
+
+		RTC::RTP::RtpStream::Params params;
+
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
+
+		std::string mid;
+
+		RTC::RTP::RtpStreamSend stream(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
+
+		auto receiveReceiverReport = [&](int64_t receivedAtUs, uint32_t lastSr, uint32_t dlsr)
+		{
+			RTC::RTCP::ReceiverReport report;
+
+			report.SetSsrc(params.ssrc);
+			report.SetLastSenderReport(lastSr);
+			report.SetDelaySinceLastSenderReport(dlsr);
+
+			stream.ReceiveRtcpReceiverReport(std::addressof(report), receivedAtUs);
+		};
+
+		// The compact NTP representation has 16 bits of seconds, so it wraps around
+		// every 65536 seconds.
+		constexpr int64_t WrapUs{ 65536 * 1000000LL };
+
+		// The Sender Report is sent 1 second before the wrap, the remote endpoint holds
+		// it for half a second, and the Receiver Report arrives right at the wrap.
+		receiveReceiverReport(WrapUs, 0xFFFF0000, 0x8000);
+
+		REQUIRE(stream.GetRttMs() == 500.0f);
+
+		// No Sender Report was received by the remote endpoint yet, so the last RTT is
+		// kept.
+		receiveReceiverReport(WrapUs, 0, 0);
+
+		REQUIRE(stream.GetRttMs() == 500.0f);
+
+		// The remote endpoint answers the Sender Report right away.
+		receiveReceiverReport((10 * 1000000) + 500000, 0x000A0000, 0);
+
+		REQUIRE(stream.GetRttMs() == 500.0f);
+
+		// A negative RTT yields 1 millisecond.
+		receiveReceiverReport(20 * 1000000, 0x00140000, 0x8000);
+
+		REQUIRE(stream.GetRttMs() == 1.0f);
+
+		// So does a RTT too small to be true.
+		receiveReceiverReport(20 * 1000000, 0x0013FFFF, 0);
+
+		REQUIRE(stream.GetRttMs() == 1.0f);
+	}
+
 #ifdef PERFORMANCE_TEST
 	SECTION("Performance")
 	{