mediasoup 3.26.0 → 3.27.0

package/worker/test/src/RTC/RTP/TestPacket.cpp

@@ -1059,16 +1059,16 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		  /*paddingLength*/ 0);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
-		REQUIRE(packet->GetCaptureMs() == std::nullopt);
+		REQUIRE(packet->GetCaptureAtUs() == std::nullopt);
 
 		packet->SetPayloadType(100);
 		packet->SetMarker(true);
 		packet->SetSequenceNumber(12345);
 		packet->SetTimestamp(987654321);
 		packet->SetSsrc(1234567890);
-		packet->SetCaptureMs(99998888);
+		packet->SetCaptureAtUs(99998888);
 
-		REQUIRE(packet->GetCaptureMs() == 99998888);
+		REQUIRE(packet->GetCaptureAtUs() == 99998888);
 
 		std::vector<RTC::RTP::Packet::Extension> extensions;
 
@@ -1208,7 +1208,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(extensionLen == 3);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
-		REQUIRE(packet->GetCaptureMs() == 99998888);
+		REQUIRE(packet->GetCaptureAtUs() == 99998888);
 
 		/* Clone it. */
 
@@ -1257,7 +1257,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(extensionLen == 3);
 
 		REQUIRE(packet->IsPaddedTo4Bytes() == true);
-		REQUIRE(packet->GetCaptureMs() == 99998888);
+		REQUIRE(packet->GetCaptureAtUs() == 99998888);
 
 		/* Set payload. */
 
@@ -1547,12 +1547,12 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(packet->ReadTransportWideCc01(readWideSeqNumber));
 		REQUIRE(readWideSeqNumber == wideSeqNumber);
 
-		std::string newMid{ "mid-®2" };
-		uint64_t newAbsSendtimeMs{ 999999 };
-		uint16_t newWideSeqNumber{ 5556 };
+		const std::string newMid{ "mid-®2" };
+		const int64_t newAbsSendtimeUs{ 999999250 };
+		const uint16_t newWideSeqNumber{ 5556 };
 
 		REQUIRE(packet->UpdateMid(newMid));
-		REQUIRE(packet->UpdateAbsSendTime(newAbsSendtimeMs));
+		REQUIRE(packet->UpdateAbsSendTime(newAbsSendtimeUs));
 		REQUIRE(packet->UpdateTransportWideCc01(newWideSeqNumber));
 
 		REQUIRE(packet->ReadMid(readMid));
@@ -1560,7 +1560,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(packet->ReadRid(readRid));
 		REQUIRE(readRid == rid);
 		REQUIRE(packet->ReadAbsSendTime(readAbsSendtime));
-		REQUIRE(readAbsSendtime == Utils::Time::TimeMsToAbsSendTime(newAbsSendtimeMs));
+		REQUIRE(readAbsSendtime == Utils::Time::TimeUsToAbsSendTime(newAbsSendtimeUs));
 		REQUIRE(packet->ReadTransportWideCc01(readWideSeqNumber));
 		REQUIRE(readWideSeqNumber == newWideSeqNumber);
 
@@ -1587,7 +1587,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 		REQUIRE(packet2->ReadRid(readRid));
 		REQUIRE(readRid == rid);
 		REQUIRE(packet2->ReadAbsSendTime(readAbsSendtime));
-		REQUIRE(readAbsSendtime == Utils::Time::TimeMsToAbsSendTime(newAbsSendtimeMs));
+		REQUIRE(readAbsSendtime == Utils::Time::TimeUsToAbsSendTime(newAbsSendtimeUs));
 		REQUIRE(packet2->ReadTransportWideCc01(readWideSeqNumber));
 		REQUIRE(readWideSeqNumber == newWideSeqNumber);
 	}

package/worker/test/src/RTC/RTP/TestRetransmissionBuffer.cpp

@@ -20,7 +20,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 		};
 
 	public:
-		RtpMyRetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate)
+		RtpMyRetransmissionBuffer(uint16_t maxItems, int64_t maxRetransmissionDelayMs, uint32_t clockRate)
 		  : RTC::RTP::RetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate)
 		{
 		}
@@ -51,7 +51,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 		{
 			REQUIRE(verificationBuffer.size() == this->buffer.size());
 
-			for (size_t idx{ 0u }; idx < verificationBuffer.size(); ++idx)
+			for (size_t idx{ 0 }; idx < verificationBuffer.size(); ++idx)
 			{
 				auto& verificationItem = verificationBuffer.at(idx);
 				auto* item             = this->buffer.at(idx);
@@ -70,7 +70,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("proper packets received in order")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -95,7 +95,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("proper packets received out of order")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -120,7 +120,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("packet with too new sequence number produces buffer emptying")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -142,7 +142,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("blank slots are properly created")
 	{
 		const uint16_t maxItems{ 10 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -180,7 +180,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("packet with too old sequence number is discarded")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -205,7 +205,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("packet with too old timestamp is discarded")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -232,7 +232,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	SECTION("packet with very newest timestamp is inserted as newest item despite its seq is old")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -256,7 +256,7 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 	  "packet with lower seq than newest packet in the buffer and higher timestamp forces buffer emptying")
 	{
 		const uint16_t maxItems{ 4 };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);
@@ -276,8 +276,8 @@ SCENARIO("RTP RetransmissionBuffer", "[rtp][rtx]")
 
 	SECTION("fuzzer generated packets")
 	{
-		const uint16_t maxItems{ 2500u };
-		const uint32_t maxRetransmissionDelayMs{ 2000u };
+		const uint16_t maxItems{ 2500 };
+		const int64_t maxRetransmissionDelayMs{ 2000 };
 		const uint32_t clockRate{ 90000 };
 
 		RtpMyRetransmissionBuffer myRetransmissionBuffer(maxItems, maxRetransmissionDelayMs, clockRate);

package/worker/test/src/RTC/RTP/TestRtpStreamRecv.cpp

@@ -1,4 +1,6 @@
 #include "common.hpp"
+#include "RTC/RTCP/FeedbackPs.hpp"
+#include "RTC/RTCP/FeedbackRtpNack.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
@@ -111,6 +113,11 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 			return 0;
 		}
 
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/) override
+		{
+		}
+
 	public:
 		bool shouldTriggerNack = false;
 		bool shouldTriggerPLI  = false;
@@ -118,10 +125,10 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		std::vector<uint16_t> nackedSeqNumbers;
 	};
 
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 
 	// clang-format off
@@ -158,25 +165,25 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(3);
 		listener.shouldTriggerNack = true;
 		listener.shouldTriggerPLI  = false;
 		listener.shouldTriggerFIR  = false;
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		REQUIRE(listener.nackedSeqNumbers.size() == 1);
 		REQUIRE(listener.nackedSeqNumbers[0] == 2);
 		listener.nackedSeqNumbers.clear();
 
 		packet->SetSequenceNumber(2);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		REQUIRE(listener.nackedSeqNumbers.empty());
 
 		packet->SetSequenceNumber(4);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		REQUIRE(listener.nackedSeqNumbers.empty());
 	}
@@ -188,19 +195,19 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(2);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(3);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(4);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(5);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		// Sequence number 6 arrives via RTX before the original RTP packet.
 
@@ -222,13 +229,13 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(0xfffe);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		packet->SetSequenceNumber(1);
 		listener.shouldTriggerNack = true;
 		listener.shouldTriggerPLI  = false;
 		listener.shouldTriggerFIR  = false;
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		REQUIRE(listener.nackedSeqNumbers.size() == 2);
 		REQUIRE(listener.nackedSeqNumbers[0] == 0xffff);
@@ -243,13 +250,13 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 
 		// Seq different is bigger than MaxNackPackets in NackGenerator, so it
 		// triggers a key frame.
 		packet->SetSequenceNumber(1003);
 		listener.shouldTriggerPLI = true;
 		listener.shouldTriggerFIR = false;
-		rtpStream.ReceivePacket(packet.get());
+		rtpStream.ReceivePacket(packet.get(), shared.GetTimeUs());
 	}
 }

package/worker/test/src/RTC/RTP/TestRtpStreamSend.cpp

@@ -107,10 +107,10 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		packet->SetPayloadDescriptorHandler(payloadDescriptorHandler);
 	};
 
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 
 	// clang-format off
@@ -1129,7 +1129,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 	SECTION("Sender Report RTP timestamp is based on the capture instant when known")
 	{
 		// Instant reported by the mocked clock, and hence the one at which packets are seen.
-		constexpr uint64_t PacketMs{ 1000 };
+		constexpr int64_t PacketAtUs{ 1000 * 1000 };
 		constexpr uint32_t PacketTs{ 1533790901 };
 
 		TestRtpStreamListener testRtpStreamListener;
@@ -1155,7 +1155,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 			  packet.get());
 
 			const std::unique_ptr<RTC::RTCP::SenderReport> report(
-			  stream.GetRtcpSenderReport(PacketMs + 1000));
+			  stream.GetRtcpSenderReport(PacketAtUs + 1000000));
 
 			REQUIRE(report);
 			REQUIRE(report->GetRtpTs() == PacketTs + params.clockRate);
@@ -1167,7 +1167,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 			  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 			auto packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
 
-			packet->SetCaptureMs(PacketMs - 500);
+			packet->SetCaptureAtUs(PacketAtUs - 500000);
 
 			sendRtpPacket(
 			  {
@@ -1176,7 +1176,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 			  packet.get());
 
 			const std::unique_ptr<RTC::RTCP::SenderReport> report(
-			  stream.GetRtcpSenderReport(PacketMs + 1000));
+			  stream.GetRtcpSenderReport(PacketAtUs + 1000000));
 
 			REQUIRE(report);
 			REQUIRE(report->GetRtpTs() == PacketTs + ((1500 * params.clockRate) / 1000));
@@ -1189,7 +1189,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 			  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 			auto packet(createRtpPacket(rtpBuffer1, sizeof(rtpBuffer1), 21006, PacketTs));
 
-			packet->SetCaptureMs(PacketMs + 3000);
+			packet->SetCaptureAtUs(PacketAtUs + 3000000);
 
 			sendRtpPacket(
 			  {
@@ -1198,7 +1198,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 			  packet.get());
 
 			const std::unique_ptr<RTC::RTCP::SenderReport> report(
-			  stream.GetRtcpSenderReport(PacketMs + 1000));
+			  stream.GetRtcpSenderReport(PacketAtUs + 1000000));
 
 			REQUIRE(report);
 			REQUIRE(report->GetRtpTs() == PacketTs);
@@ -1208,7 +1208,7 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 	SECTION("no Sender Report is generated once the stream has stopped sending")
 	{
 		// Instant reported by the mocked clock, and hence the one at which packets are seen.
-		constexpr uint64_t PacketMs{ 1000 };
+		constexpr int64_t PacketAtUs{ 1000 * 1000 };
 		constexpr uint32_t PacketTs{ 1533790901 };
 
 		TestRtpStreamListener testRtpStreamListener;
@@ -1232,14 +1232,14 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		  packet.get());
 
 		// Right at the limit the Sender Report is still generated.
-		const std::unique_ptr<RTC::RTCP::SenderReport> report(
-		  stream.GetRtcpSenderReport(PacketMs + RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs));
+		const std::unique_ptr<RTC::RTCP::SenderReport> report(stream.GetRtcpSenderReport(
+		  PacketAtUs + (RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs * 1000)));
 
 		REQUIRE(report);
 
 		// Past the limit it is not.
 		const std::unique_ptr<RTC::RTCP::SenderReport> staleReport(stream.GetRtcpSenderReport(
-		  PacketMs + RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs + 1));
+		  PacketAtUs + ((RTC::RTP::RtpStreamSend::MaxSenderReportReferenceAgeMs + 1) * 1000)));
 
 		REQUIRE_FALSE(staleReport);
 	}

package/worker/test/src/RTC/SCTP/association/TestAssociation.cpp

@@ -33,8 +33,8 @@
 
 namespace
 {
-	// Initial value of the simulated clock (ms).
-	constexpr uint64_t InitialNowMs{ 1000000 };
+	// Initial value of the simulated clock (us).
+	constexpr int64_t InitialNowUs{ 1000000 * 1000 };
 
 	// All backoff timer labels an SCTP association may create. Used by `runTimers()`
 	// to fire whichever timers have expired after advancing time.
@@ -78,10 +78,10 @@ namespace
 		  bool mayConnectOnReceivedSctpData  = false)
 		  // NOTE: The order in which these members are initialized is **critical**.
 		  : sctpOptions(sctpOptions),
-		    shared(/*getTimeMs*/
-		           [this]()
-		           {
-			           return this->nowMs;
+		    shared(/*getTimeUs*/
+				       [this]() -> int64_t
+				       {
+			           return this->nowUs;
 		           }),
 		    association(
 		      this->sctpOptions,
@@ -94,14 +94,18 @@ namespace
 
 		/**
 		 * Advances the simulated clock of this association by `incrementMs`.
+		 *
+		 * @remarks
+		 * - The increment is given in milliseconds since it comes from the SCTP
+		 *   options and the timers, which work in milliseconds.
 		 */
-		void AdvanceTimeMs(uint64_t incrementMs)
+		void AdvanceTimeMs(int64_t incrementMs)
 		{
-			this->nowMs += incrementMs;
+			this->nowUs += incrementMs * 1000;
 		}
 
 	public:
-		uint64_t nowMs{ InitialNowMs };
+		int64_t nowUs{ InitialNowUs };
 		RTC::SCTP::SctpOptions sctpOptions;
 		mocks::RTC::SCTP::MockAssociationListener listener;
 		mocks::MockShared shared;
@@ -148,7 +152,7 @@ namespace
 
 		REQUIRE(!buffer.empty());
 
-		to.association.ReceiveSctpData(buffer.data(), buffer.size());
+		to.association.ReceiveSctpData(buffer.data(), buffer.size(), to.shared.GetTimeUs());
 	}
 
 	/**
@@ -168,7 +172,7 @@ namespace
 			if (!bufferFromA.empty())
 			{
 				deliveredPacket = true;
-				z.association.ReceiveSctpData(bufferFromA.data(), bufferFromA.size());
+				z.association.ReceiveSctpData(bufferFromA.data(), bufferFromA.size(), z.shared.GetTimeUs());
 			}
 
 			const auto bufferFromZ = z.listener.ConsumeFirstSentPacket();
@@ -176,7 +180,7 @@ namespace
 			if (!bufferFromZ.empty())
 			{
 				deliveredPacket = true;
-				a.association.ReceiveSctpData(bufferFromZ.data(), bufferFromZ.size());
+				a.association.ReceiveSctpData(bufferFromZ.data(), bufferFromZ.size(), a.shared.GetTimeUs());
 			}
 		} while (deliveredPacket);
 	}
@@ -212,7 +216,7 @@ namespace
 	 * Advances the simulated clock of both associations by `durationMs` and fires
 	 * any timer that has expired.
 	 */
-	void advanceTimeMs(AssociationUnderTest& a, AssociationUnderTest& z, uint64_t durationMs)
+	void advanceTimeMs(AssociationUnderTest& a, AssociationUnderTest& z, int64_t durationMs)
 	{
 		a.AdvanceTimeMs(durationMs);
 		z.AdvanceTimeMs(durationMs);
@@ -259,7 +263,7 @@ namespace
 		const uint32_t verificationTag = parsePacket(buffer)->GetVerificationTag();
 
 		// Deliver the COOKIE-ACK so the connection is fully established on A.
-		a.association.ReceiveSctpData(buffer.data(), buffer.size());
+		a.association.ReceiveSctpData(buffer.data(), buffer.size(), a.shared.GetTimeUs());
 
 		REQUIRE(a.association.GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED);
 		REQUIRE(z.association.GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED);
@@ -291,7 +295,8 @@ namespace
 	{
 		packet->WriteCRC32cChecksum();
 
-		target.association.ReceiveSctpData(packet->GetBuffer(), packet->GetLength());
+		target.association.ReceiveSctpData(
+		  packet->GetBuffer(), packet->GetLength(), target.shared.GetTimeUs());
 	}
 
 	/**
@@ -836,7 +841,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		REQUIRE(packetHasSingleChunkOfType<RTC::SCTP::HeartbeatRequestChunk>(buffer) == true);
 
 		// Feed it to Z and expect a HEARTBEAT-ACK that is propagated back to A.
-		z.association.ReceiveSctpData(buffer.data(), buffer.size());
+		z.association.ReceiveSctpData(buffer.data(), buffer.size(), z.shared.GetTimeUs());
 		deliverFirstSentPacket(z, a);
 	}
 
@@ -1282,7 +1287,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		REQUIRE(packetHasSingleChunkOfType<RTC::SCTP::HeartbeatRequestChunk>(bufferA) == true);
 
 		// Z receives the heartbeat and sends an ACK that is propagated back to A.
-		z.association.ReceiveSctpData(bufferA.data(), bufferA.size());
+		z.association.ReceiveSctpData(bufferA.data(), bufferA.size(), z.shared.GetTimeUs());
 		deliverFirstSentPacket(z, a);
 
 		// A little while later, Z should send heartbeats to A.
@@ -1293,7 +1298,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		REQUIRE(packetHasSingleChunkOfType<RTC::SCTP::HeartbeatRequestChunk>(bufferZ) == true);
 
 		// A receives the heartbeat and sends an ACK that is propagated back to Z.
-		a.association.ReceiveSctpData(bufferZ.data(), bufferZ.size());
+		a.association.ReceiveSctpData(bufferZ.data(), bufferZ.size(), a.shared.GetTimeUs());
 		deliverFirstSentPacket(a, z);
 	}
 
@@ -1313,7 +1318,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 
 		const auto maxRetransmissions = a.sctpOptions.maxRetransmissions.value();
 
-		uint64_t timeToNextHeartbeatMs = a.sctpOptions.heartbeatIntervalMs;
+		int64_t timeToNextHeartbeatMs = a.sctpOptions.heartbeatIntervalMs;
 
 		for (size_t i = 0; i < maxRetransmissions; ++i)
 		{
@@ -1362,7 +1367,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 
 		const auto maxRetransmissions = a.sctpOptions.maxRetransmissions.value();
 
-		uint64_t timeToNextHeartbeatMs = a.sctpOptions.heartbeatIntervalMs;
+		int64_t timeToNextHeartbeatMs = a.sctpOptions.heartbeatIntervalMs;
 
 		for (size_t i = 0; i < maxRetransmissions; ++i)
 		{
@@ -1384,7 +1389,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 
 		REQUIRE(packetHasSingleChunkOfType<RTC::SCTP::HeartbeatRequestChunk>(buffer) == true);
 
-		z.association.ReceiveSctpData(buffer.data(), buffer.size());
+		z.association.ReceiveSctpData(buffer.data(), buffer.size(), z.shared.GetTimeUs());
 		// A reads the HEARTBEAT-ACK, which clears the error counter.
 		deliverFirstSentPacket(z, a);
 
@@ -1890,7 +1895,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 
 		// Make the cookie stale on Z's side by advancing its clock beyond the cookie
 		// lifespan before the COOKIE-ECHO is delivered.
-		z.AdvanceTimeMs(RTC::SCTP::StateCookie::ValidCookieLifeMs + 1000);
+		z.AdvanceTimeMs((RTC::SCTP::StateCookie::ValidCookieLifeUs / 1000) + 1000);
 
 		// Z reads the now stale COOKIE-ECHO.
 		deliverFirstSentPacket(a, z);

package/worker/test/src/RTC/SCTP/association/TestHeartbeatHandler.cpp

@@ -18,13 +18,13 @@
 
 SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 {
-	constexpr uint64_t InitialNowMs{ 1000000 };
-	constexpr uint64_t HeartbeatIntervalMs{ 30000 };
+	constexpr int64_t InitialNowUs{ 1000000 * 1000 };
+	constexpr int64_t HeartbeatIntervalMs{ 30000 };
 
 	class TestHeartbeatHandler
 	{
 	public:
-		explicit TestHeartbeatHandler(uint64_t heartbeatIntervalMs)
+		explicit TestHeartbeatHandler(int64_t heartbeatIntervalMs)
 		  // NOTE: The order in which these members are initialized is **critical**.
 		  : sctpOptions(
 		      RTC::SCTP::SctpOptions{
@@ -33,10 +33,10 @@ SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 		        .zeroChecksumAlternateErrorDetectionMethod =
 		          RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE }),
 		    tcbContext(this->associationListener, this->sctpOptions),
-		    shared(/*getTimeMs*/
-		           [this]()
-		           {
-			           return this->nowMs;
+		    shared(/*getTimeUs*/
+				       [this]() -> int64_t
+				       {
+			           return this->nowUs;
 		           }),
 		    heartbeatHandler(
 		      this->associationListenerDeferrer,
@@ -49,13 +49,18 @@ SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 		};
 
 	public:
+		/**
+		 * @remarks
+		 * - The increment is given in milliseconds since it comes from the SCTP
+		 *   options and the timers, which work in milliseconds.
+		 */
 		void AdvanceTimeMs(int64_t incrementMs)
 		{
-			this->nowMs += incrementMs;
+			this->nowUs += incrementMs * 1000;
 		}
 
 	private:
-		uint64_t nowMs{ InitialNowMs };
+		int64_t nowUs{ InitialNowUs };
 
 		// NOTE: Public members for testing.
 	public:
@@ -185,9 +190,10 @@ SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 		receivedHeartbeatInfoParameter->Consolidate();
 
 		// Respond a while later.
-		const uint64_t rttMs{ 313 };
+		const int64_t rttMs{ 313 };
 
-		test.tcbContext.ExpectObserveRttMsCalledTimes(1);
+		test.tcbContext.ExpectObserveRttUsCalledTimes(1).ExpectObserveRttUsCalledWith(
+		  static_cast<int64_t>(rttMs * 1000));
 
 		test.AdvanceTimeMs(rttMs);
 		test.heartbeatHandler.HandleReceivedHeartbeatAckChunk(receivedHeartbeatAckChunk.get());
@@ -237,7 +243,7 @@ SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 		  sentHeartbeatInfoParameter->GetInfo(), sentHeartbeatInfoParameter->GetInfoLength());
 		receivedHeartbeatInfoParameter->Consolidate();
 
-		test.tcbContext.ExpectObserveRttMsCalledTimes(0);
+		test.tcbContext.ExpectObserveRttUsCalledTimes(0);
 
 		// Go backwards in time to make the HEARTBEAT-ACK have an invalid timestamp
 		// in it, as it will be in the future.
@@ -251,12 +257,12 @@ SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
 	{
 		TestHeartbeatHandler test(HeartbeatIntervalMs);
 
-		const uint64_t rtoMs{ 105 };
+		const int64_t rtoMs{ 105 };
 
-		test.tcbContext.WillGetCurrentRtoMsOnce(
+		test.tcbContext.WillGetCurrentRtoUsOnce(
 		  []()
 		  {
-			  return rtoMs;
+			  return static_cast<int64_t>(rtoMs * 1000);
 		  });
 
 		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);

package/worker/test/src/RTC/SCTP/association/TestStateCookie.cpp

@@ -614,9 +614,9 @@ SCENARIO("SCTP State Cookie", "[sctp][statecookie]")
 			  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE
 		};
 
-		const uint8_t macKey[]             = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-			                                     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
-		const uint64_t creationTimestampMs = 1234567890;
+		const uint8_t macKey[]            = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+		                                      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+		const int64_t creationTimestampUs = 1234567890;
 
 		auto* buffer = sctpCommon::FactoryBuffer;
 
@@ -630,7 +630,7 @@ SCENARIO("SCTP State Cookie", "[sctp][statecookie]")
 		  /*remoteAdvertisedReceiverWindowCredit*/ 999909999,
 		  /*tieTag*/ 1111222233334444,
 		  remoteCapabilities,
-		  /*creationTimestampMs*/ creationTimestampMs,
+		  /*creationTimestampUs*/ creationTimestampUs,
 		  /*macKey*/ macKey,
 		  /*macKeyLength*/ sizeof(macKey));
 
@@ -648,7 +648,7 @@ SCENARIO("SCTP State Cookie", "[sctp][statecookie]")
 		REQUIRE(stateCookie);
 		REQUIRE(stateCookie->GetLength() == RTC::SCTP::StateCookie::AuthenticatedStateCookieLength);
 		REQUIRE(stateCookie->IsAuthenticated() == true);
-		REQUIRE(stateCookie->GetCreationTimestampMs() == creationTimestampMs);
+		REQUIRE(stateCookie->GetCreationTimestampUs() == creationTimestampUs);
 		REQUIRE(stateCookie->GetLocalVerificationTag() == 6660666);
 		REQUIRE(stateCookie->GetRemoteVerificationTag() == 9990999);
 
@@ -662,7 +662,7 @@ SCENARIO("SCTP State Cookie", "[sctp][statecookie]")
 		/* The MAC must NOT verify with a wrong key. */
 
 		const uint8_t wrongMacKey[] = { 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88,
-			                              0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00 };
+		                                0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00 };
 
 		REQUIRE(
 		  RTC::SCTP::StateCookie::VerifyMac(