mediasoup 3.27.0 → 3.28.0

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

@@ -1,4 +1,3 @@
-#include "DepLibUV.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/SimpleProducerStreamManager.hpp"
@@ -139,12 +138,20 @@ namespace
 	// RtpStreamRecvListener must outlive the RtpStreamRecv.
 	RtpStreamRecvListener streamRecvListener; // NOLINT(readability-identifier-naming)
 
+	// Milliseconds between the packets fed by feedRtpStreamRecv() below.
+	constexpr int64_t PacketSpacingMs{ 1 };
+
+	// Current time, which the helpers below move so that traffic spans a period
+	// instead of happening all at once.
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	int64_t nowUs{ 1000000000000 };
+
 	// NOLINTNEXTLINE(readability-identifier-naming)
 	mocks::MockShared shared(/*getTimeUs*/
 	                         []() -> int64_t
 	                         {
-		                         return DepLibUV::GetTimeUs();
-	                         }); // NOLINT(readability-identifier-naming)
+		                         return nowUs;
+	                         });
 
 	std::unique_ptr<RTC::SimpleProducerStreamManager> createManager(
 	  MockListener* listener,
@@ -179,7 +186,9 @@ namespace
 		  std::addressof(streamRecvListener), std::addressof(shared), params, 0u, false);
 	}
 
-	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero.
+	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero. They
+	// are spread in time because a bitrate is measured over the period its samples
+	// span, and samples taken all at once span none.
 	void feedRtpStreamRecv(RTC::RTP::RtpStreamRecv* rtpStream, RTC::RTP::Packet* packet, uint16_t count)
 	{
 		auto firstSeq = static_cast<uint16_t>(packet->GetSequenceNumber() + 1);
@@ -187,18 +196,27 @@ namespace
 
 		for (uint16_t seq = firstSeq; Utils::Number::IsLowerThan<uint16_t>(seq, lastSeq); ++seq)
 		{
+			if (seq != firstSeq)
+			{
+				nowUs += PacketSpacingMs * 1000;
+			}
+
 			packet->SetSequenceNumber(seq);
 			rtpStream->ReceivePacket(packet, shared.GetTimeUs());
 		}
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		// The packets span the gaps between them plus the millisecond the first one
+		// was taken in.
+		const auto periodMs = static_cast<double>(((count - 1) * PacketSpacingMs) + 1);
 
-		// bitrate (bps) = totalBytes * 8000 / windowSizeMs.
-		// windowSizeMs for RtpStreamRecv is 2500.
-		const auto expectedBitrate =
-		  static_cast<int64_t>(std::trunc((count * packet->GetLength() * 8000.0f / 2500) + 0.5f));
+		// bitrate (bps) = bytes * 8000 / periodMs, where the packet that starts the
+		// period is left out of the bytes because the period does not cover the time
+		// it took to arrive.
+		const auto expectedBitrate = static_cast<int64_t>(std::trunc(
+		  ((static_cast<double>(count - 1) * static_cast<double>(packet->GetLength()) * 8000.0) / periodMs) +
+		  0.5));
 
-		REQUIRE(rtpStream->GetBitrate(nowMs) == expectedBitrate);
+		REQUIRE(rtpStream->GetBitrate(shared.GetTimeMs()) == expectedBitrate);
 	}
 } // namespace
 
@@ -411,7 +429,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs      = DepLibUV::GetTimeMs();
+		const int64_t nowMs      = shared.GetTimeMs();
 		const auto streamBitrate = rtpStream->GetBitrate(nowMs);
 		const auto usedBitrate   = manager->IncreaseLayer(
 		  /*bitrate*/ streamBitrate + 1, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
@@ -432,7 +450,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs            = DepLibUV::GetTimeMs();
+		const int64_t nowMs            = shared.GetTimeMs();
 		const auto streamBitrate       = rtpStream->GetBitrate(nowMs);
 		const int64_t availableBitrate = streamBitrate - 1;
 		auto usedBitrate               = manager->IncreaseLayer(
@@ -454,7 +472,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First call claims bitrate.
 		auto usedBitrate = manager->IncreaseLayer(
@@ -482,7 +500,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First iteration: claim bitrate and apply.
 		manager->IncreaseLayer(
@@ -509,7 +527,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs       = DepLibUV::GetTimeMs();
+		const int64_t nowMs       = shared.GetTimeMs();
 		const auto streamBitrate  = rtpStream->GetBitrate(nowMs);
 		const auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
@@ -530,7 +548,7 @@ SCENARIO("SimpleProducerStreamManager", "[rtp][producerstreammanager][simple]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
 		REQUIRE(desiredBitrate == 0);

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

@@ -1,4 +1,3 @@
-#include "DepLibUV.hpp"
 #include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
@@ -148,12 +147,20 @@ namespace
 	// RtpStreamRecvListener must outlive the RtpStreamRecv.
 	RtpStreamRecvListener streamRecvListener; // NOLINT(readability-identifier-naming)
 
+	// Milliseconds between the packets fed by feedRtpStreamRecv() below.
+	constexpr int64_t PacketSpacingMs{ 1 };
+
+	// Current time, which the helpers below move so that traffic spans a period
+	// instead of happening all at once.
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	int64_t nowUs{ 1000000000000 };
+
 	// NOLINTNEXTLINE(readability-identifier-naming)
 	mocks::MockShared shared(/*getTimeUs*/
 	                         []() -> int64_t
 	                         {
-		                         return DepLibUV::GetTimeUs();
-	                         }); // NOLINT(readability-identifier-naming)
+		                         return nowUs;
+	                         });
 
 	std::unique_ptr<RTC::SimulcastProducerStreamManager> createManager(
 	  MockListener* listener,
@@ -198,7 +205,9 @@ namespace
 		  std::addressof(streamRecvListener), std::addressof(shared), params, 0u, false);
 	}
 
-	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero.
+	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero. They
+	// are spread in time because a bitrate is measured over the period its samples
+	// span, and samples taken all at once span none.
 	void feedRtpStreamRecv(RTC::RTP::RtpStreamRecv* rtpStream, RTC::RTP::Packet* packet, uint16_t count)
 	{
 		auto firstSeq = static_cast<uint16_t>(packet->GetSequenceNumber() + 1);
@@ -206,18 +215,27 @@ namespace
 
 		for (uint16_t seq = firstSeq; Utils::Number::IsLowerThan<uint16_t>(seq, lastSeq); ++seq)
 		{
+			if (seq != firstSeq)
+			{
+				nowUs += PacketSpacingMs * 1000;
+			}
+
 			packet->SetSequenceNumber(seq);
 			rtpStream->ReceivePacket(packet, shared.GetTimeUs());
 		}
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		// The packets span the gaps between them plus the millisecond the first one
+		// was taken in.
+		const auto periodMs = static_cast<double>(((count - 1) * PacketSpacingMs) + 1);
 
-		// bitrate (bps) = totalBytes * 8000 / windowSizeMs.
-		// windowSizeMs for RtpStreamRecv is 2500.
-		const auto expectedBitrate =
-		  static_cast<int64_t>(std::trunc((count * packet->GetLength() * 8000.0f / 2500) + 0.5f));
+		// bitrate (bps) = bytes * 8000 / periodMs, where the packet that starts the
+		// period is left out of the bytes because the period does not cover the time
+		// it took to arrive.
+		const auto expectedBitrate = static_cast<int64_t>(std::trunc(
+		  ((static_cast<double>(count - 1) * static_cast<double>(packet->GetLength()) * 8000.0) / periodMs) +
+		  0.5));
 
-		REQUIRE(rtpStream->GetBitrate(nowMs) == expectedBitrate);
+		REQUIRE(rtpStream->GetBitrate(shared.GetTimeMs()) == expectedBitrate);
 	}
 } // namespace
 
@@ -1236,7 +1254,7 @@ SCENARIO("SimulcastProducerStreamManager", "[rtp][producerstreammanager][simulca
 		packet->SetSsrc(MappedSsrc0);
 		feedRtpStreamRecv(rtpStream0.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First call claims bitrate.
 		auto usedBitrate = manager->IncreaseLayer(
@@ -1267,7 +1285,7 @@ SCENARIO("SimulcastProducerStreamManager", "[rtp][producerstreammanager][simulca
 		packet->SetSsrc(MappedSsrc0);
 		feedRtpStreamRecv(rtpStream0.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First iteration: claim layer 0.
 		manager->IncreaseLayer(
@@ -1304,7 +1322,7 @@ SCENARIO("SimulcastProducerStreamManager", "[rtp][producerstreammanager][simulca
 		packet->SetSsrc(MappedSsrc1);
 		feedRtpStreamRecv(rtpStream1.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto bitrate0       = rtpStream0->GetBitrate(nowMs);
 		auto bitrate1       = rtpStream1->GetBitrate(nowMs);
 

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

@@ -1,4 +1,3 @@
-#include "DepLibUV.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/SvcProducerStreamManager.hpp"
@@ -154,12 +153,20 @@ namespace
 	// RtpStreamRecvListener must outlive the RtpStreamRecv.
 	RtpStreamRecvListener streamRecvListener; // NOLINT(readability-identifier-naming)
 
+	// Milliseconds between the packets fed by feedRtpStreamRecv() below.
+	constexpr int64_t PacketSpacingMs{ 1 };
+
+	// Current time, which the helpers below move so that traffic spans a period
+	// instead of happening all at once.
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	int64_t nowUs{ 1000000000000 };
+
 	// NOLINTNEXTLINE(readability-identifier-naming)
 	mocks::MockShared shared(/*getTimeUs*/
 	                         []() -> int64_t
 	                         {
-		                         return DepLibUV::GetTimeUs();
-	                         }); // NOLINT(readability-identifier-naming)
+		                         return nowUs;
+	                         });
 
 	std::unique_ptr<RTC::SvcProducerStreamManager> createManager(
 	  MockListener* listener,
@@ -201,7 +208,9 @@ namespace
 		  std::addressof(streamRecvListener), std::addressof(shared), params, 0u, false);
 	}
 
-	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero.
+	// Feed packets into the RtpStreamRecv so GetBitrate() returns non-zero. They
+	// are spread in time because a bitrate is measured over the period its samples
+	// span, and samples taken all at once span none.
 	void feedRtpStreamRecv(RTC::RTP::RtpStreamRecv* rtpStream, RTC::RTP::Packet* packet, uint16_t count)
 	{
 		auto firstSeq = static_cast<uint16_t>(packet->GetSequenceNumber() + 1);
@@ -209,18 +218,27 @@ namespace
 
 		for (uint16_t seq = firstSeq; Utils::Number::IsLowerThan<uint16_t>(seq, lastSeq); ++seq)
 		{
+			if (seq != firstSeq)
+			{
+				nowUs += PacketSpacingMs * 1000;
+			}
+
 			packet->SetSequenceNumber(seq);
 			rtpStream->ReceivePacket(packet, shared.GetTimeUs());
 		}
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		// The packets span the gaps between them plus the millisecond the first one
+		// was taken in.
+		const auto periodMs = static_cast<double>(((count - 1) * PacketSpacingMs) + 1);
 
-		// bitrate (bps) = totalBytes * 8000 / windowSizeMs.
-		// windowSizeMs for RtpStreamRecv is 2500.
-		const auto expectedBitrate =
-		  static_cast<int64_t>(std::trunc((count * packet->GetLength() * 8000.0f / 2500) + 0.5f));
+		// bitrate (bps) = bytes * 8000 / periodMs, where the packet that starts the
+		// period is left out of the bytes because the period does not cover the time
+		// it took to arrive.
+		const auto expectedBitrate = static_cast<int64_t>(std::trunc(
+		  ((static_cast<double>(count - 1) * static_cast<double>(packet->GetLength()) * 8000.0) / periodMs) +
+		  0.5));
 
-		REQUIRE(rtpStream->GetBitrate(nowMs) == expectedBitrate);
+		REQUIRE(rtpStream->GetBitrate(shared.GetTimeMs()) == expectedBitrate);
 	}
 } // namespace
 
@@ -943,7 +961,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 
 		manager->SetExternallyManagedBitrate();
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto usedBitrate    = manager->IncreaseLayer(
 		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
@@ -960,7 +978,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 		manager->SetExternallyManagedBitrate();
 
 		// Score is 0 by default (no RTP received + inactivity check disabled).
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto usedBitrate    = manager->IncreaseLayer(
 		  /*bitrate*/ 1000000, /*considerLoss*/ false, /*lossPercentage*/ 0.0f, nowMs);
 
@@ -987,7 +1005,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First call claims bitrate.
 		auto usedBitrate = manager->IncreaseLayer(
@@ -1021,7 +1039,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 		// Feed packets so the stream has non-zero bitrate.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 
 		// First iteration.
 		manager->IncreaseLayer(
@@ -1082,7 +1100,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 		MockListener listener;
 		auto manager = createManager(std::addressof(listener));
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
 		REQUIRE(desiredBitrate == 0);
@@ -1106,7 +1124,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto streamBitrate  = rtpStream->GetBitrate(nowMs);
 		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
@@ -1132,7 +1150,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 		// Feed packets so total stream bitrate > 0.
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto desiredBitrate = manager->GetDesiredBitrate(nowMs);
 
 		// K-SVC returns the max per-spatial-layer bitrate. With a plain RtpStreamRecv
@@ -1243,7 +1261,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto streamBitrate  = rtpStream->GetBitrate(nowMs);
 
 		// With 1% loss virtualBitrate = 1.08 * bitrate, so we can afford the stream
@@ -1274,7 +1292,7 @@ SCENARIO("SvcProducerStreamManager", "[rtp][producerstreammanager][svc]")
 
 		feedRtpStreamRecv(rtpStream.get(), packet.get(), 100);
 
-		const int64_t nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = shared.GetTimeMs();
 		auto streamBitrate  = rtpStream->GetBitrate(nowMs);
 
 		// With 50% loss virtualBitrate = (1 - 0.5*0.5) * bitrate = 0.75 * bitrate.

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

@@ -186,10 +186,10 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{  1u, 1000000 },
-			{  3u, 1050000 },
-			{  5u, 1100000 },
-			{  6u, 1150000 },
+			{ 1u, 1000000 },
+			{ 3u, 1050000 },
+			{ 5u, 1100000 },
+			{ 6u, 1150000 },
 		};
 
 		TestResults results
@@ -215,12 +215,12 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{  1u, 1000000 },
-			{  1u, 1050000 },
-			{  2u, 1100000 },
-			{  3u, 1150000 },
-			{  3u, 1200000 },
-			{  4u, 1250000 },
+			{ 1u, 1000000 },
+			{ 1u, 1050000 },
+			{ 2u, 1100000 },
+			{ 3u, 1150000 },
+			{ 3u, 1200000 },
+			{ 4u, 1250000 },
 		};
 
 		TestResults results

package/worker/test/src/Utils/TestTime.cpp

@@ -2,39 +2,138 @@
 #include "DepLibUV.hpp"
 #include "Utils.hpp"
 #include <catch2/catch_test_macros.hpp>
+#include <cstdlib> // std::abs()
+#include <limits>
 
 SCENARIO("Utils::Time", "[utils][time]")
 {
-	SECTION("Ntp2TimeUs()")
+	SECTION("TimeUsToMs()")
+	{
+		REQUIRE(Utils::Time::TimeUsToMs(0) == 0);
+		REQUIRE(Utils::Time::TimeUsToMs(1000) == 1);
+		REQUIRE(Utils::Time::TimeUsToMs(1499) == 1);
+		// Halves upwards.
+		REQUIRE(Utils::Time::TimeUsToMs(1500) == 2);
+		REQUIRE(Utils::Time::TimeUsToMs(1501) == 2);
+		REQUIRE(Utils::Time::TimeUsToMs(3990000000750000) == 3990000000750);
+
+		// A negative instant rounds the same way, so halves still go upwards rather
+		// than towards zero.
+		REQUIRE(Utils::Time::TimeUsToMs(-1000) == -1);
+		REQUIRE(Utils::Time::TimeUsToMs(-1499) == -1);
+		REQUIRE(Utils::Time::TimeUsToMs(-1500) == -1);
+		REQUIRE(Utils::Time::TimeUsToMs(-1501) == -2);
+		REQUIRE(Utils::Time::TimeUsToMs(-500) == 0);
+		REQUIRE(Utils::Time::TimeUsToMs(-501) == -1);
+
+		// The extremes are rounded rather than overflowing.
+		REQUIRE(Utils::Time::TimeUsToMs(std::numeric_limits<int64_t>::max()) == 9223372036854776LL);
+		REQUIRE(Utils::Time::TimeUsToMs(std::numeric_limits<int64_t>::min()) == -9223372036854776LL);
+	}
+
+	SECTION("NtpToTimeUs()")
 	{
 		const auto nowUs  = DepLibUV::GetTimeUs();
-		const auto ntp    = Utils::Time::TimeUs2Ntp(nowUs);
-		const auto nowUs2 = Utils::Time::Ntp2TimeUs(ntp);
-		const auto ntp2   = Utils::Time::TimeUs2Ntp(nowUs2);
+		const auto ntp    = Utils::Time::TimeUsToNtp(nowUs);
+		const auto nowUs2 = Utils::Time::NtpToTimeUs(ntp);
+		const auto ntp2   = Utils::Time::TimeUsToNtp(nowUs2);
 
 		REQUIRE(nowUs2 == nowUs);
 		REQUIRE(ntp2.seconds == ntp.seconds);
 		REQUIRE(ntp2.fractions == ntp.fractions);
 	}
 
-	SECTION("TimeUs2Ntp()")
+	SECTION("TimeUsToNtp()")
 	{
-		auto ntp = Utils::Time::TimeUs2Ntp(1500000);
+		auto ntp = Utils::Time::TimeUsToNtp(1500000);
 
 		REQUIRE(ntp.seconds == 1);
 		// Half a second in NTP fractional units.
 		REQUIRE(ntp.fractions == 2147483648);
 
 		// A real NTP instant, seconds since Jan 1, 1900, which still fits in 32 bits.
-		ntp = Utils::Time::TimeUs2Ntp(3990000000750000);
+		ntp = Utils::Time::TimeUsToNtp(3990000000750000);
 
 		REQUIRE(ntp.seconds == 3990000000);
-		REQUIRE(Utils::Time::Ntp2TimeUs(ntp) == 3990000000750000);
+		REQUIRE(Utils::Time::NtpToTimeUs(ntp) == 3990000000750000);
 
 		// Sub-millisecond times are kept.
-		REQUIRE(Utils::Time::TimeUs2Ntp(1000500).fractions > Utils::Time::TimeUs2Ntp(1000000).fractions);
-		REQUIRE(Utils::Time::TimeUs2Ntp(1000500).fractions < Utils::Time::TimeUs2Ntp(1001000).fractions);
-		REQUIRE(Utils::Time::Ntp2TimeUs(Utils::Time::TimeUs2Ntp(1000500)) == 1000500);
+		REQUIRE(Utils::Time::TimeUsToNtp(1000500).fractions > Utils::Time::TimeUsToNtp(1000000).fractions);
+		REQUIRE(Utils::Time::TimeUsToNtp(1000500).fractions < Utils::Time::TimeUsToNtp(1001000).fractions);
+		REQUIRE(Utils::Time::NtpToTimeUs(Utils::Time::TimeUsToNtp(1000500)) == 1000500);
+	}
+
+	// Middle 32 bits of the given NTP timestamp.
+	auto toCompactNtp = [](uint32_t seconds, uint32_t fractions) -> uint32_t
+	{
+		return (seconds << 16) | (fractions >> 16);
+	};
+
+	auto toTimeUs = [](uint32_t seconds, uint32_t fractions) -> int64_t
+	{
+		return Utils::Time::NtpToTimeUs(Utils::Time::Ntp{ .seconds = seconds, .fractions = fractions });
+	};
+
+	SECTION("CompactNtpIntervalToTimeUs()")
+	{
+		{
+			const int64_t diffUs = toTimeUs(0x12654, 0x64335) - toTimeUs(0x12345, 0x23456);
+			const uint32_t compactNtpDiff = toCompactNtp(0x12654, 0x64335) - toCompactNtp(0x12345, 0x23456);
+
+			REQUIRE(std::abs(Utils::Time::CompactNtpIntervalToTimeUs(compactNtpDiff) - diffUs) <= 1000);
+		}
+
+		// The later timestamp has the lower compact NTP representation, which is fine as
+		// long as the difference is computed with unsigned arithmetic.
+		{
+			const int64_t diffUs = toTimeUs(0x20000, 0x64335) - toTimeUs(0x1ffff, 0x23456);
+
+			REQUIRE(diffUs > 0);
+			REQUIRE(toCompactNtp(0x20000, 0x64335) < toCompactNtp(0x1ffff, 0x23456));
+
+			const uint32_t compactNtpDiff = toCompactNtp(0x20000, 0x64335) - toCompactNtp(0x1ffff, 0x23456);
+
+			REQUIRE(std::abs(Utils::Time::CompactNtpIntervalToTimeUs(compactNtpDiff) - diffUs) <= 1000);
+		}
+
+		// A difference close to 2^16 seconds is a negative one.
+		{
+			const int64_t diffUs = toTimeUs(0x1ffff, 0x64335) - toTimeUs(0x20000, 0x23456);
+
+			REQUIRE(diffUs < 0);
+
+			const uint32_t compactNtpDiff = toCompactNtp(0x1ffff, 0x64335) - toCompactNtp(0x20000, 0x23456);
+
+			REQUIRE(std::abs(Utils::Time::CompactNtpIntervalToTimeUs(compactNtpDiff) - diffUs) <= 1000);
+		}
+
+		// Right in the middle, both +2^15 and -2^15 seconds are valid results.
+		REQUIRE(std::abs(Utils::Time::CompactNtpIntervalToTimeUs(0x80000000)) == 0x8000 * 1000000LL);
+	}
+
+	SECTION("CompactNtpRttToTimeUs()")
+	{
+		// A difference close to 2^15 seconds is still a positive one.
+		{
+			const int64_t diffUs = toTimeUs(0x17fff, 0xffff5) - toTimeUs(0x10000, 0x00006);
+
+			REQUIRE(std::abs(diffUs - (((1 << 15) - 1) * 1000000LL)) <= 1000);
+
+			const uint32_t compactNtpDiff = toCompactNtp(0x17fff, 0xffff5) - toCompactNtp(0x10000, 0x00006);
+
+			REQUIRE(std::abs(Utils::Time::CompactNtpRttToTimeUs(compactNtpDiff) - diffUs) <= 1000);
+		}
+
+		// A negative round trip time yields 1 millisecond.
+		{
+			const int64_t diffUs = toTimeUs(0x1ffff, 0x64335) - toTimeUs(0x20000, 0x23456);
+
+			REQUIRE(diffUs < 0);
+
+			const uint32_t compactNtpDiff = toCompactNtp(0x1ffff, 0x64335) - toCompactNtp(0x20000, 0x23456);
+
+			REQUIRE(Utils::Time::CompactNtpRttToTimeUs(compactNtpDiff) == 1000);
+		}
 	}
 
 	SECTION("TimeUsToAbsSendTime()")
@@ -63,25 +162,25 @@ SCENARIO("Utils::Time", "[utils][time]")
 		REQUIRE(Utils::Time::TimeUsToAbsSendTime(-WrapPeriodUs) == 0);
 	}
 
-	SECTION("TimeUs2Q32x32()")
+	SECTION("TimeUsToQ32x32()")
 	{
 		// A whole second is the fractional unit itself.
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeUs2Q32x32(1000000).value() == 4294967296);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(1000000).value() == 4294967296);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeUs2Q32x32(-1000000).value() == -4294967296);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(-1000000).value() == -4294967296);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeUs2Q32x32(0).value() == 0);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(0).value() == 0);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeUs2Q32x32(1000).value() == 4294967);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(1000).value() == 4294967);
 
 		// Seconds are 32 bits wide in the format, so 2^31 seconds no longer fit.
 		constexpr int64_t OutOfRangeUs{ (1LL << 31) * 1000000 };
 
-		REQUIRE(Utils::Time::TimeUs2Q32x32(OutOfRangeUs) == std::nullopt);
-		REQUIRE(Utils::Time::TimeUs2Q32x32(-OutOfRangeUs) == std::nullopt);
-		REQUIRE(Utils::Time::TimeUs2Q32x32(OutOfRangeUs - 1).has_value());
-		REQUIRE(Utils::Time::TimeUs2Q32x32(-OutOfRangeUs + 1).has_value());
+		REQUIRE(Utils::Time::TimeUsToQ32x32(OutOfRangeUs) == std::nullopt);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(-OutOfRangeUs) == std::nullopt);
+		REQUIRE(Utils::Time::TimeUsToQ32x32(OutOfRangeUs - 1).has_value());
+		REQUIRE(Utils::Time::TimeUsToQ32x32(-OutOfRangeUs + 1).has_value());
 	}
 
 	SECTION("Q32x32ToTimeUs()")
@@ -93,7 +192,7 @@ SCENARIO("Utils::Time", "[utils][time]")
 		for (const int64_t us : { 1, -1, 1000, -1000, 1000000, -1000000, 123456789, -123456789 })
 		{
 			// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-			REQUIRE(Utils::Time::Q32x32ToTimeUs(Utils::Time::TimeUs2Q32x32(us).value()) == us);
+			REQUIRE(Utils::Time::Q32x32ToTimeUs(Utils::Time::TimeUsToQ32x32(us).value()) == us);
 		}
 	}
 }