mediasoup 3.27.0 → 3.28.0

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

@@ -1,7 +1,8 @@
 #include "common.hpp"
 #include "RTC/RateCalculator.hpp"
 #include <catch2/catch_test_macros.hpp>
-#include <limits> // std::numeric_limits
+#include <cstdlib> // std::abs()
+#include <limits>  // std::numeric_limits
 #include <vector>
 
 SCENARIO("RateCalculator", "[rate-calculator]")
@@ -10,7 +11,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	{
 		int64_t offset;
 		uint32_t size;
-		uint32_t rate;
+		std::optional<int64_t> rate;
 	};
 
 	auto validate =
@@ -23,23 +24,249 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 			REQUIRE(rate.GetRate(timeBaseMs + item.offset) == item.rate);
 		}
 
-		// Repeat asking for the rate at a time older than the whole window, which
-		// must leave it untouched.
+		// Repeat asking for the rate at a time older than the whole window. There is
+		// no period between the samples and a time that precedes all of them, so
+		// there is nothing to measure.
 		rate.Reset();
 
 		for (const auto& item : input)
 		{
 			rate.Update(item.size, timeBaseMs + item.offset);
 
-			REQUIRE(rate.GetRate(item.offset) == item.rate);
+			REQUIRE(rate.GetRate(item.offset) == std::nullopt);
 		}
 
+		// The reads above left the data untouched, so the rate at the time of the
+		// latest sample is still the one that was reported for it.
+		REQUIRE(rate.GetRate(timeBaseMs + input.back().offset) == input.back().rate);
+
 		// Asking for the rate far in the future expires every item.
-		REQUIRE(rate.GetRate(std::numeric_limits<int64_t>::max()) == 0);
+		REQUIRE(rate.GetRate(std::numeric_limits<int64_t>::max()) == std::nullopt);
 	};
 
 	const int64_t nowMs = 12345678;
 
+	// NOTE: This pins the three states in which there is nothing to measure, and
+	// that a lone sample does become a measurement once the window has filled
+	// around it.
+	SECTION("no rate until there is something to measure")
+	{
+		RTC::RateCalculator rate(1000, 8000, 100);
+
+		// Not a single sample.
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+
+		rate.Update(5, nowMs);
+
+		// A single sample taken at an instant says how much data there was, not how
+		// fast it is flowing.
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+		REQUIRE(rate.GetRate(nowMs + 500) == std::nullopt);
+
+		// Once the window has filled, that lone sample is all the data there was
+		// during a whole window, which is a rate.
+		REQUIRE(rate.GetRate(nowMs + 999) == 40);
+
+		// And one more item later it has expired, leaving nothing again.
+		REQUIRE(rate.GetRate(nowMs + 1000) == std::nullopt);
+	}
+
+	// NOTE: This pins the headline of the whole thing: the divisor is the period
+	// the samples span, not the window they sit in. Dividing by the window here
+	// would report 32 bps for a link carrying 16 kbps.
+	SECTION("rate is measured over the period the samples span")
+	{
+		RTC::RateCalculator rate(1000, 8000, 100);
+
+		rate.Update(1000, nowMs);
+		rate.Update(1000, nowMs + 999);
+
+		// The period is the whole window, so both samples count: 2000 * 8000 / 1000.
+		REQUIRE(rate.GetRate(nowMs + 999) == 16000);
+	}
+
+	// NOTE: The five sections below use a window of 500 ms split into items of a
+	// single millisecond, so that expiration happens sample by sample and every
+	// expected value can be worked out by hand.
+
+	SECTION("a lone sample is measured once the window has filled around it")
+	{
+		// window: 500ms, items: 500 (granularity: 1ms)
+		RTC::RateCalculator rate(500, 8000, 500);
+
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+
+		// One byte per millisecond, given as a single sample.
+		rate.Update(500, nowMs);
+
+		// Only one sample, and the window has not filled.
+		REQUIRE(rate.GetRate(nowMs + 498) == std::nullopt);
+
+		// Now it has, so the single sample is all the data of a whole window.
+		REQUIRE(rate.GetRate(nowMs + 499) == 1000 * 8);
+
+		// Another one on top doubles it.
+		rate.Update(500, nowMs + 499);
+
+		REQUIRE(rate.GetRate(nowMs + 499) == 2 * 1000 * 8);
+
+		// And now the first one drops out.
+		REQUIRE(rate.GetRate(nowMs + 500) == 1000 * 8);
+	}
+
+	SECTION("samples of size zero are measured as no data rather than no rate")
+	{
+		// window: 500ms, items: 500 (granularity: 1ms)
+		RTC::RateCalculator rate(500, 8000, 500);
+
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+
+		rate.Update(500, nowMs);
+		rate.Update(0, nowMs + 499);
+
+		REQUIRE(rate.GetRate(nowMs + 499) == 1000 * 8);
+
+		// The first sample drops out, leaving the empty one, which is a rate of
+		// zero rather than no rate at all.
+		REQUIRE(rate.GetRate(nowMs + 500) == 0);
+
+		// And now the empty one drops out too.
+		REQUIRE(rate.GetRate(nowMs + 1000) == std::nullopt);
+	}
+
+	SECTION("a quiet period is measured as no data until it empties the window")
+	{
+		// window: 500ms, items: 500 (granularity: 1ms)
+		RTC::RateCalculator rate(500, 8000, 500);
+
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+
+		rate.Update(0, nowMs);
+
+		REQUIRE(rate.GetRate(nowMs + 499) == 0);
+
+		// Move the window along so that the sample falls out.
+		REQUIRE(rate.GetRate(nowMs + 500) == std::nullopt);
+
+		// Move it a long way out, which makes the next sample start a new period.
+		rate.Update(0, nowMs + 1500);
+
+		REQUIRE(rate.GetRate(nowMs + 1500) == std::nullopt);
+
+		// The second one gives a period to measure over.
+		rate.Update(0, nowMs + 1501);
+
+		REQUIRE(rate.GetRate(nowMs + 1501) == 0);
+	}
+
+	SECTION("silence longer than the window starts a new period")
+	{
+		// window: 500ms, items: 500 (granularity: 1ms)
+		RTC::RateCalculator rate(500, 8000, 500);
+
+		// 1000 bytes per millisecond until the window has filled, which must not make
+		// the estimation error grow as the measured period is extended.
+		int64_t prevError{ 8000000 };
+		std::optional<int64_t> bitrate;
+
+		for (int64_t i{ 1 }; i < 10000; ++i)
+		{
+			rate.Update(1000, nowMs + i);
+
+			bitrate = rate.GetRate(nowMs + i);
+
+			if (bitrate.has_value())
+			{
+				const int64_t error = std::abs(8000000 - bitrate.value());
+
+				REQUIRE(error <= prevError + 1);
+
+				prevError = error;
+			}
+		}
+
+		REQUIRE(bitrate == 8000000);
+
+		// Silence over the window size, read during the silence.
+		REQUIRE(rate.GetRate(nowMs + 10500) == std::nullopt);
+
+		// So the samples that come next are measured over their own period, which is
+		// the 2ms they span, leaving out the one that starts it: 1000 * 8000 / 2.
+		rate.Update(1000, nowMs + 10500);
+		rate.Update(1000, nowMs + 10501);
+
+		REQUIRE(rate.GetRate(nowMs + 10501) == 4000000);
+
+		// A manual reset does the same.
+		rate.Reset();
+
+		REQUIRE(rate.GetRate(nowMs + 10501) == std::nullopt);
+
+		rate.Update(1000, nowMs + 10501);
+		rate.Update(1000, nowMs + 10502);
+
+		REQUIRE(rate.GetRate(nowMs + 10502) == 4000000);
+	}
+
+	// NOTE: This pins that data given with an instant that precedes the whole
+	// window is not lost. It is taken as if it had been given at the instant the
+	// newest item starts at, so it counts towards both the rate and the total.
+	SECTION("a sample older than the whole window still counts")
+	{
+		// window: 1000ms, items: 1000 (granularity: 1ms)
+		RTC::RateCalculator rate(1000, 8000, 1000);
+
+		rate.Update(1000, nowMs);
+		rate.Update(1000, nowMs + 500);
+
+		// 1000 * 8000 / 501, without the sample that starts the period.
+		REQUIRE(rate.GetRate(nowMs + 500) == 15968);
+		REQUIRE(rate.GetBytes() == 2000);
+
+		// Five seconds before the window, which spans one.
+		rate.Update(1000, nowMs - 5000);
+
+		REQUIRE(rate.GetBytes() == 3000);
+		// 2000 * 8000 / 501.
+		REQUIRE(rate.GetRate(nowMs + 500) == 31936);
+	}
+
+	// NOTE: This is what the margin exists for: the samples come a whole window
+	// apart, so without it each of them would find the window empty, restart the
+	// measured period and never be measured at all.
+	SECTION("a stream sending as often as the window is still measured")
+	{
+		// window: 1000ms, items: 1000 (granularity: 1ms), counting frames
+		RTC::RateCalculator rate(1000, 1000, 1000);
+
+		REQUIRE(rate.GetRate(nowMs) == std::nullopt);
+
+		// One frame per second for ten seconds.
+		for (int64_t i{ 0 }; i < 10000; i += 1000)
+		{
+			rate.Update(1, nowMs + i);
+
+			if (i > 0)
+			{
+				REQUIRE(rate.GetRate(nowMs + i) == 1);
+			}
+		}
+	}
+
+	// NOTE: The overflow is provoked through the scale rather than through the size
+	// of the samples, since Update() takes a size_t and on a 32 bit build no amount
+	// of samples of that size makes the result overflow.
+	SECTION("a rate that does not fit is no rate at all")
+	{
+		// window: 1000ms, items: 1000 (granularity: 1ms)
+		RTC::RateCalculator rate(1000, 1e30F, 1000);
+
+		rate.Update(1000, nowMs);
+		rate.Update(1000, nowMs + 1);
+
+		REQUIRE(rate.GetRate(nowMs + 1) == std::nullopt);
+	}
+
 	SECTION("receive single item per 1000 ms")
 	{
 		RTC::RateCalculator rate;
@@ -47,7 +274,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0, .size=5, .rate=40 }
+			{ .offset=0, .size=5, .rate=std::nullopt }
 		};
 		// clang-format on
 
@@ -61,10 +288,15 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0,   .size=5, .rate=40  },
-			{ .offset=100, .size=2, .rate=56  },
-			{ .offset=300, .size=2, .rate=72  },
-			{ .offset=999, .size=4, .rate=104 }
+			// A lone sample with the window unfilled.
+			{ .offset=0,   .size=5, .rate=std::nullopt },
+			// 2 * 8000 / 101, the first sample being the one that starts the period.
+			{ .offset=100, .size=2, .rate=158          },
+			// (2 + 2) * 8000 / 301.
+			{ .offset=300, .size=2, .rate=106          },
+			// The period is the whole window now, so every sample counts:
+			// (5 + 2 + 2 + 4) * 8000 / 1000.
+			{ .offset=999, .size=4, .rate=104          }
 		};
 		// clang-format on
 
@@ -75,12 +307,15 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	{
 		RTC::RateCalculator rate(1000, 8000, 100);
 
+		// Each sample expires the previous one, but they come close enough together
+		// for the measured period to be kept, so each of them is measured over the
+		// window instead of over the instant it was taken in.
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0,    .size=5, .rate=40 },
-			{ .offset=1000, .size=5, .rate=40 },
-			{ .offset=2000, .size=5, .rate=40 }
+			{ .offset=0,    .size=5, .rate=std::nullopt },
+			{ .offset=1000, .size=5, .rate=40           },
+			{ .offset=2000, .size=5, .rate=40           }
 		};
 		// clang-format on
 
@@ -91,20 +326,22 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	{
 		RTC::RateCalculator rate(1000, 8000, 1000);
 
+		// From the second sample on the period is already the whole window, so every
+		// rate below is the bytes left within it times 8.
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0,    .size=5, .rate=40 },
-			{ .offset=999,  .size=2, .rate=56 },
-			{ .offset=1001, .size=1, .rate=24 },
-			{ .offset=1001, .size=1, .rate=32 },
-			{ .offset=2000, .size=1, .rate=24 }
+			{ .offset=0,    .size=5, .rate=std::nullopt },
+			{ .offset=999,  .size=2, .rate=56           },
+			{ .offset=1001, .size=1, .rate=24           },
+			{ .offset=1001, .size=1, .rate=32           },
+			{ .offset=2000, .size=1, .rate=24           }
 		};
 		// clang-format on
 
 		validate(rate, nowMs, input);
 
-		REQUIRE(rate.GetRate(nowMs + 3001) == 0);
+		REQUIRE(rate.GetRate(nowMs + 3001) == std::nullopt);
 	}
 
 	SECTION("slide with 100 items")
@@ -114,19 +351,21 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0,    .size=5, .rate=40 },
-			{ .offset=999,  .size=2, .rate=56 },
-			{ .offset=1001, .size=1, .rate=24 }, // merged inside 999
-			{ .offset=1001, .size=1, .rate=32 }, // merged inside 999
-			{ .offset=2000, .size=1, .rate=8  }  // it will erase the item with
-			                // timestamp=999, removing also the next two samples. The
-			                // end estimation will include only the last sample.
+			{ .offset=0,    .size=5, .rate=std::nullopt },
+			{ .offset=999,  .size=2, .rate=56           },
+			{ .offset=1001, .size=1, .rate=24           }, // merged inside 999
+			{ .offset=1001, .size=1, .rate=32           }, // merged inside 999
+			{ .offset=2000, .size=1, .rate=8            }  // it will erase the item
+			                // with timestamp=999, removing also the next two samples.
+			                // Only the last sample is left, and it comes close enough
+			                // to the previous one to keep being measured over the
+			                // window.
 		};
 		// clang-format on
 
 		validate(rate, nowMs, input);
 
-		REQUIRE(rate.GetRate(nowMs + 3001) == 0);
+		REQUIRE(rate.GetRate(nowMs + 3001) == std::nullopt);
 	}
 
 	SECTION("wrap")
@@ -134,19 +373,22 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// window: 1000ms, items: 5 (granularity: 200ms)
 		RTC::RateCalculator rate(1000, 8000, 5);
 
+		// A byte every 200ms is 40 bps, and that is what comes out from the second
+		// sample on: leaving out the one that starts the period is what makes the
+		// samples and the gaps between them match while the window fills.
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=1000, .size=1, .rate=1*8 },
-			{ .offset=1200, .size=1, .rate=(1*8) + (1*8) },
-			{ .offset=1400, .size=1, .rate=(1*8) + (2*8) },
-			{ .offset=1600, .size=1, .rate=(1*8) + (3*8) },
-			{ .offset=1800, .size=1, .rate=(1*8) + (4*8) },
-			{ .offset=2000, .size=1, .rate=(1*8) + ((5-1)*8) }, // starts wrap here
-			{ .offset=2200, .size=1, .rate=(1*8) + ((6-2)*8) },
-			{ .offset=2400, .size=1, .rate=(1*8) + ((7-3)*8) },
-			{ .offset=2600, .size=1, .rate=(1*8) + ((8-4)*8) },
-			{ .offset=2800, .size=1, .rate=(1*8) + ((9-5)*8) },
+			{ .offset=1000, .size=1, .rate=std::nullopt         },
+			{ .offset=1200, .size=1, .rate=40                   },
+			{ .offset=1400, .size=1, .rate=40                   },
+			{ .offset=1600, .size=1, .rate=40                   },
+			{ .offset=1800, .size=1, .rate=40                   },
+			{ .offset=2000, .size=1, .rate=(1*8) + ((5-1)*8)    }, // starts wrap here
+			{ .offset=2200, .size=1, .rate=(1*8) + ((6-2)*8)    },
+			{ .offset=2400, .size=1, .rate=(1*8) + ((7-3)*8)    },
+			{ .offset=2600, .size=1, .rate=(1*8) + ((8-4)*8)    },
+			{ .offset=2800, .size=1, .rate=(1*8) + ((9-5)*8)    },
 		};
 		// clang-format on
 
@@ -163,10 +405,13 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// clang-format off
 		const std::vector<TestRateCalculatorData> input =
 		{
-			{ .offset=0,   .size=1, .rate=8  },
-			{ .offset=333, .size=1, .rate=16 },
-			{ .offset=666, .size=1, .rate=24 },
-			{ .offset=999, .size=1, .rate=32 },
+			{ .offset=0,   .size=1, .rate=std::nullopt },
+			// 1 * 8000 / 334, without the sample that starts the period.
+			{ .offset=333, .size=1, .rate=24           },
+			// 2 * 8000 / 667.
+			{ .offset=666, .size=1, .rate=24           },
+			// The period is the whole window now: 4 * 8000 / 1000.
+			{ .offset=999, .size=1, .rate=32           },
   	};
 		// clang-format on
 
@@ -194,27 +439,33 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		REQUIRE(rate.GetRate(nowMs + 1100) == 91 * 8);
 	}
 
-	// NOTE: This pins the GetRate() memoization key, which is both nowMs and the
-	// total count. Keying it on nowMs alone would return a stale rate.
+	// NOTE: This pins the GetRate() memoization key, which is the time plus both
+	// totals. Keying it on the time alone would return a stale rate.
 	SECTION("rate is recalculated after Update() with the same now")
 	{
 		RTC::RateCalculator rate(1000, 8000, 100);
 
+		// Two samples apart in time, so that there is a period to measure over and
+		// the reads below are not rejected for lack of one.
 		rate.Update(5, nowMs);
+		rate.Update(5, nowMs + 500);
 
-		REQUIRE(rate.GetRate(nowMs) == 40);
+		// 5 * 8000 / 501, without the sample that starts the period.
+		REQUIRE(rate.GetRate(nowMs + 500) == 80);
 
-		rate.Update(5, nowMs);
+		rate.Update(5, nowMs + 500);
 
-		REQUIRE(rate.GetRate(nowMs) == 80);
+		// 10 * 8000 / 501.
+		REQUIRE(rate.GetRate(nowMs + 500) == 160);
 
-		rate.Update(5, nowMs);
+		rate.Update(5, nowMs + 500);
 
-		REQUIRE(rate.GetRate(nowMs) == 120);
+		// 15 * 8000 / 501.
+		REQUIRE(rate.GetRate(nowMs + 500) == 240);
 
 		// Repeated reads with no Update() in between must be stable.
-		REQUIRE(rate.GetRate(nowMs) == 120);
-		REQUIRE(rate.GetRate(nowMs) == 120);
+		REQUIRE(rate.GetRate(nowMs + 500) == 240);
+		REQUIRE(rate.GetRate(nowMs + 500) == 240);
 	}
 
 	// NOTE: This pins the item size rounding for a window size which is not a
@@ -237,24 +488,28 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 
 	// NOTE: This pins that the GetRate() memoization needs no "not calculated yet"
 	// mark. Its zeroed initial state is a valid entry, so a read at time 0 must be
-	// neither a stale hit nor a miss returning something else than 0.
+	// neither a stale hit nor a miss returning something else than no rate at all.
 	SECTION("rate at time 0 on a fresh and on a reset calculator")
 	{
 		RTC::RateCalculator rate(1000, 8000, 100);
 
-		REQUIRE(rate.GetRate(0) == 0);
+		REQUIRE(rate.GetRate(0) == std::nullopt);
 
 		rate.Update(5, 0);
+		rate.Update(5, 500);
 
-		REQUIRE(rate.GetRate(0) == 40);
+		// 5 * 8000 / 501, without the sample that starts the period.
+		REQUIRE(rate.GetRate(500) == 80);
 
 		rate.Reset();
 
-		REQUIRE(rate.GetRate(0) == 0);
+		REQUIRE(rate.GetRate(0) == std::nullopt);
 
 		rate.Update(5, 0);
+		rate.Update(5, 500);
 
-		REQUIRE(rate.GetRate(0) == 40);
+		// The same as before the reset.
+		REQUIRE(rate.GetRate(500) == 80);
 	}
 
 	// NOTE: This pins the constructor clamping. A zero number of items used to
@@ -269,9 +524,16 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		oneItem.Update(5, nowMs);
 		noWindow.Update(5, nowMs);
 
-		REQUIRE(noItems.GetRate(nowMs) == 40);
-		REQUIRE(oneItem.GetRate(nowMs) == 40);
-		// The window size is clamped to 1ms.
-		REQUIRE(noWindow.GetRate(nowMs) == 40000);
+		noItems.Update(5, nowMs + 500);
+		oneItem.Update(5, nowMs + 500);
+		noWindow.Update(5, nowMs + 500);
+
+		// Two samples 500ms apart, of which the one that starts the period is left
+		// out: 5 * 8000 / 501.
+		REQUIRE(noItems.GetRate(nowMs + 500) == 80);
+		REQUIRE(oneItem.GetRate(nowMs + 500) == 80);
+		// The window size is clamped to 1ms, which leaves every sample alone in a
+		// period of a single millisecond, so such a window can never measure a rate.
+		REQUIRE(noWindow.GetRate(nowMs + 500) == std::nullopt);
 	}
 }

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

@@ -2,6 +2,9 @@
 #include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RemoteCaptureTimeEstimator.hpp"
+#include "RTC/RtpDictionaries.hpp"
+#include "Utils.hpp"
+#include "test/include/RTC/RTP/rtpCommon.hpp"
 #include "mocks/include/MockShared.hpp"
 #include <catch2/catch_test_macros.hpp>
 
@@ -81,10 +84,49 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		estimator.SenderReportReceived(std::addressof(rtpStream));
 	};
 
+	// Makes a packet carrying the 'abs-capture-time' extension reach the stream, which
+	// is what tells a sender that does send it from one that only announced it.
+	auto receiveAbsCaptureTimePacket = [&nowUs, &rtpStream]() -> void
+	{
+		// Id the extension is given, which only has to match between what is written
+		// and what is read back.
+		constexpr uint8_t AbsCaptureTimeId{ 1 };
+
+		std::unique_ptr<RTC::RTP::Packet> packet(
+		  RTC::RTP::Packet::Factory(rtpCommon::FactoryBuffer, sizeof(rtpCommon::FactoryBuffer)));
+
+		REQUIRE(packet);
+
+		packet->SetSsrc(Ssrc);
+		packet->SetTimestamp(RemoteBaseTs);
+
+		const std::vector<RTC::RTP::Packet::Extension> extensions{
+			{ RTC::RtpHeaderExtensionUri::Type::ABS_CAPTURE_TIME,
+			 AbsCaptureTimeId, /*len*/ 8,
+			 rtpCommon::DataBuffer }
+		};
+
+		packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::OneByte, extensions);
+
+		RTC::RTP::HeaderExtensionIds headerExtensionIds;
+
+		headerExtensionIds.absCaptureTime = AbsCaptureTimeId;
+
+		packet->AssignExtensionIds(headerExtensionIds);
+
+		const auto ntp = Utils::Time::TimeUsToNtp(static_cast<int64_t>(RemoteBaseNtpSec) * 1000000);
+
+		REQUIRE(packet->UpdateAbsCaptureTime(
+		  (static_cast<uint64_t>(ntp.seconds) << 32) | static_cast<uint64_t>(ntp.fractions)));
+
+		rtpStream.ReceivePacket(packet.get(), nowUs);
+	};
+
 	SECTION("no source until the first Producer has been taken into account")
 	{
 		REQUIRE_FALSE(estimator.GetSource().has_value());
-		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
 	}
 
 	SECTION("the first Producer chooses abs-capture-time when it negotiated it")
@@ -118,6 +160,50 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
 	}
 
+	SECTION("abs-capture-time negotiated but never received moves the source to Sender Report")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+
+		// The first packet is what the wait is measured against, so nothing happens on
+		// it however long this sender has been around.
+		nowUs += 60 * 1000000;
+
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME);
+
+		// Still within the wait, since the extension travels on some packets rather
+		// than on every one and may simply not have arrived yet.
+		nowUs += 4 * 1000000;
+
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME);
+
+		// Long enough without a single packet carrying it.
+		nowUs += 1 * 1000000;
+
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
+	}
+
+	SECTION("abs-capture-time received keeps the source whatever the sender does later")
+	{
+		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ true);
+
+		receiveAbsCaptureTimePacket();
+
+		REQUIRE(rtpStream.HasAbsCaptureTime());
+
+		// Way past the wait, which is not armed at all once the extension has been seen.
+		nowUs += 60 * 1000000;
+
+		estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs);
+
+		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME);
+	}
+
 	SECTION("the capture instant is translated into our clock")
 	{
 		estimator.UpdateSource(/*absCaptureTimeNegotiated*/ false);
@@ -125,7 +211,8 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		// A single Sender Report is not enough for the clock offset to be estimated.
 		receiveSenderReport(0);
 
-		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
 
 		for (uint32_t idx{ 1 }; idx < RTC::RemoteClockOffsetEstimator::MinSampleCount; ++idx)
 		{
@@ -137,19 +224,19 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		const auto lastIdx = RTC::RemoteClockOffsetEstimator::MinSampleCount - 1;
 		const auto lastTs  = static_cast<uint32_t>(RemoteBaseTs + (lastIdx * ClockRate));
 
-		REQUIRE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs).has_value());
+		REQUIRE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs, nowUs).has_value());
 		REQUIRE(
 		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs).value() ==
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs, nowUs).value() ==
 		  LocalBaseUs + (lastIdx * 1000000));
 
 		// 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.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs).has_value());
+		REQUIRE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs, nowUs).has_value());
 		REQUIRE(
 		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs).value() ==
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs, nowUs).value() ==
 		  LocalBaseUs + ((lastIdx + 1) * 1000000));
 	}
 
@@ -164,6 +251,7 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 		// Sender Reports have been received, but the source in use is not allowed to
 		// fall back to them.
-		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
 	}
 }