mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/RTP/RtpStreamSend.cpp

@@ -3,6 +3,8 @@
 
 #include "RTC/RTP/RtpStreamSend.hpp"
 #include "Logger.hpp"
+#include "RTC/RTCP/FeedbackPsFir.hpp"
+#include "RTC/RTCP/FeedbackPsPli.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include "Utils.hpp"
 #include <vector>
@@ -14,12 +16,12 @@ namespace RTC
 		/* Static. */
 
 		// Limit max number of items in the retransmission buffer.
-		static constexpr size_t RetransmissionBufferMaxItems{ 2500u };
+		static constexpr size_t RetransmissionBufferMaxItems{ 2500 };
 		// 17: 16 bit mask + the initial sequence number.
-		static constexpr size_t MaxRequestedPackets{ 17u };
+		static constexpr size_t MaxRequestedPackets{ 17 };
 		static thread_local std::vector<RTP::RetransmissionBuffer::Item*> RetransmissionContainer(
 		  MaxRequestedPackets + 1);
-		static constexpr uint32_t DefaultRtt{ 100u };
+		static constexpr int64_t DefaultRttMs{ 100 };
 
 		/* Instance methods. */
 
@@ -36,7 +38,7 @@ namespace RTC
 
 			if (this->params.useNack)
 			{
-				uint32_t maxRetransmissionDelayMs{ 0 };
+				int64_t maxRetransmissionDelayMs{ 0 };
 
 				switch (params.mimeType.type)
 				{
@@ -74,7 +76,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const uint64_t nowMs = this->shared->GetTimeMs();
+			const int64_t nowMs = this->shared->GetTimeMs();
 
 			auto baseStats = RTP::RtpStream::FillBufferStats(builder);
 			auto stats     = FBS::RtpStream::CreateSendStats(
@@ -82,7 +84,7 @@ namespace RTC
 			  baseStats,
 			  this->transmissionCounter.GetPacketCount(),
 			  this->transmissionCounter.GetBytes(),
-			  this->transmissionCounter.GetBitrate(nowMs));
+			  static_cast<uint64_t>(this->transmissionCounter.GetBitrate(nowMs)));
 
 			return FBS::RtpStream::CreateStats(builder, FBS::RtpStream::StatsData::SendStats, stats.Union());
 		}
@@ -270,17 +272,17 @@ namespace RTC
 			}
 		}
 
-		void RtpStreamSend::ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report)
+		void RtpStreamSend::ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs)
 		{
 			MS_TRACE();
 
 			/* Calculate RTT. */
 
-			// Get the NTP representation of the current timestamp.
-			const uint64_t nowMs = this->shared->GetTimeMs();
-			auto ntp             = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
+			// Get the NTP representation of the time at which the Receiver Report
+			// arrived, which is what the round trip is measured against.
+			auto ntp = Utils::Time::TimeUs2Ntp(receivedAtUs + this->shared->GetNtpOffsetUs());
 
-			// Get the compact NTP representation of the current timestamp.
+			// Get the compact NTP representation of the arrival time.
 			uint32_t compactNtp = (ntp.seconds & 0x0000FFFF) << 16;
 
 			compactNtp |= (ntp.fractions & 0xFFFF0000) >> 16;
@@ -289,21 +291,20 @@ namespace RTC
 			const uint32_t dlsr   = report->GetDelaySinceLastSenderReport();
 
 			// RTT in 1/2^16 second fractions.
-			uint32_t rtt{ 0 };
+			uint32_t rttCompactNtp{ 0 };
 
 			// If no Sender Report was received by the remote endpoint yet, ignore lastSr
 			// and dlsr values in the Receiver Report.
 			if (lastSr && dlsr && (compactNtp > dlsr + lastSr))
 			{
-				rtt = compactNtp - dlsr - lastSr;
+				rttCompactNtp = compactNtp - dlsr - lastSr;
 			}
 
-			// RTT in milliseconds.
-			this->rtt = static_cast<float>(rtt >> 16) * 1000;
-			this->rtt += (static_cast<float>(rtt & 0x0000FFFF) / 65536) * 1000;
+			this->rttMs = static_cast<float>(rttCompactNtp >> 16) * 1000;
+			this->rttMs += (static_cast<float>(rttCompactNtp & 0x0000FFFF) / 65536) * 1000;
 
 			// Avoid negative RTT value since it doesn't make sense.
-			this->rtt = std::max(this->rtt, 0.0f);
+			this->rttMs = std::max(this->rttMs, 0.0f);
 
 			this->packetsLost  = report->GetTotalLost();
 			this->fractionLost = report->GetFractionLost();
@@ -313,7 +314,8 @@ namespace RTC
 			UpdateScore(report);
 		}
 
-		void RtpStreamSend::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+		void RtpStreamSend::ReceiveRtcpXrReceiverReferenceTime(
+		  RTC::RTCP::ReceiverReferenceTime* report, int64_t receivedAtUs)
 		{
 			MS_TRACE();
 
@@ -322,12 +324,12 @@ namespace RTC
 			compactNtp += report->GetNtpFrac() >> 16;
 
 			this->lastReceiverReferenceTime = ReceiverReferenceTime{
-				.compactNtp = compactNtp,
-				.receivedMs = this->shared->GetTimeMs(),
+				.compactNtp   = compactNtp,
+				.receivedAtUs = receivedAtUs,
 			};
 		}
 
-		RTC::RTCP::SenderReport* RtpStreamSend::GetRtcpSenderReport(uint64_t nowMs)
+		RTC::RTCP::SenderReport* RtpStreamSend::GetRtcpSenderReport(int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -338,22 +340,22 @@ namespace RTC
 
 			// A stream that stopped sending cannot tell where its RTP timeline is now, and
 			// extrapolating would claim RTP timestamps of packets never sent.
-			if (nowMs - this->maxPacketMs > RtpStreamSend::MaxSenderReportReferenceAgeMs)
+			if ((nowUs - this->maxPacketAtUs) / 1000 > RtpStreamSend::MaxSenderReportReferenceAgeMs)
 			{
 				return nullptr;
 			}
 
-			auto ntp     = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
+			auto ntp     = Utils::Time::TimeUs2Ntp(nowUs + this->shared->GetNtpOffsetUs());
 			auto* report = new RTC::RTCP::SenderReport();
 
 			// Calculate TS difference between now and the instant at which the media in the
 			// packet holding the highest RTP timestamp was captured, falling back to the
 			// instant that packet was seen while the capture instant cannot be told.
-			const uint64_t referenceMs = this->maxPacketCaptureMs.value_or(this->maxPacketMs);
+			const int64_t referenceUs = this->maxPacketCaptureAtUs.value_or(this->maxPacketAtUs);
 			// NOTE: The capture instant is an estimation, so it may land ahead of now.
-			const uint64_t diffMs = nowMs > referenceMs ? nowMs - referenceMs : 0;
-			const uint64_t diffTs = diffMs * GetClockRate() / 1000;
-			const auto rtpTs      = static_cast<uint32_t>(this->maxPacketTs + diffTs);
+			const int64_t diffUs = nowUs > referenceUs ? nowUs - referenceUs : 0;
+			const int64_t diffTs = (diffUs * GetClockRate()) / 1000000;
+			const auto rtpTs     = static_cast<uint32_t>(this->maxPacketTs + diffTs);
 
 			report->SetSsrc(GetSsrc());
 			report->SetPacketCount(this->transmissionCounter.GetPacketCount());
@@ -363,15 +365,18 @@ namespace RTC
 			report->SetRtpTs(rtpTs);
 
 			// Update info about last Sender Report.
+			//
+			// NOTE: It is the very instant announced in the report above, so that the
+			// mapping means the same thing here and in a receive stream.
 			this->lastSenderReportMapping = RTP::RtpStream::SenderReportMapping{
-				.ntpMs = nowMs,
+				.ntpUs = nowUs + this->shared->GetNtpOffsetUs(),
 				.ts    = rtpTs,
 			};
 
 			return report;
 		}
 
-		RTC::RTCP::DelaySinceLastRr::SsrcInfo* RtpStreamSend::GetRtcpXrDelaySinceLastRrSsrcInfo(uint64_t nowMs)
+		RTC::RTCP::DelaySinceLastRr::SsrcInfo* RtpStreamSend::GetRtcpXrDelaySinceLastRrSsrcInfo(int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -381,12 +386,12 @@ namespace RTC
 			}
 
 			const auto& receiverReferenceTime = this->lastReceiverReferenceTime.value();
-			// Get delay in milliseconds.
-			auto delayMs = static_cast<uint32_t>(nowMs - receiverReferenceTime.receivedMs);
+			// Get delay in microseconds.
+			const int64_t delayUs = nowUs - receiverReferenceTime.receivedAtUs;
 			// Express delay in units of 1/65536 seconds.
-			uint32_t dlrr = (delayMs / 1000) << 16;
+			auto dlrr = static_cast<uint32_t>((delayUs / 1000000) << 16);
 
-			dlrr |= uint32_t{ (delayMs % 1000) * 65536 / 1000 };
+			dlrr |= static_cast<uint32_t>(((delayUs % 1000000) * 65536) / 1000000);
 
 			auto* ssrcInfo = new RTC::RTCP::DelaySinceLastRr::SsrcInfo();
 
@@ -430,23 +435,23 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		uint32_t RtpStreamSend::GetBitrate(
-		  uint64_t /*nowMs*/, uint8_t /*spatialLayer*/, uint8_t /*temporalLayer*/)
+		int64_t RtpStreamSend::GetBitrate(
+		  int64_t /*nowMs*/, uint8_t /*spatialLayer*/, uint8_t /*temporalLayer*/)
 		{
 			MS_TRACE();
 
 			MS_ABORT("invalid method call");
 		}
 
-		uint32_t RtpStreamSend::GetSpatialLayerBitrate(uint64_t /*nowMs*/, uint8_t /*spatialLayer*/)
+		int64_t RtpStreamSend::GetSpatialLayerBitrate(int64_t /*nowMs*/, uint8_t /*spatialLayer*/)
 		{
 			MS_TRACE();
 
 			MS_ABORT("invalid method call");
 		}
 
-		uint32_t RtpStreamSend::GetLayerBitrate(
-		  uint64_t /*nowMs*/, uint8_t /*spatialLayer*/, uint8_t /*temporalLayer*/)
+		int64_t RtpStreamSend::GetLayerBitrate(
+		  int64_t /*nowMs*/, uint8_t /*spatialLayer*/, uint8_t /*temporalLayer*/)
 		{
 			MS_TRACE();
 
@@ -480,9 +485,9 @@ namespace RTC
 			}
 
 			// Look for each requested packet.
-			const uint64_t nowMs = this->shared->GetTimeMs();
-			const uint16_t rtt   = (this->rtt > 0.0f ? this->rtt : DefaultRtt);
-			uint16_t currentSeq  = seq;
+			const int64_t nowMs = this->shared->GetTimeMs();
+			const int64_t rttMs = (this->rttMs > 0.0f ? this->rttMs : DefaultRttMs);
+			uint16_t currentSeq = seq;
 			bool requested{ true };
 			size_t containerIdx{ 0 };
 
@@ -507,14 +512,14 @@ namespace RTC
 						// Do nothing.
 					}
 					// Don't resent the packet if it was resent in the last RTT ms.
-					else if (item->resentAtMs != 0u && nowMs - item->resentAtMs <= static_cast<uint64_t>(rtt))
+					else if (item->resentAtMs != 0 && nowMs - item->resentAtMs <= rttMs)
 					{
 						MS_DEBUG_TAG(
 						  rtx,
 						  "ignoring retransmission for a packet already resent in the last RTT ms "
-						  "[seq:%" PRIu16 ", rtt:%" PRIu16 "]",
+						  "[seq:%" PRIu16 ", rtt:%" PRIi64 " ms]",
 						  item->sequenceNumber,
-						  rtt);
+						  rttMs);
 					}
 					// Stored packet is valid for retransmission. Resend it.
 					else

package/worker/src/RTC/RTP/RtxStream.cpp

@@ -57,7 +57,6 @@ namespace RTC
 				this->started     = true;
 				this->maxSeq      = seq - 1;
 				this->maxPacketTs = packet->GetTimestamp();
-				this->maxPacketMs = this->shared->GetTimeMs();
 			}
 
 			// If not a valid packet ignore it.
@@ -76,7 +75,6 @@ namespace RTC
 			if (Utils::Number::IsHigherThan<uint32_t>(packet->GetTimestamp(), this->maxPacketTs))
 			{
 				this->maxPacketTs = packet->GetTimestamp();
-				this->maxPacketMs = this->shared->GetTimeMs();
 			}
 
 			// Increase packet count.
@@ -141,12 +139,12 @@ namespace RTC
 			if (this->lastSenderReportTiming.has_value())
 			{
 				const auto& senderReportTiming = this->lastSenderReportTiming.value();
-				// Get delay in milliseconds.
-				const uint32_t delayMs = this->shared->GetTimeMs() - senderReportTiming.receivedMs;
+				// Get delay in microseconds.
+				const int64_t delayUs = this->shared->GetTimeUs() - senderReportTiming.receivedAtUs;
 				// Express delay in units of 1/65536 seconds.
-				uint32_t dlsr = (delayMs / 1000) << 16;
+				auto dlsr = static_cast<uint32_t>((delayUs / 1000000) << 16);
 
-				dlsr |= uint32_t{ (delayMs % 1000) * 65536 / 1000 };
+				dlsr |= static_cast<uint32_t>(((delayUs % 1000000) * 65536) / 1000000);
 
 				report->SetDelaySinceLastSenderReport(dlsr);
 				report->SetLastSenderReport(senderReportTiming.compactNtp);
@@ -160,7 +158,7 @@ namespace RTC
 			return report;
 		}
 
-		void RtxStream::ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report)
+		void RtxStream::ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs)
 		{
 			MS_TRACE();
 
@@ -169,8 +167,8 @@ namespace RTC
 			compactNtp += report->GetNtpFrac() >> 16;
 
 			this->lastSenderReportTiming = SenderReportTiming{
-				.compactNtp = compactNtp,
-				.receivedMs = this->shared->GetTimeMs(),
+				.compactNtp   = compactNtp,
+				.receivedAtUs = receivedAtUs,
 			};
 		}
 
@@ -215,7 +213,6 @@ namespace RTC
 					InitSeq(seq);
 
 					this->maxPacketTs = packet->GetTimestamp();
-					this->maxPacketMs = this->shared->GetTimeMs();
 				}
 				else
 				{

package/worker/src/RTC/RateCalculator.cpp

@@ -3,129 +3,76 @@
 
 #include "RTC/RateCalculator.hpp"
 #include "Logger.hpp"
-#include "Utils.hpp"
-#include <cmath>   // std::trunc()
-#include <cstring> // std::memset()
+#include <cmath>  // std::trunc()
+#include <limits> // std::numeric_limits()
 
 namespace RTC
 {
-	RateCalculator::RateCalculator(size_t windowSizeMs, float scale, uint16_t windowItems)
-	  : windowSizeMs(windowSizeMs),
-	    scale(scale),
-	    windowItems(windowItems),
-	    itemSizeMs(std::max(windowSizeMs / windowItems, size_t{ 1 }))
+	RateCalculator::RateCalculator(int64_t windowSizeMs, float scale, uint16_t windowItems)
 	{
 		MS_TRACE();
 
-		this->buffer.resize(windowItems);
+		// Clamp the given values so every derived value is safe to use.
+		this->windowSizeMs = std::max<int64_t>(windowSizeMs, 1);
 
-		std::memset(
-		  static_cast<void*>(std::addressof(this->buffer.front())),
-		  0,
-		  sizeof(BufferItem) * this->buffer.size());
+		const int64_t items = std::max<int64_t>(windowItems, 1);
+
+		// Item granularity, rounded up so that `items` items always suffice to cover
+		// the window.
+		this->itemSizeMs = (this->windowSizeMs + items - 1) / items;
+
+		// Number of items needed to cover the whole window, rounded up. It is never
+		// higher than `items`, and it guarantees that in-window data can never
+		// overrun the ring. The window it spans overshoots windowSizeMs by less than
+		// one item, which is inherent to splitting the window into items.
+		this->buffer.resize(
+		  static_cast<size_t>((this->windowSizeMs + this->itemSizeMs - 1) / this->itemSizeMs));
+
+		this->rateScale = static_cast<double>(scale) / static_cast<double>(this->windowSizeMs);
 	}
 
-	void RateCalculator::Update(size_t size, uint64_t nowMs)
+	void RateCalculator::Update(size_t size, int64_t nowMs)
 	{
 		MS_TRACE();
 
-		// Ignore too old data. Should never happen.
-		if (this->oldestItemStartTimeMs.has_value() && Utils::Number::IsLowerThan<uint64_t>(nowMs, *this->oldestItemStartTimeMs))
+		// Ignore data older than the window. Should never happen.
+		if (!SlideWindow(nowMs))
 		{
-			MS_WARN_DEV("nowMs < this->oldestItemStartTimeMs, should never happen");
+			MS_WARN_DEV("given nowMs is older than the current window, ignoring data");
 
 			return;
 		}
 
-		// Increase bytes.
-		this->bytes += size;
-
-		RemoveOldData(nowMs);
-
-		// If the elapsed time from the newest item start time is greater than the
-		// item size (in milliseconds), increase the item index.
-		if (
-		  this->newestItemIndex < 0 || !this->newestItemStartTimeMs.has_value() ||
-		  Utils::Number::IsHigherOrEqualThan<uint64_t>(
-		    nowMs - *this->newestItemStartTimeMs, this->itemSizeMs))
-		{
-			this->newestItemIndex++;
-			this->newestItemStartTimeMs = nowMs;
-
-			if (this->newestItemIndex >= this->windowItems)
-			{
-				MS_DEBUG_DEV("this->newestItemIndex >= this->windowItems, setting this->newestItemIndex = 0");
-
-				this->newestItemIndex = 0;
-			}
-
-			// Advance oldestItemIndex if buffer is full.
-			// NOTE: This avoids a crash:
-			//   https://github.com/versatica/mediasoup/issues/1316
-			if (this->newestItemIndex == this->oldestItemIndex && this->oldestItemIndex != -1)
-			{
-				if (++this->oldestItemIndex >= this->windowItems)
-				{
-					this->oldestItemIndex = 0;
-				}
-			}
-
-			MS_ASSERT(
-			  this->newestItemIndex != this->oldestItemIndex || this->oldestItemIndex == -1,
-			  "newest index overlaps with the oldest one [newestItemIndex:%" PRIi32
-			  ", oldestItemIndex:%" PRIi32 "]",
-			  this->newestItemIndex,
-			  this->oldestItemIndex);
-
-			// Set the newest item.
-			BufferItem& item = this->buffer[this->newestItemIndex];
-
-			item.count  = size;
-			item.timeMs = nowMs;
-		}
-		else
-		{
-			// Update the newest item.
-			BufferItem& item = this->buffer[this->newestItemIndex];
-
-			item.count += size;
-		}
-
-		// Set the oldest item index and time, if not set.
-		if (this->oldestItemIndex < 0)
-		{
-			MS_DEBUG_DEV(
-			  "this->oldestItemIndex < 0, setting this->oldestItemIndex and this->oldestItemStartTimeMs");
-
-			this->oldestItemIndex       = this->newestItemIndex;
-			this->oldestItemStartTimeMs = nowMs;
-		}
-
+		this->buffer[this->newestItemIndex] += size;
 		this->totalCount += size;
-
-		// Reset `lastRate` and `lastTimeMs` so `GetRate()` will calculate rate
-		// again even if called with same now in the same loop iteration.
-		this->lastRate   = 0;
-		this->lastTimeMs = std::nullopt;
+		this->bytes += size;
 	}
 
-	uint32_t RateCalculator::GetRate(uint64_t nowMs)
+	int64_t RateCalculator::GetRate(int64_t nowMs)
 	{
 		MS_TRACE();
 
-		if (this->lastTimeMs.has_value() && nowMs == *this->lastTimeMs)
+		// If both keys match, the memoized rate is still exact. `lastRate` is a pure
+		// function of `totalCount`, so the value is right, and no expiration can be
+		// pending: SlideWindow() already ran for this very `nowMs` and
+		// `newestItemStartTimeMs` only moves forward afterwards, while the initial and
+		// post Reset() state has an empty ring anyway.
+		if (nowMs == this->lastTimeMs && this->totalCount == this->lastTotalCount)
 		{
-			MS_DEBUG_DEV("nowMs == this->lastTimeMs, early return");
+			MS_DEBUG_DEV("nothing changed since the latest call, early return");
 
 			return this->lastRate;
 		}
 
-		RemoveOldData(nowMs);
+		SlideWindow(nowMs);
 
-		const float scale = this->scale / this->windowSizeMs;
+		const double rate = std::trunc((static_cast<double>(this->totalCount) * this->rateScale) + 0.5);
 
-		this->lastTimeMs = nowMs;
-		this->lastRate   = static_cast<uint32_t>(std::trunc((this->totalCount * scale) + 0.5f));
+		// NOTE: Must be read after SlideWindow(), which may have expired data.
+		this->lastTotalCount = this->totalCount;
+		this->lastTimeMs     = nowMs;
+		this->lastRate =
+		  static_cast<int64_t>(std::min(rate, static_cast<double>(std::numeric_limits<int64_t>::max())));
 
 		return this->lastRate;
 	}
@@ -134,73 +81,89 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		std::memset(
-		  static_cast<void*>(std::addressof(this->buffer.front())),
-		  0,
-		  sizeof(BufferItem) * this->buffer.size());
-
-		this->newestItemStartTimeMs = std::nullopt;
-		this->newestItemIndex       = -1;
-		this->oldestItemStartTimeMs = std::nullopt;
-		this->oldestItemIndex       = -1;
-		this->totalCount            = 0u;
-		this->lastRate              = 0u;
-		this->lastTimeMs            = std::nullopt;
+		std::ranges::fill(this->buffer, 0);
+
+		this->newestItemIndex       = 0;
+		this->newestItemStartTimeMs = 0;
+		this->totalCount            = 0;
+		this->lastRate              = 0;
+		this->lastTimeMs            = 0;
+		this->lastTotalCount        = 0;
 	}
 
-	void RateCalculator::RemoveOldData(uint64_t nowMs)
+	/**
+	 * Expires the items that no longer belong to the window ending at `nowMs`,
+	 * and makes the item holding `nowMs` the newest one.
+	 *
+	 * Returns false if `nowMs` is so far in the past that it lies outside of the
+	 * window, in which case nothing is modified.
+	 */
+	bool RateCalculator::SlideWindow(int64_t nowMs)
 	{
 		MS_TRACE();
 
-		if (!this->oldestItemStartTimeMs.has_value())
+		// Time elapsed since the newest item started, negative when `nowMs` lies in
+		// the past.
+		const int64_t elapsedMs = nowMs - this->newestItemStartTimeMs;
+
+		// `nowMs` is older than the whole window.
+		if (elapsedMs <= -this->windowSizeMs)
 		{
-			return;
+			return false;
 		}
 
-		// No item set.
-		if (this->newestItemIndex < 0 || this->oldestItemIndex < 0)
+		// `nowMs` belongs to the newest item, or to an already existing one still
+		// within the window, so there is nothing to expire.
+		if (elapsedMs < this->itemSizeMs)
 		{
-			return;
+			return true;
 		}
 
-		const uint64_t newOldestTime = nowMs - this->windowSizeMs;
+		// NOTE: Positive since `elapsedMs` is not lower than `itemSizeMs` here.
+		const int64_t steps = elapsedMs / this->itemSizeMs;
 
-		// Oldest item already removed.
-		if (Utils::Number::IsLowerThan<uint64_t>(newOldestTime, *this->oldestItemStartTimeMs))
+		// A whole window elapsed since the newest item, so every item is gone.
+		if (std::cmp_greater_equal(steps, this->buffer.size()))
 		{
-			return;
-		}
+			MS_DEBUG_DEV("a whole window elapsed, resetting every item");
 
-		// A whole window size time has elapsed since last entry. Reset the buffer.
-		if (
-		  this->newestItemStartTimeMs.has_value() &&
-		  Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->newestItemStartTimeMs))
-		{
-			MS_DEBUG_DEV("newOldestTime >= this->newestItemStartTimeMs, resetting the buffer");
+			// NOTE: totalCount is the sum of every item, so a zero total means that
+			// the ring is already zeroed.
+			if (this->totalCount != 0)
+			{
+				std::ranges::fill(this->buffer, 0);
+
+				this->totalCount = 0;
+			}
 
-			Reset();
+			this->newestItemIndex       = 0;
+			this->newestItemStartTimeMs = nowMs;
 
-			return;
+			return true;
 		}
 
-		while (Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->oldestItemStartTimeMs))
+		// Walk the ring forward. Every item being passed holds the count of exactly
+		// buffer.size() items ago, which is now out of the window.
+		for (int64_t i{ 0 }; i < steps; ++i)
 		{
-			BufferItem& oldestItem = this->buffer[this->oldestItemIndex];
-
-			this->totalCount -= oldestItem.count;
-
-			oldestItem.count  = 0u;
-			oldestItem.timeMs = 0u;
-
-			if (++this->oldestItemIndex >= this->windowItems)
+			if (++this->newestItemIndex == this->buffer.size())
 			{
-				this->oldestItemIndex = 0;
+				this->newestItemIndex = 0;
 			}
 
-			const BufferItem& newOldestItem = this->buffer[this->oldestItemIndex];
+			this->totalCount -= this->buffer[this->newestItemIndex];
 
-			this->oldestItemStartTimeMs = newOldestItem.timeMs;
+			this->buffer[this->newestItemIndex] = 0;
 		}
+
+		// Advance by whole items rather than jumping to `nowMs`. The window is
+		// derived from item geometry (buffer.size() * itemSizeMs) instead of from per
+		// item timestamps, so absorbing the `elapsedMs % itemSizeMs` remainder here
+		// would stretch items past itemSizeMs, making the ring span more time than
+		// windowSizeMs and hence over-report the rate.
+		this->newestItemStartTimeMs += steps * this->itemSizeMs;
+
+		return true;
 	}
 
 	void RtpDataCounter::Update(const RTC::RTP::Packet* packet)

package/worker/src/RTC/RemoteCaptureTimeEstimator.cpp

@@ -31,29 +31,29 @@ namespace RTC
 		  rtcp,
 		  "capture instant source set to %s",
 		  this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME ? "abs-capture-time"
-		                                                                       : "Sender Report");
+			                                                                     : "Sender Report");
 	}
 
 	void RemoteCaptureTimeEstimator::SenderReportReceived(const RTC::RTP::RtpStreamRecv* rtpStream)
 	{
 		MS_TRACE();
 
-		const auto senderReportMapping    = rtpStream->GetSenderReportMapping();
-		const auto senderReportReceivedMs = rtpStream->GetSenderReportReceivedMs();
+		const auto senderReportMapping      = rtpStream->GetSenderReportMapping();
+		const auto senderReportReceivedAtUs = rtpStream->GetSenderReportReceivedAtUs();
 
 		// Both are stored together, so either both are set or none of them is.
-		if (!senderReportMapping.has_value() || !senderReportReceivedMs.has_value())
+		if (!senderReportMapping.has_value() || !senderReportReceivedAtUs.has_value())
 		{
 			return;
 		}
 
 		this->clockOffsetEstimator.AddSenderReport(
-		  senderReportMapping.value().ntpMs,
-		  senderReportReceivedMs.value(),
-		  static_cast<uint32_t>(rtpStream->GetRtt()));
+		  senderReportMapping.value().ntpUs,
+		  senderReportReceivedAtUs.value(),
+		  static_cast<int64_t>(rtpStream->GetRttMs()));
 	}
 
-	std::optional<uint64_t> RemoteCaptureTimeEstimator::GetLocalCaptureMs(
+	std::optional<int64_t> RemoteCaptureTimeEstimator::GetLocalCaptureAtUs(
 	  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const
 	{
 		MS_TRACE();
@@ -63,15 +63,15 @@ namespace RTC
 			return std::nullopt;
 		}
 
-		const auto remoteCaptureMs = this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME
-		                               ? rtpStream->GetRemoteCaptureMsFromAbsCaptureTime(ts)
-		                               : rtpStream->GetRemoteCaptureMsFromSenderReport(ts);
+		const auto remoteCaptureAtUs = this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME
+		                                 ? rtpStream->GetRemoteCaptureAtUsFromAbsCaptureTime(ts)
+		                                 : rtpStream->GetRemoteCaptureAtUsFromSenderReport(ts);
 
-		if (!remoteCaptureMs.has_value())
+		if (!remoteCaptureAtUs.has_value())
 		{
 			return std::nullopt;
 		}
 
-		return this->clockOffsetEstimator.RemoteMsToLocalMs(remoteCaptureMs.value());
+		return this->clockOffsetEstimator.RemoteUsToLocalUs(remoteCaptureAtUs.value());
 	}
 } // namespace RTC