mediasoup 3.24.2 → 3.26.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;
 		}
@@ -225,6 +238,11 @@ namespace RTC
 		uint32_t requiredBitrate{ 0u };
 		int16_t spatialLayer{ 0 };
 		int16_t temporalLayer{ 0 };
+		// Whether a usable spatial layer has been found, in which case we must not
+		// go above the preferred spatial layer. Same criteria as in
+		// RecalculateTargetLayers(), so both take the same decision no matter the
+		// bitrate of the layer.
+		bool usableSpatialLayerFound{ this->provisionalTargetLayers.spatial != -1 };
 
 		for (size_t sIdx{ 0u }; sIdx < this->producerRtpStreams.size(); ++sIdx)
 		{
@@ -249,8 +267,12 @@ namespace RTC
 			{
 				continue;
 			}
-			// If this is higher than preferred spatial layer, abort.
-			else if (spatialLayer > this->preferredLayers.spatial)
+			// If this is higher than preferred spatial layer, abort unless no lower
+			// spatial layer is usable or this is the provisional one (so we may still
+			// increase its temporal layer).
+			else if (
+			  spatialLayer > this->preferredLayers.spatial && usableSpatialLayerFound &&
+			  spatialLayer != this->provisionalTargetLayers.spatial)
 			{
 				MS_DEBUG_DEV(
 				  "avoid upgrading to spatial layer %" PRIi16
@@ -300,10 +322,19 @@ namespace RTC
 				continue;
 			}
 
+			// This spatial layer is usable even if it has no bitrate at all.
+			usableSpatialLayerFound = true;
+
 			temporalLayer = 0;
 
+			// Don't consider temporal layers above the preferred one, nor above the
+			// ones this stream has.
+			const auto maxTemporalLayer = std::min(
+			  static_cast<int16_t>(producerRtpStream->GetTemporalLayers() - 1),
+			  this->preferredLayers.temporal);
+
 			// Check bitrate of every temporal layer.
-			for (; std::cmp_less(temporalLayer, producerRtpStream->GetTemporalLayers()); ++temporalLayer)
+			for (; temporalLayer <= maxTemporalLayer; ++temporalLayer)
 			{
 				// Ignore temporal layers lower than the one we already have (taking
 				// into account the spatial layer too).
@@ -589,43 +620,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 +916,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);
@@ -962,6 +1022,13 @@ namespace RTC
 				continue;
 			}
 
+			// Don't go above the preferred spatial layer if we already found a usable
+			// lower one.
+			if (spatialLayer > this->preferredLayers.spatial && newTargetLayers.spatial != -1)
+			{
+				break;
+			}
+
 			newTargetLayers.spatial = spatialLayer;
 
 			// If this is the preferred or higher spatial layer take it and exit.
@@ -973,19 +1040,11 @@ namespace RTC
 
 		if (newTargetLayers.spatial != -1)
 		{
-			if (newTargetLayers.spatial == this->preferredLayers.spatial)
-			{
-				newTargetLayers.temporal = this->preferredLayers.temporal;
-			}
-			else if (newTargetLayers.spatial < this->preferredLayers.spatial)
-			{
-				newTargetLayers.temporal =
-				  static_cast<int16_t>(this->encodingContext->GetTemporalLayers() - 1);
-			}
-			else
-			{
-				newTargetLayers.temporal = 0;
-			}
+			// Don't consider temporal layers above the preferred one, nor above the
+			// ones this stream has.
+			newTargetLayers.temporal = std::min(
+			  this->preferredLayers.temporal,
+			  static_cast<int16_t>(this->encodingContext->GetTemporalLayers() - 1));
 		}
 
 		// Return true if any target layer changed.
@@ -1050,7 +1109,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/SvcProducerStreamManager.cpp

@@ -190,9 +190,14 @@ namespace RTC
 
 			temporalLayer = 0;
 
+			// Don't consider temporal layers above the preferred one, nor above the
+			// ones this stream has.
+			const auto maxTemporalLayer = std::min(
+			  static_cast<int16_t>(this->producerRtpStream->GetTemporalLayers() - 1),
+			  this->preferredLayers.temporal);
+
 			// Check bitrate of every temporal layer.
-			for (; std::cmp_less(temporalLayer, this->producerRtpStream->GetTemporalLayers());
-			     ++temporalLayer)
+			for (; temporalLayer <= maxTemporalLayer; ++temporalLayer)
 			{
 				// Ignore temporal layers lower than the one we already have (taking
 				// into account the spatial layer too).
@@ -247,8 +252,9 @@ namespace RTC
 				}
 			}
 
-			// If this is the preferred or higher spatial layer, take it and exit.
-			if (spatialLayer >= this->preferredLayers.spatial)
+			// If this is the preferred or higher spatial layer, take it and exit,
+			// unless we have not found any usable spatial layer yet.
+			if (spatialLayer >= this->preferredLayers.spatial && this->provisionalTargetLayers.spatial != -1)
 			{
 				break;
 			}
@@ -589,6 +595,13 @@ namespace RTC
 				continue;
 			}
 
+			// Don't go above the preferred spatial layer if we already found a usable
+			// lower one.
+			if (spatialLayer > this->preferredLayers.spatial && newTargetLayers.spatial != -1)
+			{
+				break;
+			}
+
 			newTargetLayers.spatial = spatialLayer;
 
 			// If this is the preferred or higher spatial layer and has bitrate,
@@ -601,19 +614,11 @@ namespace RTC
 
 		if (newTargetLayers.spatial != -1)
 		{
-			if (newTargetLayers.spatial == this->preferredLayers.spatial)
-			{
-				newTargetLayers.temporal = this->preferredLayers.temporal;
-			}
-			else if (newTargetLayers.spatial < this->preferredLayers.spatial)
-			{
-				newTargetLayers.temporal =
-				  static_cast<int16_t>(this->encodingContext->GetTemporalLayers() - 1);
-			}
-			else
-			{
-				newTargetLayers.temporal = 0;
-			}
+			// Don't consider temporal layers above the preferred one, nor above the
+			// ones this stream has.
+			newTargetLayers.temporal = std::min(
+			  this->preferredLayers.temporal,
+			  static_cast<int16_t>(this->encodingContext->GetTemporalLayers() - 1));
 		}
 
 	done:

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)