mediasoup 3.24.2 → 3.26.0

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

@@ -0,0 +1,164 @@
+#include "common.hpp"
+#include "RTC/RTCP/SenderReport.hpp"
+#include "RTC/RTP/RtpStreamRecv.hpp"
+#include "RTC/RemoteCaptureTimeEstimator.hpp"
+#include "mocks/include/MockShared.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]")
+{
+	// Wall clock of the remote sender when it generates its first Sender Report
+	// (seconds since 1900).
+	constexpr uint32_t RemoteBaseNtpSec{ 3976000000 };
+	// RTP timestamp that first Sender Report reports about.
+	constexpr uint32_t RemoteBaseTs{ 1000000 };
+	// Our own monotonic clock when that first Sender Report arrives.
+	constexpr uint64_t LocalBaseMs{ 1000000 };
+	constexpr uint32_t ClockRate{ 90000 };
+	constexpr uint32_t Ssrc{ 1111 };
+
+	class RtpStreamRecvListener : public RTC::RTP::RtpStreamRecv::Listener
+	{
+	public:
+		void OnRtpStreamScore(
+		  RTC::RTP::RtpStream* /*rtpStream*/, uint8_t /*score*/, uint8_t /*previousScore*/) override
+		{
+		}
+
+		void OnRtpStreamSendRtcpPacket(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, RTC::RTCP::Packet* /*packet*/) override
+		{
+		}
+
+		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* /*rtpStream*/) override
+		{
+			return 0;
+		}
+	};
+
+	uint64_t nowMs{ LocalBaseMs };
+
+	mocks::MockShared shared(/*getTimeMs*/
+	                         [&nowMs]() -> uint64_t
+	                         {
+		                         return nowMs;
+	                         });
+
+	RTC::RTP::RtpStream::Params params;
+
+	params.ssrc      = Ssrc;
+	params.clockRate = ClockRate;
+
+	RtpStreamRecvListener listener;
+	RTC::RTP::RtpStreamRecv rtpStream(
+	  std::addressof(listener),
+	  std::addressof(shared),
+	  params,
+	  /*sendNackDelayMs*/ 0,
+	  /*useRtpInactivityCheck*/ false);
+
+	RTC::RemoteCaptureTimeEstimator estimator;
+
+	// Makes the Sender Report about `RemoteBaseTs` plus `idx` seconds of media reach
+	// us with no delay at all, and feeds it to the estimator.
+	auto receiveSenderReport = [&nowMs, &rtpStream, &estimator](uint32_t idx) -> void
+	{
+		nowMs = LocalBaseMs + (idx * 1000);
+
+		RTC::RTCP::SenderReport report;
+
+		report.SetSsrc(Ssrc);
+		report.SetNtpSec(RemoteBaseNtpSec + idx);
+		report.SetNtpFrac(0);
+		report.SetRtpTs(RemoteBaseTs + (idx * ClockRate));
+
+		rtpStream.ReceiveRtcpSenderReport(std::addressof(report));
+		estimator.SenderReportReceived(std::addressof(rtpStream));
+	};
+
+	SECTION("no source until the first Producer has been taken into account")
+	{
+		REQUIRE_FALSE(estimator.GetSource().has_value());
+		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+	}
+
+	SECTION("the first Producer chooses abs-capture-time when it negotiated it")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME);
+	}
+
+	SECTION("the first Producer chooses Sender Report when it did not negotiate abs-capture-time")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ false);
+
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
+	}
+
+	SECTION("a Producer without abs-capture-time moves the source to Sender Report")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ false);
+
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
+	}
+
+	SECTION("the source never moves back to abs-capture-time")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ false);
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
+	}
+
+	SECTION("the capture instant is translated into our clock")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ false);
+
+		// A single Sender Report is not enough for the clock offset to be estimated.
+		receiveSenderReport(0);
+
+		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+
+		for (uint32_t idx{ 1 }; idx < RTC::RemoteClockOffsetEstimator::MinSampleCount; ++idx)
+		{
+			receiveSenderReport(idx);
+		}
+
+		// The Sender Reports reached us with no delay, so the capture instant of the
+		// RTP timestamp of the last one is the very instant at which it arrived.
+		const auto lastIdx = RTC::RemoteClockOffsetEstimator::MinSampleCount - 1;
+		const auto lastTs  = static_cast<uint32_t>(RemoteBaseTs + (lastIdx * ClockRate));
+
+		REQUIRE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), lastTs).has_value());
+		REQUIRE(
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  estimator.GetLocalCaptureMs(std::addressof(rtpStream), lastTs).value() ==
+		  LocalBaseMs + (lastIdx * 1000));
+
+		// One second of media later maps one second later in our clock too.
+		const auto nextTs = static_cast<uint32_t>(RemoteBaseTs + ((lastIdx + 1) * ClockRate));
+
+		REQUIRE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), nextTs).has_value());
+		REQUIRE(
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  estimator.GetLocalCaptureMs(std::addressof(rtpStream), nextTs).value() ==
+		  LocalBaseMs + ((lastIdx + 1) * 1000));
+	}
+
+	SECTION("no capture instant while the abs-capture-time source has nothing to offer")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+
+		for (uint32_t idx{ 0 }; idx < RTC::RemoteClockOffsetEstimator::MinSampleCount; ++idx)
+		{
+			receiveSenderReport(idx);
+		}
+
+		// Sender Reports have been received, but the source in use is not allowed to
+		// fall back to them.
+		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+	}
+}

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

@@ -0,0 +1,241 @@
+#include "common.hpp"
+#include "RTC/RemoteClockOffsetEstimator.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]")
+{
+	// Remote sender wall clock, as reported in the NTP field of its Sender Reports
+	// (milliseconds since 1900).
+	constexpr uint64_t RemoteBaseMs{ 3976000000000 };
+	// Our own monotonic clock.
+	constexpr uint64_t LocalBaseMs{ 1000000 };
+	// Offset expected when Sender Reports reach us with no delay at all.
+	constexpr int64_t BaseOffsetMs{ static_cast<int64_t>(LocalBaseMs) -
+		                              static_cast<int64_t>(RemoteBaseMs) };
+
+	const auto minSampleCount = RTC::RemoteClockOffsetEstimator::MinSampleCount;
+	const auto windowSize     = RTC::RemoteClockOffsetEstimator::WindowSize;
+
+	// Feeds `count` Sender Reports one second apart, each one reaching us `owdMs`
+	// after having been generated by the sender.
+	auto feed = [](
+	              RTC::RemoteClockOffsetEstimator& estimator,
+	              uint64_t remoteNtpMs,
+	              uint64_t localArrivalMs,
+	              size_t count,
+	              uint64_t owdMs,
+	              uint32_t rttMs) -> void
+	{
+		for (size_t idx{ 0 }; idx < count; ++idx)
+		{
+			const uint64_t elapsedMs = static_cast<uint64_t>(idx) * 1000;
+
+			estimator.AddSenderReport(remoteNtpMs + elapsedMs, localArrivalMs + elapsedMs + owdMs, rttMs);
+		}
+	};
+
+	RTC::RemoteClockOffsetEstimator estimator;
+
+	SECTION("no offset until MinSampleCount Sender Reports have been received")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount - 1, 0, 0);
+
+		REQUIRE_FALSE(estimator.GetOffsetMs().has_value());
+
+		// One more Sender Report reaches the minimum.
+		const uint64_t elapsedMs = static_cast<uint64_t>(minSampleCount - 1) * 1000;
+
+		feed(estimator, RemoteBaseMs + elapsedMs, LocalBaseMs + elapsedMs, 1, 0, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+	}
+
+	SECTION("the offset carries the Sender Report one way delay when the RTT is unknown")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount, 40, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + 40);
+	}
+
+	SECTION("half of the RTT is removed from the offset")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount, 40, 80);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+	}
+
+	SECTION("a single delayed Sender Report does not move the offset")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, windowSize, 20, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + 20);
+
+		// A Sender Report that took much longer to reach us must be rejected by the
+		// median.
+		const uint64_t elapsedMs = static_cast<uint64_t>(windowSize) * 1000;
+
+		feed(estimator, RemoteBaseMs + elapsedMs, LocalBaseMs + elapsedMs, 1, 500, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + 20);
+	}
+
+	SECTION("the offset follows a sustained change in delay")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, windowSize, 0, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+
+		// Once the whole window has been replaced the new delay is fully reflected.
+		const uint64_t elapsedMs = static_cast<uint64_t>(windowSize) * 1000;
+
+		feed(estimator, RemoteBaseMs + elapsedMs, LocalBaseMs + elapsedMs, windowSize, 100, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + 100);
+	}
+
+	SECTION("delayed Sender Reports move the offset once they are the majority")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, windowSize, 0, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+
+		// Less than half of the window delayed, so the median still falls on a
+		// Sender Report that reached us with no delay.
+		uint64_t elapsedMs = static_cast<uint64_t>(windowSize) * 1000;
+
+		feed(estimator, RemoteBaseMs + elapsedMs, LocalBaseMs + elapsedMs, windowSize / 2, 300, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+
+		// One more delayed Sender Report makes them the majority.
+		elapsedMs += static_cast<uint64_t>(windowSize / 2) * 1000;
+
+		feed(estimator, RemoteBaseMs + elapsedMs, LocalBaseMs + elapsedMs, 1, 300, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + 300);
+	}
+
+	SECTION("the offset tracks a drifting remote clock")
+	{
+		// The remote wall clock runs one millisecond per second slower than ours, so
+		// each Sender Report yields an offset one millisecond higher than the
+		// previous one.
+		for (size_t idx{ 0 }; idx < windowSize; ++idx)
+		{
+			estimator.AddSenderReport(
+			  RemoteBaseMs + (static_cast<uint64_t>(idx) * 1000),
+			  LocalBaseMs + (static_cast<uint64_t>(idx) * 1001),
+			  0);
+		}
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// The samples in the window grow by one millisecond each, so the median is
+		// the middle of that ramp.
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs + static_cast<int64_t>(windowSize / 2));
+
+		// The drift keeps going, so the offset keeps up with it rather than sticking
+		// to the value it already had.
+		for (size_t idx{ windowSize }; idx < windowSize * 2; ++idx)
+		{
+			estimator.AddSenderReport(
+			  RemoteBaseMs + (static_cast<uint64_t>(idx) * 1000),
+			  LocalBaseMs + (static_cast<uint64_t>(idx) * 1001),
+			  0);
+		}
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		REQUIRE(
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  estimator.GetOffsetMs().value() ==
+		  BaseOffsetMs + static_cast<int64_t>(windowSize + (windowSize / 2)));
+	}
+
+	SECTION("all the Sender Reports of a compound packet produce a single sample")
+	{
+		// Three Sender Reports of a same compound packet, hence a single arrival
+		// time.
+		estimator.AddSenderReport(RemoteBaseMs, LocalBaseMs, 0);
+		estimator.AddSenderReport(RemoteBaseMs + 1, LocalBaseMs, 0);
+		estimator.AddSenderReport(RemoteBaseMs + 2, LocalBaseMs, 0);
+
+		REQUIRE_FALSE(estimator.GetOffsetMs().has_value());
+
+		// Two more compound packets reach the minimum.
+		estimator.AddSenderReport(RemoteBaseMs + 1000, LocalBaseMs + 1000, 0);
+		estimator.AddSenderReport(RemoteBaseMs + 1001, LocalBaseMs + 1000, 0);
+		estimator.AddSenderReport(RemoteBaseMs + 2000, LocalBaseMs + 2000, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+	}
+
+	SECTION("Sender Reports with no NTP timestamp are ignored")
+	{
+		// NOTE: Not using feed() here since it would advance the NTP timestamp.
+		estimator.AddSenderReport(0, LocalBaseMs, 0);
+		estimator.AddSenderReport(0, LocalBaseMs + 1000, 0);
+		estimator.AddSenderReport(0, LocalBaseMs + 2000, 0);
+
+		REQUIRE_FALSE(estimator.GetOffsetMs().has_value());
+	}
+
+	SECTION("remote times are translated into our clock")
+	{
+		const RTC::RemoteClockOffsetEstimator untrainedEstimator;
+
+		REQUIRE_FALSE(untrainedEstimator.RemoteMsToLocalMs(RemoteBaseMs).has_value());
+
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount, 0, 0);
+
+		REQUIRE(estimator.RemoteMsToLocalMs(RemoteBaseMs).has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.RemoteMsToLocalMs(RemoteBaseMs).value() == LocalBaseMs);
+		REQUIRE(estimator.RemoteMsToLocalMs(RemoteBaseMs + 500).has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.RemoteMsToLocalMs(RemoteBaseMs + 500).value() == LocalBaseMs + 500);
+
+		// A remote time older than the origin of our clock cannot be translated.
+		REQUIRE_FALSE(estimator.RemoteMsToLocalMs(0).has_value());
+	}
+
+	SECTION("Reset() clears the estimation")
+	{
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount, 0, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+
+		estimator.Reset();
+
+		REQUIRE_FALSE(estimator.GetOffsetMs().has_value());
+
+		// The last arrival time is forgotten as well, so Sender Reports arriving at
+		// the very same times as before the reset are not taken as duplicates.
+		feed(estimator, RemoteBaseMs, LocalBaseMs, minSampleCount, 0, 0);
+
+		REQUIRE(estimator.GetOffsetMs().has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(estimator.GetOffsetMs().value() == BaseOffsetMs);
+	}
+}

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

@@ -61,9 +61,9 @@ namespace
 		{
 		}
 
-		void OnRtpStreamNeedWorstRemoteFractionLost(
-		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t& /*worstRemoteFractionLost*/) override
+		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* /*rtpStream*/) override
 		{
+			return 0;
 		}
 	};