mediasoup 3.24.2 → 3.25.0

package/worker/src/RTC/SimulcastProducerStreamManager.cpp

@@ -164,19 +164,32 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		// Just interested if this is the first Sender Report for a RTP stream.
-		if (!first)
+		if (first)
+		{
+			MS_DEBUG_TAG(simulcast, "first SenderReport [ssrc:%" PRIu32 "]", rtpStream->GetSsrc());
+		}
+
+		// If the capture instant of our RTP timestamp reference stream cannot be told
+		// yet, do nothing since we know we won't be able to switch.
+		auto* producerTsReferenceRtpStream = GetProducerTsReferenceRtpStream();
+
+		if (!producerTsReferenceRtpStream || !producerTsReferenceRtpStream->GetCaptureMapping().has_value())
 		{
 			return;
 		}
 
-		MS_DEBUG_TAG(simulcast, "first SenderReport [ssrc:%" PRIu32 "]", rtpStream->GetSsrc());
+		// Other than the first Sender Report of each stream, the only one worth checking
+		// layers upon is the one that makes the capture instant of the RTP timestamp
+		// reference stream known, since other spatial layers may become switchable then.
+		// NOTE: Doing it on every single Sender Report would ask the Transport to
+		// redistribute its outgoing bitrate at the pace of the RTCP of the sender and we
+		// don't want that.
+		const bool tsReferenceCaptureMappingIsNew =
+		  this->tsReferenceSpatialLayerWithCaptureMapping != this->tsReferenceSpatialLayer;
 
-		// If our RTP timestamp reference stream does not yet have SR, do nothing
-		// since we know we won't be able to switch.
-		auto* producerTsReferenceRtpStream = GetProducerTsReferenceRtpStream();
+		this->tsReferenceSpatialLayerWithCaptureMapping = this->tsReferenceSpatialLayer;
 
-		if (!producerTsReferenceRtpStream || !producerTsReferenceRtpStream->GetSenderReportNtpMs())
+		if (!first && !tsReferenceCaptureMappingIsNew)
 		{
 			return;
 		}
@@ -589,43 +602,71 @@ namespace RTC
 			{
 				tsOffset = 0u;
 			}
-			// If this is not the RTP stream we use as TS reference, do NTP based RTP
-			// TS synchronization.
+			// If this is not the RTP stream we use as TS reference, synchronize its RTP
+			// timestamps based on the capture instant of the media.
 			else
 			{
-				auto* producerTsReferenceRtpStream = GetProducerTsReferenceRtpStream();
-				auto* producerTargetRtpStream      = GetProducerTargetRtpStream();
-
-				// NOTE: If we are here is because we have Sender Reports for both the
-				// TS reference stream and the target one.
-				MS_ASSERT(
-				  producerTsReferenceRtpStream->GetSenderReportNtpMs(),
-				  "no Sender Report for TS reference RTP stream");
-				MS_ASSERT(
-				  producerTargetRtpStream->GetSenderReportNtpMs(), "no Sender Report for current RTP stream");
-
-				// Calculate NTP and TS stuff.
-				auto ntpMs1 = producerTsReferenceRtpStream->GetSenderReportNtpMs();
-				auto ts1    = producerTsReferenceRtpStream->GetSenderReportTs();
-				auto ntpMs2 = producerTargetRtpStream->GetSenderReportNtpMs();
-				auto ts2    = producerTargetRtpStream->GetSenderReportTs();
-				int64_t diffMs;
-
-				if (ntpMs2 >= ntpMs1)
+				const auto* producerTsReferenceRtpStream = GetProducerTsReferenceRtpStream();
+				// NOTE: The stream of the spatial layer of this packet, which is not always
+				// the one of the target spatial layer. A resync may be pending for the
+				// current spatial layer while the target one is a different one.
+				const auto* producerRtpStream = this->producerRtpStreams.at(spatialLayer);
+
+				const auto tsReferenceCaptureMapping = producerTsReferenceRtpStream->GetCaptureMapping();
+				const auto captureMapping            = producerRtpStream->GetCaptureMapping();
+
+				// Without the capture instant of the TS reference stream there is nothing to
+				// align this one to, so take this spatial layer as the new TS reference and
+				// let its RTP timestamps go untouched, which is what would have been done had
+				// it been chosen as TS reference in the first place.
+				if (!tsReferenceCaptureMapping.has_value())
 				{
-					diffMs = ntpMs2 - ntpMs1;
+					MS_DEBUG_TAG(
+					  simulcast,
+					  "cannot tell the capture instant of the TS reference stream, using spatial layer "
+					  "%" PRIi16 " as RTP timestamp reference",
+					  spatialLayer);
+
+					this->tsReferenceSpatialLayer = spatialLayer;
 				}
-				else
+				// The capture instant of this stream cannot be told yet, so there is no way to
+				// align it and no reason to give up a TS reference stream that is good. Discard
+				// the packet and wait, since the Sender Report that is missing is on its way.
+				else if (!captureMapping.has_value())
 				{
-					diffMs = -1 * (ntpMs1 - ntpMs2);
-				}
+					MS_DEBUG_TAG(
+					  simulcast,
+					  "cannot tell yet the capture instant of spatial layer %" PRIi16
+					  ", discarding packet [ssrc:%" PRIu32 ", seq:%" PRIu16 "]",
+					  spatialLayer,
+					  packet->GetSsrc(),
+					  packet->GetSequenceNumber());
+
+					// Ask for another key frame since this one is being discarded.
+					if (packet->IsKeyFrame())
+					{
+						RequestKeyFrame();
+					}
 
-				const int64_t diffTs  = diffMs * clockRate / 1000;
-				const uint32_t newTs2 = ts2 - diffTs;
+					result.type = RtpPacketProcessResult::Type::SILENT_DROP;
 
-				// Apply offset. This is the difference that later must be removed from
-				// the sending RTP packet.
-				tsOffset = newTs2 - ts1;
+					return result;
+				}
+				else
+				{
+					// Calculate capture instant and TS stuff.
+					const auto captureMs1 = tsReferenceCaptureMapping.value().captureMs;
+					const auto ts1        = tsReferenceCaptureMapping.value().ts;
+					const auto captureMs2 = captureMapping.value().captureMs;
+					const auto ts2        = captureMapping.value().ts;
+					const int64_t diffMs = static_cast<int64_t>(captureMs2) - static_cast<int64_t>(captureMs1);
+					const int64_t diffTs  = diffMs * clockRate / 1000;
+					const uint32_t newTs2 = ts2 - diffTs;
+
+					// Apply offset. This is the difference that later must be removed from
+					// the sending RTP packet.
+					tsOffset = newTs2 - ts1;
+				}
 			}
 
 			// When switching to a new stream it may happen that the timestamp of this
@@ -857,8 +898,9 @@ namespace RTC
 
 		// If we don't have yet a RTP timestamp reference, set it now.
 		if (
-		  newTargetSpatialLayer != -1 && (this->tsReferenceSpatialLayer == -1 ||
-		                                  !GetProducerTsReferenceRtpStream()->GetSenderReportNtpMs()))
+		  newTargetSpatialLayer != -1 &&
+		  (this->tsReferenceSpatialLayer == -1 ||
+		   !GetProducerTsReferenceRtpStream()->GetCaptureMapping().has_value()))
 		{
 			MS_DEBUG_TAG(
 			  simulcast, "using spatial layer %" PRIi16 " as RTP timestamp reference", newTargetSpatialLayer);
@@ -1050,7 +1092,7 @@ namespace RTC
 
 		return (
 		  this->tsReferenceSpatialLayer == -1 || spatialLayer == this->tsReferenceSpatialLayer ||
-		  this->producerRtpStreams.at(spatialLayer)->GetSenderReportNtpMs());
+		  this->producerRtpStreams.at(spatialLayer)->GetCaptureMapping().has_value());
 	}
 
 	RTC::RTP::RtpStreamRecv* SimulcastProducerStreamManager::GetProducerTsReferenceRtpStream() const

package/worker/src/RTC/Transport.cpp

@@ -640,6 +640,15 @@ namespace RTC
 				// Insert into the map.
 				this->mapProducers[producerId] = producer;
 
+				// Take this Producer into account for the capture time estimation of its
+				// sender.
+				{
+					const auto& cname = producer->GetRtpParameters().rtcp.cname;
+
+					this->mapCnameRemoteCaptureTimeEstimator[cname].UpdateSource(
+					  producer->GetRtpHeaderExtensionIds().absCaptureTime != 0);
+				}
+
 				MS_DEBUG_DEV("Producer created [producerId:%s]", producerId.c_str());
 
 				// Take the transport related RTP header extensions of the Producer and
@@ -680,6 +689,14 @@ namespace RTC
 					  producerRtpHeaderExtensionIds.dependencyDescriptor;
 				}
 
+				// NOTE: Not transport related, but needed here so that received packets carry
+				// its id and `RtpStreamRecv` can read the extension off them.
+				if (producerRtpHeaderExtensionIds.absCaptureTime != 0)
+				{
+					this->recvRtpHeaderExtensionIds.absCaptureTime =
+					  producerRtpHeaderExtensionIds.absCaptureTime;
+				}
+
 				// Create status response.
 				auto responseOffset = FBS::Transport::CreateProduceResponse(
 				  request->GetBufferBuilder(), FBS::RtpParameters::Type(producer->GetType()));
@@ -1245,6 +1262,26 @@ namespace RTC
 				// Remove it from the map.
 				this->mapProducers.erase(producer->id);
 
+				// Remove the capture time estimator of its sender once its last Producer
+				// is gone.
+				{
+					const auto& cname = producer->GetRtpParameters().rtcp.cname;
+
+					const bool cnameStillInUse = std::ranges::any_of(
+					  this->mapProducers,
+					  [&cname](const auto& kv)
+					  {
+						  const auto* otherProducer = kv.second;
+
+						  return otherProducer->GetRtpParameters().rtcp.cname == cname;
+					  });
+
+					if (!cnameStillInUse)
+					{
+						this->mapCnameRemoteCaptureTimeEstimator.erase(cname);
+					}
+				}
+
 				// Tell the child class to clear associated SSRCs.
 				for (const auto& kv : producer->GetRtpStreams())
 				{
@@ -2538,6 +2575,17 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		// Feed the capture time estimator of the sender of this Producer.
+		const auto it =
+		  this->mapCnameRemoteCaptureTimeEstimator.find(producer->GetRtpParameters().rtcp.cname);
+
+		if (it != this->mapCnameRemoteCaptureTimeEstimator.end())
+		{
+			auto& remoteCaptureTimeEstimator = it->second;
+
+			remoteCaptureTimeEstimator.SenderReportReceived(rtpStream);
+		}
+
 		this->listener->OnTransportProducerRtcpSenderReport(this, producer, rtpStream, first);
 	}
 
@@ -2555,13 +2603,57 @@ namespace RTC
 		SendRtcpPacket(packet);
 	}
 
-	void Transport::OnProducerNeedWorstRemoteFractionLost(
-	  RTC::Producer* producer, uint32_t mappedSsrc, uint8_t& worstRemoteFractionLost)
+	uint8_t Transport::OnProducerNeedWorstRemoteFractionLost(RTC::Producer* producer, uint32_t mappedSsrc)
+	{
+		MS_TRACE();
+
+		return this->listener->OnTransportNeedWorstRemoteFractionLost(this, producer, mappedSsrc);
+	}
+
+	std::optional<uint64_t> Transport::OnProducerNeedLocalCaptureMs(
+	  RTC::Producer* producer, const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts)
+	{
+		MS_TRACE();
+
+		const auto it =
+		  this->mapCnameRemoteCaptureTimeEstimator.find(producer->GetRtpParameters().rtcp.cname);
+
+		if (it == this->mapCnameRemoteCaptureTimeEstimator.end())
+		{
+			return std::nullopt;
+		}
+
+		const auto& remoteCaptureTimeEstimator = it->second;
+
+		return remoteCaptureTimeEstimator.GetLocalCaptureMs(rtpStream, ts);
+	}
+
+	std::optional<int64_t> Transport::OnProducerNeedRemoteClockOffsetMs(const RTC::Producer* producer)
 	{
 		MS_TRACE();
 
-		this->listener->OnTransportNeedWorstRemoteFractionLost(
-		  this, producer, mappedSsrc, worstRemoteFractionLost);
+		const auto it =
+		  this->mapCnameRemoteCaptureTimeEstimator.find(producer->GetRtpParameters().rtcp.cname);
+
+		if (it == this->mapCnameRemoteCaptureTimeEstimator.end())
+		{
+			return std::nullopt;
+		}
+
+		const auto& remoteCaptureTimeEstimator = it->second;
+		const auto clockOffsetMs               = remoteCaptureTimeEstimator.GetClockOffsetMs();
+
+		if (!clockOffsetMs.has_value())
+		{
+			return std::nullopt;
+		}
+
+		// NOTE: The estimator gives the offset against our own monotonic clock, while what
+		// a receiver reconstructs out of the Sender Reports we send is the clock we
+		// announce, so the distance to the NTP epoch has to be taken into account. Both
+		// terms are huge and their sum is small, so they are added as milliseconds before
+		// anything scales them up.
+		return clockOffsetMs.value() + static_cast<int64_t>(this->shared->GetNtpOffsetMs());
 	}
 
 	void Transport::OnConsumerSendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet)

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

@@ -1059,12 +1059,16 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		  /*paddingLength*/ 0);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
+		REQUIRE(packet->GetCaptureMs() == std::nullopt);
 
 		packet->SetPayloadType(100);
 		packet->SetMarker(true);
 		packet->SetSequenceNumber(12345);
 		packet->SetTimestamp(987654321);
 		packet->SetSsrc(1234567890);
+		packet->SetCaptureMs(99998888);
+
+		REQUIRE(packet->GetCaptureMs() == 99998888);
 
 		std::vector<RTC::RTP::Packet::Extension> extensions;
 
@@ -1204,6 +1208,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(extensionLen == 3);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
+		REQUIRE(packet->GetCaptureMs() == 99998888);
 
 		/* Clone it. */
 
@@ -1252,6 +1257,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(extensionLen == 3);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
+		REQUIRE(packet->GetCaptureMs() == 99998888);
 
 		/* Set payload. */
 

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

@@ -106,9 +106,9 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 			}
 		}
 
-		void OnRtpStreamNeedWorstRemoteFractionLost(
-		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t& /*worstRemoteFractionLost*/) override
+		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* /*rtpStream*/) override
 		{
+			return 0;
 		}
 
 	public:

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

@@ -1,5 +1,6 @@
 #include "common.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTP/Codecs/AV1.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/RTP/Codecs/VP8.hpp"
@@ -1125,6 +1126,124 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		REQUIRE(result == RTC::RTP::RtpStreamSend::ReceivePacketResult::DISCARDED);
 	}
 
+	SECTION("Sender Report RTP timestamp is based on the capture instant when known")
+	{
+		// Instant reported by the mocked clock, and hence the one at which packets are seen.
+		constexpr uint64_t PacketMs{ 1000 };
+		constexpr uint32_t PacketTs{ 1533790901 };
+
+		TestRtpStreamListener testRtpStreamListener;
+
+		RTC::RTP::RtpStream::Params params;
+
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
+
+		std::string mid;
+
+		// Without capture instant, the instant at which the packet was seen is used.
+		{
+			RTC::RTP::RtpStreamSend stream(
+			  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
+			auto packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
+
+			sendRtpPacket(
+			  {
+			    { std::addressof(stream), params.ssrc }
+      },
+			  packet.get());
+
+			const std::unique_ptr<RTC::RTCP::SenderReport> report(
+			  stream.GetRtcpSenderReport(PacketMs + 1000));
+
+			REQUIRE(report);
+			REQUIRE(report->GetRtpTs() == PacketTs + params.clockRate);
+		}
+
+		// With capture instant, the extra half second since it is accounted for.
+		{
+			RTC::RTP::RtpStreamSend stream(
+			  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
+			auto packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
+
+			packet->SetCaptureMs(PacketMs - 500);
+
+			sendRtpPacket(
+			  {
+			    { std::addressof(stream), params.ssrc }
+      },
+			  packet.get());
+
+			const std::unique_ptr<RTC::RTCP::SenderReport> report(
+			  stream.GetRtcpSenderReport(PacketMs + 1000));
+
+			REQUIRE(report);
+			REQUIRE(report->GetRtpTs() == PacketTs + ((1500 * params.clockRate) / 1000));
+		}
+
+		// A capture instant ahead of now, which the estimation may yield, does not make the
+		// difference wrap around.
+		{
+			RTC::RTP::RtpStreamSend stream(
+			  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
+			auto packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
+
+			packet->SetCaptureMs(PacketMs + 3000);
+
+			sendRtpPacket(
+			  {
+			    { std::addressof(stream), params.ssrc }
+      },
+			  packet.get());
+
+			const std::unique_ptr<RTC::RTCP::SenderReport> report(
+			  stream.GetRtcpSenderReport(PacketMs + 1000));
+
+			REQUIRE(report);
+			REQUIRE(report->GetRtpTs() == PacketTs);
+		}
+	}
+
+	SECTION("no Sender Report is generated once the stream has stopped sending")
+	{
+		// Instant reported by the mocked clock, and hence the one at which packets are seen.
+		constexpr uint64_t PacketMs{ 1000 };
+		constexpr uint32_t PacketTs{ 1533790901 };
+
+		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 packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
+
+		sendRtpPacket(
+		  {
+		    { std::addressof(stream), params.ssrc }
+    },
+		  packet.get());
+
+		// Right at the limit the Sender Report is still generated.
+		const std::unique_ptr<RTC::RTCP::SenderReport> report(
+		  stream.GetRtcpSenderReport(PacketMs + RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs));
+
+		REQUIRE(report);
+
+		// Past the limit it is not.
+		const std::unique_ptr<RTC::RTCP::SenderReport> staleReport(stream.GetRtcpSenderReport(
+		  PacketMs + RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs + 1));
+
+		REQUIRE_FALSE(staleReport);
+	}
+
 #ifdef PERFORMANCE_TEST
 	SECTION("Performance")
 	{

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

@@ -33,9 +33,9 @@ namespace
 		{
 		}
 
-		void OnRtpStreamNeedWorstRemoteFractionLost(
-		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t& /*worstRemoteFractionLost*/) override
+		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* /*rtpStream*/) override
 		{
+			return 0;
 		}
 	};
 
@@ -104,7 +104,8 @@ namespace
 
 		encoding.ssrc = 1234567890;
 
-		rtpParameters.mid = "mid";
+		rtpParameters.mid        = "mid";
+		rtpParameters.rtcp.cname = "cname";
 		rtpParameters.codecs.emplace_back(codec);
 		rtpParameters.encodings.emplace_back(encoding);
 		rtpParameters.headerExtensions = std::vector<RTC::RtpHeaderExtensionParameters>();

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

@@ -10,7 +10,7 @@
 // merged unrelated bindings. This scenario locks down the post-fix
 // behavior: distinct tuples produce distinct keys, equal tuples produce equal
 // keys.
-SCENARIO("PortManager", "[rtc][portmanager]")
+SCENARIO("PortManager", "[portmanager]")
 {
 	// Helper: build an IPv4 `sockaddr_storage` from a dotted-quad string + port=0.
 	auto makeV4 = [](const char* dottedQuad)

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());
+	}
+}