mediasoup 3.28.0 → 3.29.0

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

@@ -131,7 +131,7 @@ SCENARIO("NackGenerator generator", "[rtp][rtcp][nack]")
 		                         return 1000 * 1000;
 	                         });
 
-	auto validate =
+	const auto validate =
 	  [&shared](std::unique_ptr<RTC::RTP::Packet>& packet, std::vector<TestNackGeneratorInput>& inputs)
 	{
 		TestNackGeneratorListener listener;

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

@@ -13,7 +13,7 @@
 SCENARIO("PortManager", "[portmanager]")
 {
 	// Helper: build an IPv4 `sockaddr_storage` from a dotted-quad string + port=0.
-	auto makeV4 = [](const char* dottedQuad)
+	const auto makeV4 = [](const char* dottedQuad)
 	{
 		sockaddr_storage ss{};
 		auto* in = reinterpret_cast<sockaddr_in*>(std::addressof(ss));
@@ -27,7 +27,7 @@ SCENARIO("PortManager", "[portmanager]")
 	};
 
 	// Helper: build an IPv6 `sockaddr_storage` from a textual address + port=0.
-	auto makeV6 = [](const char* literal)
+	const auto makeV6 = [](const char* literal)
 	{
 		sockaddr_storage ss{};
 		auto* in6 = reinterpret_cast<sockaddr_in6*>(std::addressof(ss));

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

@@ -14,7 +14,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		std::optional<int64_t> rate;
 	};
 
-	auto validate =
+	const auto validate =
 	  [](RTC::RateCalculator& rate, int64_t timeBaseMs, const std::vector<TestRateCalculatorData>& input)
 	{
 		for (const auto& item : input)

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

@@ -69,7 +69,7 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 	// Makes the Sender Report about `RemoteBaseTs` plus `idx` seconds of media reach
 	// us with no delay at all, and feeds it to the estimator.
-	auto receiveSenderReport = [&nowUs, &shared, &rtpStream, &estimator](uint32_t idx) -> void
+	const auto receiveSenderReport = [&nowUs, &shared, &rtpStream, &estimator](uint32_t idx) -> void
 	{
 		nowUs = LocalBaseUs + (idx * 1000000);
 
@@ -86,7 +86,7 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 	// 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
+	const auto receiveAbsCaptureTimePacket = [&nowUs, &rtpStream]() -> void
 	{
 		// Id the extension is given, which only has to match between what is written
 		// and what is read back.
@@ -124,9 +124,10 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 	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, nowUs).has_value());
+		REQUIRE(estimator.GetSource().has_value() == false);
+		REQUIRE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 	}
 
 	SECTION("the first Producer chooses abs-capture-time when it negotiated it")
@@ -168,23 +169,26 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		// it however long this sender has been around.
 		nowUs += 60 * 1000000;
 
-		REQUIRE_FALSE(
-		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value());
+		REQUIRE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 		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.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 		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.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 		REQUIRE(estimator.GetSource() == RTC::RemoteCaptureTimeEstimator::Source::SENDER_REPORT);
 	}
 
@@ -211,8 +215,9 @@ 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, nowUs).has_value());
+		REQUIRE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 
 		for (uint32_t idx{ 1 }; idx < RTC::RemoteClockOffsetEstimator::MinSampleCount; ++idx)
 		{
@@ -251,7 +256,8 @@ 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, nowUs).has_value());
+		REQUIRE(
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs, nowUs).has_value() ==
+		  false);
 	}
 }

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

@@ -19,13 +19,13 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 	// 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,
-	              int64_t remoteNtpUs,
-	              int64_t localArrivalAtUs,
-	              size_t count,
-	              int64_t owdUs,
-	              int64_t rttMs) -> void
+	const auto feed = [](
+	                    RTC::RemoteClockOffsetEstimator& estimator,
+	                    int64_t remoteNtpUs,
+	                    int64_t localArrivalAtUs,
+	                    size_t count,
+	                    int64_t owdUs,
+	                    int64_t rttMs) -> void
 	{
 		for (size_t idx{ 0 }; idx < count; ++idx)
 		{
@@ -41,7 +41,7 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 	{
 		feed(estimator, RemoteBaseUs, LocalBaseUs, minSampleCount - 1, 0, 0);
 
-		REQUIRE_FALSE(estimator.GetOffsetUs().has_value());
+		REQUIRE(estimator.GetOffsetUs().has_value() == false);
 
 		// One more Sender Report reaches the minimum.
 		const int64_t elapsedUs = static_cast<int64_t>(minSampleCount - 1) * 1000000;
@@ -181,7 +181,7 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 		estimator.AddSenderReport(RemoteBaseUs + 1000, LocalBaseUs, 0);
 		estimator.AddSenderReport(RemoteBaseUs + 2000, LocalBaseUs, 0);
 
-		REQUIRE_FALSE(estimator.GetOffsetUs().has_value());
+		REQUIRE(estimator.GetOffsetUs().has_value() == false);
 
 		// Two more compound packets reach the minimum.
 		estimator.AddSenderReport(RemoteBaseUs + 1000000, LocalBaseUs + 1000000, 0);
@@ -200,14 +200,14 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 		estimator.AddSenderReport(0, LocalBaseUs + 1000000, 0);
 		estimator.AddSenderReport(0, LocalBaseUs + 2000000, 0);
 
-		REQUIRE_FALSE(estimator.GetOffsetUs().has_value());
+		REQUIRE(estimator.GetOffsetUs().has_value() == false);
 	}
 
 	SECTION("remote times are translated into our clock")
 	{
 		const RTC::RemoteClockOffsetEstimator untrainedEstimator;
 
-		REQUIRE_FALSE(untrainedEstimator.RemoteUsToLocalUs(RemoteBaseUs).has_value());
+		REQUIRE(untrainedEstimator.RemoteUsToLocalUs(RemoteBaseUs).has_value() == false);
 
 		feed(estimator, RemoteBaseUs, LocalBaseUs, minSampleCount, 0, 0);
 
@@ -219,7 +219,7 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 		REQUIRE(estimator.RemoteUsToLocalUs(RemoteBaseUs + 500000).value() == LocalBaseUs + 500000);
 
 		// A remote time older than the origin of our clock cannot be translated.
-		REQUIRE_FALSE(estimator.RemoteUsToLocalUs(0).has_value());
+		REQUIRE(estimator.RemoteUsToLocalUs(0).has_value() == false);
 	}
 
 	SECTION("Reset() clears the estimation")
@@ -230,7 +230,7 @@ SCENARIO("RemoteClockOffsetEstimator", "[rtp][rtcp][remoteclockoffsetestimator]"
 
 		estimator.Reset();
 
-		REQUIRE_FALSE(estimator.GetOffsetUs().has_value());
+		REQUIRE(estimator.GetOffsetUs().has_value() == false);
 
 		// 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.

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

@@ -15,7 +15,7 @@ SCENARIO("parseScalabilityMode()")
 		bool ksvc              = false;
 	};
 
-	auto parseScalabilityMode = [](const std::string& scalabilityMode)
+	const auto parseScalabilityMode = [](const std::string& scalabilityMode)
 	{
 		struct ScalabilityMode result;
 		std::smatch match;

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

@@ -8,13 +8,13 @@
 SCENARIO("SubchannelsCodec", "[subchannels]")
 {
 	// Build a message with the given payload.
-	auto makeMessage = [](const std::vector<uint8_t>& payload)
+	const auto makeMessage = [](const std::vector<uint8_t>& payload)
 	{
 		return RTC::SCTP::Message(/*streamId*/ 1, /*ppid*/ 51, payload);
 	};
 
 	// Copy the current payload of a message into a std::vector.
-	auto payloadToVector = [](const RTC::SCTP::Message& message)
+	const auto payloadToVector = [](const RTC::SCTP::Message& message)
 	{
 		const auto payload = message.GetPayload();
 

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

@@ -101,7 +101,7 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 	};
 	// clang-format on
 
-	auto validate =
+	const auto validate =
 	  [&buffer,
 		 &shared](std::vector<TestTransportCongestionControlServerInput>& inputs, TestResults& results)
 	{

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

@@ -31,7 +31,8 @@ SCENARIO("TransportTuple", "[transporttuple]")
 		                         return 1000 * 1000;
 	                         });
 
-	auto makeUdpSocket = [&listener, &shared](const std::string& ip, uint16_t minPort, uint16_t maxPort)
+	const auto makeUdpSocket =
+	  [&listener, &shared](const std::string& ip, uint16_t minPort, uint16_t maxPort)
 	{
 		auto flags = RTC::Transport::SocketFlags{ .ipv6Only = false, .udpReusePort = false };
 		RTC::PortManager::PortRangeKey portRangeKey{};
@@ -47,7 +48,7 @@ SCENARIO("TransportTuple", "[transporttuple]")
 		return std::unique_ptr<RTC::UdpSocket>(udpSocket);
 	};
 
-	auto makeUdpSockAddr = [](int family, const std::string& ip, uint16_t port)
+	const auto makeUdpSockAddr = [](int family, const std::string& ip, uint16_t port)
 	{
 		if (family == AF_INET)
 		{

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

@@ -1,8 +1,10 @@
 #include "common.hpp"
 #include "Utils.hpp"
 #include <ankerl/unordered_dense.h>
+#include <array>
 #include <catch2/catch_test_macros.hpp>
 #include <limits> // std::numeric_limits()
+#include <random> // std::mt19937
 
 SCENARIO("Utils::Crypto", "[utils][crypto]")
 {
@@ -75,6 +77,73 @@ SCENARIO("Utils::Crypto", "[utils][crypto]")
 		REQUIRE(Utils::Crypto::GetCRC32c(data32Decrementing, sizeof(data32Decrementing)) == 0x5CDB3F11);
 		REQUIRE(Utils::Crypto::GetCRC32c(dataSCSICommandPDU, sizeof(dataSCSICommandPDU)) == 0x563A96D9);
 	}
+
+	SECTION("GetCRC32() and GetCRC32c() match a byte at a time reference")
+	{
+		// Guards the slice-by-8 implementations against regressions at the 8 byte block
+		// boundary and on unaligned input. Deliberately table free so that it shares
+		// nothing with the implementations under test.
+		const auto reference =
+		  [](uint32_t polynomial, bool byteSwap, const uint8_t* data, size_t size) -> uint32_t
+		{
+			uint32_t crc{ 0xFFFFFFFF };
+
+			for (size_t i{ 0u }; i < size; ++i)
+			{
+				uint32_t byte{ static_cast<uint32_t>((crc ^ data[i]) & 0xFF) };
+
+				for (size_t bit{ 0u }; bit < 8u; ++bit)
+				{
+					byte = (byte & 1u) ? (byte >> 1) ^ polynomial : (byte >> 1);
+				}
+
+				crc = (crc >> 8) ^ byte;
+			}
+
+			const uint32_t result{ ~crc };
+
+			if (!byteSwap)
+			{
+				return result;
+			}
+
+			return ((result & 0xff) << 24) | (((result >> 8) & 0xff) << 16) |
+			       (((result >> 16) & 0xff) << 8) | ((result >> 24) & 0xff);
+		};
+
+		std::mt19937 rng{ 20240101 };
+		std::array<uint8_t, 1024 + 8> buffer{};
+
+		for (auto& byte : buffer)
+		{
+			byte = static_cast<uint8_t>(rng());
+		}
+
+		size_t mismatches{ 0u };
+
+		// Every length up to 1024 bytes at every misalignment within an 8 byte word.
+		for (size_t offset{ 0u }; offset < 8u; ++offset)
+		{
+			for (size_t size{ 0u }; size <= 1024u; ++size)
+			{
+				const uint8_t* data = buffer.data() + offset;
+
+				// CRC-32 (IEEE 802.3), no byte swap.
+				if (Utils::Crypto::GetCRC32(data, size) != reference(0xEDB88320u, false, data, size))
+				{
+					++mismatches;
+				}
+
+				// CRC-32C (Castagnoli), byte swapped.
+				if (Utils::Crypto::GetCRC32c(data, size) != reference(0x82F63B78u, true, data, size))
+				{
+					++mismatches;
+				}
+			}
+		}
+
+		REQUIRE(mismatches == 0u);
+	}
 }
 
 SCENARIO("Utils::Crypto::GetRandomUInt()", "[utils][crypto]")
@@ -84,7 +153,7 @@ SCENARIO("Utils::Crypto::GetRandomUInt()", "[utils][crypto]")
 
 	for (size_t i = 0; i < 200; ++i)
 	{
-		auto randomNumber =
+		const auto randomNumber =
 		  Utils::Crypto::GetRandomUInt<uint32_t>(0, std::numeric_limits<uint32_t>::max());
 
 		REQUIRE(randomUint32Numbers.find(randomNumber) == randomUint32Numbers.end());
@@ -94,7 +163,7 @@ SCENARIO("Utils::Crypto::GetRandomUInt()", "[utils][crypto]")
 
 	for (size_t i = 0; i < 200; ++i)
 	{
-		auto randomNumber =
+		const auto randomNumber =
 		  Utils::Crypto::GetRandomUInt<uint64_t>(0, std::numeric_limits<uint64_t>::max());
 
 		REQUIRE(randomUint64Numbers.find(randomNumber) == randomUint64Numbers.end());

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

@@ -64,12 +64,12 @@ SCENARIO("Utils::Time", "[utils][time]")
 	}
 
 	// Middle 32 bits of the given NTP timestamp.
-	auto toCompactNtp = [](uint32_t seconds, uint32_t fractions) -> uint32_t
+	const 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
+	const auto toTimeUs = [](uint32_t seconds, uint32_t fractions) -> int64_t
 	{
 		return Utils::Time::NtpToTimeUs(Utils::Time::Ntp{ .seconds = seconds, .fractions = fractions });
 	};