mediasoup 3.26.0 → 3.27.0

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

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

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

@@ -65,6 +65,11 @@ namespace
 		{
 			return 0;
 		}
+
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/) override
+		{
+		}
 	};
 
 	class MockEncodingContext : public RTC::RTP::Codecs::EncodingContext
@@ -135,10 +140,10 @@ namespace
 	RtpStreamRecvListener streamRecvListener; // NOLINT(readability-identifier-naming)
 
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return DepLibUV::GetTimeMs();
+		                         return DepLibUV::GetTimeUs();
 	                         }); // NOLINT(readability-identifier-naming)
 
 	std::unique_ptr<RTC::SimpleProducerStreamManager> createManager(
@@ -160,7 +165,7 @@ namespace
 		  kind,
 		  keyFrameSupported,
 		  listener,
-		  &shared);
+		  std::addressof(shared));
 	}
 
 	std::unique_ptr<RTC::RTP::RtpStreamRecv> createRtpStreamRecv()
@@ -170,7 +175,8 @@ namespace
 		params.ssrc      = MappedSsrc;
 		params.clockRate = 90000;
 
-		return std::make_unique<RTC::RTP::RtpStreamRecv>(&streamRecvListener, &shared, params, 0u, false);
+		return std::make_unique<RTC::RTP::RtpStreamRecv>(
+		  std::addressof(streamRecvListener), std::addressof(shared), params, 0u, false);
 	}
 
 	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero.
@@ -182,15 +188,15 @@ namespace
 		for (uint16_t seq = firstSeq; Utils::Number::IsLowerThan<uint16_t>(seq, lastSeq); ++seq)
 		{
 			packet->SetSequenceNumber(seq);
-			rtpStream->ReceivePacket(packet);
+			rtpStream->ReceivePacket(packet, shared.GetTimeUs());
 		}
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = DepLibUV::GetTimeMs();
 
 		// bitrate (bps) = totalBytes * 8000 / windowSizeMs.
 		// windowSizeMs for RtpStreamRecv is 2500.
-		auto expectedBitrate =
-		  static_cast<uint32_t>(std::trunc((count * packet->GetLength() * 8000.0f / 2500) + 0.5f));
+		const auto expectedBitrate =
+		  static_cast<int64_t>(std::trunc((count * packet->GetLength() * 8000.0f / 2500) + 0.5f));
 
 		REQUIRE(rtpStream->GetBitrate(nowMs) == expectedBitrate);
 	}
@@ -208,7 +214,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("returns BUFFER when sync required and packet is not a keyframe")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -223,7 +229,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("returns FORWARD with sendBufferedPackets when syncing with a keyframe")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -249,7 +255,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("returns DROP for empty payload packets")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener, /*keyFrameSupported*/ false);
+		auto manager   = createManager(std::addressof(listener), /*keyFrameSupported*/ false);
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -293,7 +299,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("returns FORWARD and completes sync when keyFrameSupported is false for the first packet")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener, /*keyFrameSupported*/ false);
+		auto manager   = createManager(std::addressof(listener), /*keyFrameSupported*/ false);
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -316,7 +322,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("returns FORWARD for normal packets after sync")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener, /*keyFrameSupported*/ false);
+		auto manager   = createManager(std::addressof(listener), /*keyFrameSupported*/ false);
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -342,7 +348,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("OnTransportConnected() requests keyframe when active")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -359,7 +365,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		MockListener listener;
 		listener.isActive = false;
 
-		auto manager = createManager(&listener);
+		auto manager = createManager(std::addressof(listener));
 
 		// Don't wire producerRtpStream — manager is not active.
 		manager->OnTransportConnected();
@@ -370,7 +376,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("OnResumed() sets syncRequired and requests keyframe")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -395,7 +401,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("IncreaseLayer() returns producer bitrate when it is less than available bitrate")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -405,18 +411,18 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs        = DepLibUV::GetTimeMs();
-		auto steamBitrate = rtpStream->GetBitrate(nowMs);
-		auto usedBitrate  = manager->IncreaseLayer(
-		  /*bitrate*/ steamBitrate + 1u, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
+		const int64_t nowMs      = DepLibUV::GetTimeMs();
+		const auto streamBitrate = rtpStream->GetBitrate(nowMs);
+		const auto usedBitrate   = manager->IncreaseLayer(
+		  /*bitrate*/ streamBitrate + 1, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
-		REQUIRE(usedBitrate == steamBitrate);
+		REQUIRE(usedBitrate == streamBitrate);
 	}
 
 	SECTION("IncreaseLayer() returns available bitrate when it is less than producer bitrate")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -426,10 +432,10 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs                      = DepLibUV::GetTimeMs();
-		const auto streamBitrate        = rtpStream->GetBitrate(nowMs);
-		const uint32_t availableBitrate = streamBitrate - 1;
-		auto usedBitrate                = manager->IncreaseLayer(
+		const int64_t nowMs            = DepLibUV::GetTimeMs();
+		const auto streamBitrate       = rtpStream->GetBitrate(nowMs);
+		const int64_t availableBitrate = streamBitrate - 1;
+		auto usedBitrate               = manager->IncreaseLayer(
 		  /*bitrate*/ availableBitrate, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
 		REQUIRE(usedBitrate == availableBitrate);
@@ -438,7 +444,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 	SECTION("IncreaseLayer() returns 0 on second call in same iteration")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -448,25 +454,25 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = DepLibUV::GetTimeMs();
 
 		// First call claims bitrate.
 		auto usedBitrate = manager->IncreaseLayer(
-		  /*bitrate*/ 1000000u, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
+		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
-		REQUIRE(usedBitrate > 0u);
+		REQUIRE(usedBitrate > 0);
 
 		// Second call in same iteration should return 0.
 		auto usedBitrate2 = manager->IncreaseLayer(
-		  /*bitrate*/ 1000000u, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
+		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
-		REQUIRE(usedBitrate2 == 0u);
+		REQUIRE(usedBitrate2 == 0);
 	}
 
 	SECTION("IncreaseLayer() works again after ApplyLayers()")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -476,24 +482,24 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = DepLibUV::GetTimeMs();
 
 		// First iteration: claim bitrate and apply.
 		manager->IncreaseLayer(
-		  /*bitrate*/ 1000000u, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
+		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 		manager->ApplyLayers(/*rtpStreamActiveMs*/ 0u);
 
 		// After ApplyLayers, IncreaseLayer should work again.
 		auto usedBitrate = manager->IncreaseLayer(
-		  /*bitrate*/ 1000000u, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
+		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
-		REQUIRE(usedBitrate > 0u);
+		REQUIRE(usedBitrate > 0);
 	}
 
 	SECTION("GetDesiredBitrate() returns producer bitrate for video")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener);
+		auto manager   = createManager(std::addressof(listener));
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -503,17 +509,18 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs          = DepLibUV::GetTimeMs();
-		auto steamBitrate   = rtpStream->GetBitrate(nowMs);
-		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
+		const int64_t nowMs       = DepLibUV::GetTimeMs();
+		const auto streamBitrate  = rtpStream->GetBitrate(nowMs);
+		const auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
-		REQUIRE(desiredBitrate == steamBitrate);
+		REQUIRE(desiredBitrate == streamBitrate);
 	}
 
 	SECTION("GetDesiredBitrate() returns 0 for audio kind")
 	{
 		MockListener listener;
-		auto manager   = createManager(&listener, /*keyFrameSupported*/ false, RTC::Media::Kind::AUDIO);
+		auto manager =
+		  createManager(std::addressof(listener), /*keyFrameSupported*/ false, RTC::Media::Kind::AUDIO);
 		auto rtpStream = createRtpStreamRecv();
 
 		manager->ProducerRtpStream(rtpStream.get(), MappedSsrc);
@@ -523,9 +530,9 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		auto nowMs          = DepLibUV::GetTimeMs();
+		const int64_t nowMs = DepLibUV::GetTimeMs();
 		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
-		REQUIRE(desiredBitrate == 0u);
+		REQUIRE(desiredBitrate == 0);
 	}
 }