mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/SCTP/association/AssociationListenerDeferrer.cpp

@@ -196,7 +196,7 @@ namespace RTC
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationStreamsResetPerformed(streamReset.streamIds);
-      },
+			},
 			  StreamReset{ .streamIds = { outboundStreamIds.begin(), outboundStreamIds.end() } });
 		}
 
@@ -212,9 +212,9 @@ namespace RTC
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationStreamsResetFailed(streamReset.streamIds, streamReset.errorMessage);
-      },
+			},
 			  StreamReset{ .streamIds    = { outboundStreamIds.begin(), outboundStreamIds.end() },
-			               .errorMessage = std::string(errorMessage) });
+				             .errorMessage = std::string(errorMessage) });
 		}
 
 		void AssociationListenerDeferrer::OnAssociationInboundStreamsReset(
@@ -229,7 +229,7 @@ namespace RTC
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationInboundStreamsReset(streamReset.streamIds);
-      },
+			},
 			  StreamReset{ .streamIds = { inboundStreamIds.begin(), inboundStreamIds.end() } });
 		}
 

package/worker/src/RTC/SCTP/association/Capabilities.cpp

@@ -35,7 +35,7 @@ namespace RTC
 			capabilities.partialReliability =
 			  remoteForwardTsnSupportedParameter ||
 			  (remoteSupportedExtensionsParameter &&
-			   remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::FORWARD_TSN));
+				 remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::FORWARD_TSN));
 
 			// Remote announces Message Interleaving support via Supported Extensions
 			// parameter.

package/worker/src/RTC/SCTP/association/HeartbeatHandler.cpp

@@ -71,8 +71,9 @@ namespace RTC
 
 			if (intervalDurationShouldIncludeRtt)
 			{
+				// NOTE: The timer takes milliseconds, so the RTO is truncated here.
 				this->intervalTimer->SetBaseTimeoutMs(
-				  this->intervalDurationMs + this->tcbContext->GetCurrentRtoMs());
+				  this->intervalDurationMs + (this->tcbContext->GetCurrentRtoUs() / 1000));
 			}
 			else
 			{
@@ -149,24 +150,27 @@ namespace RTC
 				return;
 			}
 
-			const uint64_t createdAtMs = Utils::Byte::Get8Bytes(info, 0);
-			const uint64_t nowMs       = this->shared->GetTimeMs();
+			// NOTE: The peer echoes back the info we wrote, so this value cannot be
+			// trusted. The guard below rejects it unless it's a past instant, which
+			// also rejects a negative resulting from garbage above 2^63.
+			const auto createdAtUs = static_cast<int64_t>(Utils::Byte::Get8Bytes(info, 0));
+			const int64_t nowUs    = this->shared->GetTimeUs();
 
-			if (createdAtMs > 0 && createdAtMs <= nowMs)
+			if (createdAtUs > 0 && createdAtUs <= nowUs)
 			{
-				const uint64_t rttMs = nowMs - createdAtMs;
+				const int64_t rttUs = nowUs - createdAtUs;
 
-				MS_DEBUG_DEV("valid HEARTBEAT-ACK chunk received, calling ObserveRttMs(%" PRIu64 ")", rttMs);
+				MS_DEBUG_DEV("valid HEARTBEAT-ACK chunk received, calling ObserveRttUs(%" PRIi64 ")", rttUs);
 
-				this->tcbContext->ObserveRttMs(rttMs);
+				this->tcbContext->ObserveRttUs(rttUs);
 			}
 			else
 			{
 				MS_WARN_DEV(
-				  "ignoring received HEARTBEAT-ACK chunk with invalid info content [createdAtMs:%" PRIu64
-				  ", nowMs:%" PRIu64 "]",
-				  createdAtMs,
-				  nowMs);
+				  "ignoring received HEARTBEAT-ACK chunk with invalid info content [createdAtUs:%" PRIi64
+				  ", nowUs:%" PRIi64 "]",
+				  createdAtUs,
+				  nowUs);
 			}
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-8.1
@@ -176,7 +180,7 @@ namespace RTC
 			this->tcbContext->ClearTxErrorCounter();
 		}
 
-		void HeartbeatHandler::OnIntervalTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void HeartbeatHandler::OnIntervalTimer(int64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();
 
@@ -204,14 +208,17 @@ namespace RTC
 				return;
 			}
 
-			this->timeoutTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+			// NOTE: The timer takes milliseconds, so the RTO is truncated here.
+			this->timeoutTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoUs() / 1000);
 			this->timeoutTimer->Start();
 
 			alignas(8) uint8_t info[HeartbeatInfoLength];
 
-			const uint64_t nowMs = this->shared->GetTimeMs();
+			// NOTE: This is read back in HandleReceivedHeartbeatAckChunk() when the
+			// peer echoes it, so both sides of it must use the same unit.
+			const int64_t nowUs = this->shared->GetTimeUs();
 
-			Utils::Byte::Set8Bytes(info, 0, nowMs);
+			Utils::Byte::Set8Bytes(info, 0, static_cast<uint64_t>(nowUs));
 
 			auto packet                 = this->tcbContext->CreatePacket();
 			auto* heartbeatRequestChunk = packet->BuildChunkInPlace<HeartbeatRequestChunk>();
@@ -222,12 +229,12 @@ namespace RTC
 			heartbeatInfoParameter->Consolidate();
 			heartbeatRequestChunk->Consolidate();
 
-			MS_DEBUG_DEV("sending HEARTBEAT-REQUEST chunk with info content [nowMs:%" PRIu64 "]", nowMs);
+			MS_DEBUG_DEV("sending HEARTBEAT-REQUEST chunk with info content [nowUs:%" PRIi64 "]", nowUs);
 
 			this->tcbContext->SendPacket(packet.get());
 		}
 
-		void HeartbeatHandler::OnTimeoutTimer(uint64_t& /*baseTimeoutMs*/, bool& stop)
+		void HeartbeatHandler::OnTimeoutTimer(int64_t& /*baseTimeoutMs*/, bool& stop)
 		{
 			MS_TRACE();
 
@@ -261,7 +268,7 @@ namespace RTC
 		}
 
 		void HeartbeatHandler::OnBackoffTimer(
-		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 

package/worker/src/RTC/SCTP/association/StateCookie.cpp

@@ -49,7 +49,7 @@ namespace RTC
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
 		  const Capabilities& remoteCapabilities,
-		  uint64_t creationTimestampMs,
+		  int64_t creationTimestampUs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
 		{
@@ -66,7 +66,7 @@ namespace RTC
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
 			  remoteCapabilities,
-			  creationTimestampMs,
+			  creationTimestampUs,
 			  macKey,
 			  macKeyLength);
 
@@ -86,7 +86,7 @@ namespace RTC
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
 		  const Capabilities& remoteCapabilities,
-		  uint64_t creationTimestampMs,
+		  int64_t creationTimestampUs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
 		{
@@ -132,7 +132,8 @@ namespace RTC
 			// bytes (including the timestamp).
 			//
 			// @see RFC 9260 section 5.1.3.
-			Utils::Byte::Set8Bytes(buffer, StateCookie::TimestampOffset, creationTimestampMs);
+			Utils::Byte::Set8Bytes(
+			  buffer, StateCookie::TimestampOffset, static_cast<uint64_t>(creationTimestampUs));
 
 			const uint8_t* mac = Utils::Crypto::GetHmacSha1(
 			  reinterpret_cast<const char*>(macKey), macKeyLength, buffer, StateCookie::MacOffset);
@@ -228,7 +229,7 @@ namespace RTC
 			SetLength(
 			  bufferLength == StateCookie::AuthenticatedStateCookieLength
 			    ? StateCookie::AuthenticatedStateCookieLength
-			    : StateCookie::StateCookieLength);
+					: StateCookie::StateCookieLength);
 		}
 
 		StateCookie::~StateCookie()
@@ -258,7 +259,7 @@ namespace RTC
 
 			if (IsAuthenticated())
 			{
-				MS_DUMP_CLEAN(indentation, "  creation timestamp (ms): %" PRIu64, GetCreationTimestampMs());
+				MS_DUMP_CLEAN(indentation, "  creation timestamp (us): %" PRIi64, GetCreationTimestampUs());
 			}
 
 			MS_DUMP_CLEAN(indentation, "  remote capabilities:");

package/worker/src/RTC/SCTP/association/StreamResetHandler.cpp

@@ -77,7 +77,8 @@ namespace RTC
 			  this->retransmissionQueue->GetLastAssignedTsn(),
 			  this->retransmissionQueue->BeginResetStreams());
 
-			this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+			// NOTE: The timer takes milliseconds, so the RTO is truncated here.
+			this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoUs() / 1000);
 			this->reConfigTimer->Start();
 
 			AddReConfigChunk(packet);
@@ -168,21 +169,21 @@ namespace RTC
 
 				if (
 				  (firstParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST &&
-				   secondParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST) ||
+					 secondParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST &&
-				   secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
+					 secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST &&
-				   secondParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST) ||
+					 secondParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST &&
-				   secondParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST) ||
+					 secondParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
-				   secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
+					 secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST &&
-				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
+					 secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
-				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
+					 secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
 				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
-				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE))
+					 secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE))
 				{
 					return true;
 				}
@@ -435,7 +436,8 @@ namespace RTC
 						// Force this request to be sent again, but with the same `reqSeqNbr`.
 						this->currentRequest->SetDeferred(true);
 
-						this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+						// NOTE: The timer takes milliseconds, so the RTO is truncated here.
+						this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoUs() / 1000);
 						this->reConfigTimer->Start();
 
 						break;
@@ -469,7 +471,7 @@ namespace RTC
 			}
 		}
 
-		void StreamResetHandler::OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop)
+		void StreamResetHandler::OnReConfigTimer(int64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
@@ -520,11 +522,12 @@ namespace RTC
 
 			this->tcbContext->SendPacket(packet.get());
 
-			baseTimeoutMs = this->tcbContext->GetCurrentRtoMs();
+			// NOTE: The timer takes milliseconds, so the RTO is truncated here.
+			baseTimeoutMs = this->tcbContext->GetCurrentRtoUs() / 1000;
 		}
 
 		void StreamResetHandler::OnBackoffTimer(
-		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 

package/worker/src/RTC/SCTP/association/TransmissionControlBlock.cpp

@@ -125,27 +125,31 @@ namespace RTC
 			MS_DUMP_CLEAN(indentation, "</SCTP::TransmissionControlBlock>");
 		}
 
-		void TransmissionControlBlock::ObserveRttMs(uint64_t rttMs)
+		void TransmissionControlBlock::ObserveRttUs(int64_t rttUs)
 		{
 			MS_TRACE();
 
 #if MS_LOG_DEV_LEVEL == 3
-			const auto prevRtoMs = this->rto.GetRtoMs();
+			const auto prevRtoUs = this->rto.GetRtoUs();
 #endif
 
-			this->rto.ObserveRttMs(rttMs);
+			this->rto.ObserveRttUs(rttUs);
 
 			MS_DEBUG_DEV(
-			  "new rtt:%" PRIu64 ", previous rto:%" PRIu64 ", new rto:%" PRIu64 ", srtt:%" PRIu64,
-			  rttMs,
-			  prevRtoMs,
-			  this->rto.GetRtoMs(),
-			  this->rto.GetSrttMs());
+			  "new rtt:%" PRIi64 " us, previous rto:%" PRIi64 " us, new rto:%" PRIi64 " us, srtt:%" PRIi64
+			  " us",
+			  rttUs,
+			  prevRtoUs,
+			  this->rto.GetRtoUs(),
+			  this->rto.GetSrttUs());
 
-			this->t3RtxTimer->SetBaseTimeoutMs(this->rto.GetRtoMs());
+			// NOTE: The timers take milliseconds, so the RTO is truncated here. It is
+			// hundreds of milliseconds long, so the sub-millisecond part is noise.
+			this->t3RtxTimer->SetBaseTimeoutMs(this->rto.GetRtoUs() / 1000);
 
-			const uint64_t delayedAckTimeoutMs = std::min(
-			  static_cast<uint64_t>(this->rto.GetRtoMs() * 0.5), this->sctpOptions.delayedAckMaxTimeoutMs);
+			const int64_t delayedAckTimeoutMs = std::min(
+			  static_cast<int64_t>((this->rto.GetRtoUs() * 0.5) / 1000),
+			  this->sctpOptions.delayedAckMaxTimeoutMs);
 
 			this->delayedAckTimer->SetBaseTimeoutMs(delayedAckTimeoutMs);
 		}
@@ -211,11 +215,11 @@ namespace RTC
 			SendPacket(packet.get());
 		}
 
-		void TransmissionControlBlock::MayAddForwardTsnChunk(Packet* packet, uint64_t nowMs)
+		void TransmissionControlBlock::MayAddForwardTsnChunk(Packet* packet, int64_t nowUs)
 		{
 			MS_TRACE();
 
-			if (nowMs >= this->limitForwardTsnUntilMs && this->retransmissionQueue.ShouldSendForwardTsn(nowMs))
+			if (nowUs >= this->limitForwardTsnUntilUs && this->retransmissionQueue.ShouldSendForwardTsn(nowUs))
 			{
 				if (this->negotiatedCapabilities.messageInterleaving)
 				{
@@ -233,7 +237,7 @@ namespace RTC
 				// before sending a duplicate FORWARD TSN."
 				// "Any delay applied to the sending of FORWARD TSN chunk SHOULD NOT
 				// exceed 200ms and MUST NOT exceed 500ms".
-				this->limitForwardTsnUntilMs = nowMs + std::min(uint64_t{ 200 }, this->rto.GetSrttMs());
+				this->limitForwardTsnUntilUs = nowUs + std::min(int64_t{ 200 * 1000 }, this->rto.GetSrttUs());
 			}
 		}
 
@@ -284,7 +288,7 @@ namespace RTC
 			SendPacket(packet.get());
 		}
 
-		void TransmissionControlBlock::SendBufferedPackets(uint64_t nowMs, bool addCookieAckChunk)
+		void TransmissionControlBlock::SendBufferedPackets(int64_t nowUs, bool addCookieAckChunk)
 		{
 			MS_TRACE();
 
@@ -338,9 +342,7 @@ namespace RTC
 						  packet.get(), this->reassemblyQueue.GetRemainingBytes());
 					}
 
-					const uint64_t nowMs = this->shared->GetTimeMs();
-
-					MayAddForwardTsnChunk(packet.get(), nowMs);
+					MayAddForwardTsnChunk(packet.get(), nowUs);
 
 					if (this->streamResetHandler.ShouldSendStreamResetRequest())
 					{
@@ -349,7 +351,7 @@ namespace RTC
 				}
 
 				auto chunksToSend =
-				  this->retransmissionQueue.GetChunksToSend(nowMs, packet->GetAvailableLength());
+				  this->retransmissionQueue.GetChunksToSend(nowUs, packet->GetAvailableLength());
 
 				if (!chunksToSend.empty())
 				{
@@ -409,7 +411,7 @@ namespace RTC
 			}
 		}
 
-		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& stop)
+		void TransmissionControlBlock::OnT3RtxTimer(int64_t& /*baseTimeoutMs*/, bool& stop)
 		{
 			MS_TRACE();
 
@@ -439,9 +441,9 @@ namespace RTC
 				{
 					this->retransmissionQueue.HandleT3RtxTimerExpiry();
 
-					const uint64_t nowMs = this->shared->GetTimeMs();
+					const int64_t nowUs = this->shared->GetTimeUs();
 
-					SendBufferedPackets(nowMs);
+					SendBufferedPackets(nowUs);
 				}
 				else
 				{
@@ -455,7 +457,7 @@ namespace RTC
 			}
 		}
 
-		void TransmissionControlBlock::OnDelayedAckTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void TransmissionControlBlock::OnDelayedAckTimer(int64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();
 
@@ -482,7 +484,7 @@ namespace RTC
 		}
 
 		void TransmissionControlBlock::OnBackoffTimer(
-		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
@@ -496,11 +498,11 @@ namespace RTC
 			}
 		}
 
-		void TransmissionControlBlock::OnRetransmissionQueueNewRttMs(uint64_t newRttMs)
+		void TransmissionControlBlock::OnRetransmissionQueueNewRttUs(int64_t newRttUs)
 		{
 			MS_TRACE();
 
-			ObserveRttMs(newRttMs);
+			ObserveRttUs(newRttUs);
 		}
 
 		void TransmissionControlBlock::OnRetransmissionQueueClearRetransmissionCounter()

package/worker/src/RTC/SCTP/packet/chunks/SackChunk.cpp

@@ -5,7 +5,6 @@
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include <cstring> // std::memmove()
-#include <ranges>
 
 namespace RTC
 {

package/worker/src/RTC/SCTP/packet/parameters/StateCookieParameter.cpp

@@ -123,7 +123,7 @@ namespace RTC
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
 		  const Capabilities& remoteCapabilities,
-		  uint64_t creationTimestampMs,
+		  int64_t creationTimestampUs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
 		{
@@ -148,7 +148,7 @@ namespace RTC
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
 			  remoteCapabilities,
-			  creationTimestampMs,
+			  creationTimestampUs,
 			  macKey,
 			  macKeyLength);
 

package/worker/src/RTC/SCTP/public/AssociationMetrics.cpp

@@ -24,7 +24,7 @@ namespace RTC
 			MS_DUMP_CLEAN(indentation, "  rtx packets count: %" PRIu64, this->rtxPacketsCount);
 			MS_DUMP_CLEAN(indentation, "  rtx bytes count: %" PRIu64, this->rtxBytesCount);
 			MS_DUMP_CLEAN(indentation, "  current congestion window (bytes): %zu", this->cwndBytes);
-			MS_DUMP_CLEAN(indentation, "  smoothed round trip time (ms): %" PRIu64, this->srttMs);
+			MS_DUMP_CLEAN(indentation, "  smoothed round trip time (ms): %" PRIi64, this->srttMs);
 			MS_DUMP_CLEAN(indentation, "  unacked data count: %zu", this->unackDataCount);
 			MS_DUMP_CLEAN(
 			  indentation, "  peer's last announced receiver window size: %" PRIu32, this->peerRwndBytes);

package/worker/src/RTC/SCTP/public/SctpOptions.cpp

@@ -34,23 +34,23 @@ namespace RTC
 			  "  total buffered amount low threshold: %zu",
 			  this->totalBufferedAmountLowThreshold);
 			MS_DUMP_CLEAN(indentation, "  default stream priority: %" PRIu16, this->defaultStreamPriority);
-			MS_DUMP_CLEAN(indentation, "  max rtt (ms): %" PRIu64, this->maxRttMs);
-			MS_DUMP_CLEAN(indentation, "  initial rto (ms): %" PRIu64, this->initialRtoMs);
-			MS_DUMP_CLEAN(indentation, "  min rto (ms): %" PRIu64, this->minRtoMs);
-			MS_DUMP_CLEAN(indentation, "  max rto (ms): %" PRIu64, this->maxRtoMs);
-			MS_DUMP_CLEAN(indentation, "  t1-init timeout (ms): %" PRIu64, this->t1InitTimeoutMs);
-			MS_DUMP_CLEAN(indentation, "  t1-cookie timeout (ms): %" PRIu64, this->t1CookieTimeoutMs);
-			MS_DUMP_CLEAN(indentation, "  t2-shutdown timeout (ms): %" PRIu64, this->t2ShutdownTimeoutMs);
+			MS_DUMP_CLEAN(indentation, "  max rtt (ms): %" PRIi64, this->maxRttMs);
+			MS_DUMP_CLEAN(indentation, "  initial rto (ms): %" PRIi64, this->initialRtoMs);
+			MS_DUMP_CLEAN(indentation, "  min rto (ms): %" PRIi64, this->minRtoMs);
+			MS_DUMP_CLEAN(indentation, "  max rto (ms): %" PRIi64, this->maxRtoMs);
+			MS_DUMP_CLEAN(indentation, "  t1-init timeout (ms): %" PRIi64, this->t1InitTimeoutMs);
+			MS_DUMP_CLEAN(indentation, "  t1-cookie timeout (ms): %" PRIi64, this->t1CookieTimeoutMs);
+			MS_DUMP_CLEAN(indentation, "  t2-shutdown timeout (ms): %" PRIi64, this->t2ShutdownTimeoutMs);
 			MS_DUMP_CLEAN(
 			  indentation,
 			  "  timer max backoff timeout (ms): %s",
 			  this->timerMaxBackoffTimeoutMs
 			    ? std::to_string(this->timerMaxBackoffTimeoutMs.value()).c_str()
-			    : "Infinite");
-			MS_DUMP_CLEAN(indentation, "  heartbeat interval (ms): %" PRIu64, this->heartbeatIntervalMs);
+					: "Infinite");
+			MS_DUMP_CLEAN(indentation, "  heartbeat interval (ms): %" PRIi64, this->heartbeatIntervalMs);
 			MS_DUMP_CLEAN(
-			  indentation, "  delayed ack max timeout (ms): %" PRIu64, this->delayedAckMaxTimeoutMs);
-			MS_DUMP_CLEAN(indentation, "  min rtt variance (ms): %" PRIu64, this->minRttVarianceMs);
+			  indentation, "  delayed ack max timeout (ms): %" PRIi64, this->delayedAckMaxTimeoutMs);
+			MS_DUMP_CLEAN(indentation, "  min rtt variance (ms): %" PRIi64, this->minRttVarianceMs);
 			MS_DUMP_CLEAN(indentation, "  initial cwnd mtus: %zu", this->initialCwndMtus);
 			MS_DUMP_CLEAN(indentation, "  min cwnd mtus: %zu", this->minCwndMtus);
 			MS_DUMP_CLEAN(
@@ -62,12 +62,12 @@ namespace RTC
 			  indentation,
 			  "  max retransmissions: %s",
 			  this->maxRetransmissions ? std::to_string(this->maxRetransmissions.value()).c_str()
-			                           : "Infinite");
+				                         : "Infinite");
 			MS_DUMP_CLEAN(
 			  indentation,
 			  "  max init retransmissions: %s",
 			  this->maxInitRetransmissions ? std::to_string(this->maxInitRetransmissions.value()).c_str()
-			                               : "Infinite");
+				                             : "Infinite");
 			MS_DUMP_CLEAN(
 			  indentation, "  enable partial reliability: %s", this->enablePartialReliability ? "yes" : "no");
 			MS_DUMP_CLEAN(

package/worker/src/RTC/SCTP/rx/DataTracker.cpp

@@ -256,7 +256,7 @@ namespace RTC
 			if (
 			  this->ackState == AckState::IMMEDIATE ||
 			  (alsoIfDelayed &&
-			   (this->ackState == AckState::BECOMING_DELAYED || this->ackState == AckState::DELAYED)))
+				 (this->ackState == AckState::BECOMING_DELAYED || this->ackState == AckState::DELAYED)))
 			{
 				UpdateAckState(AckState::IDLE, "should send SACK");
 

package/worker/src/RTC/SCTP/rx/ReassemblyQueue.cpp

@@ -41,9 +41,9 @@ namespace RTC
 			  data.GetMessageId(),
 			  data.GetFragmentSequenceNumber(),
 			  (data.IsBeginning() && data.IsEnd() ? "complete"
-			   : data.IsBeginning()               ? "first"
-			   : data.IsEnd()                     ? "last"
-			                                      : "middle"));
+				 : data.IsBeginning()               ? "first"
+				 : data.IsEnd()                     ? "last"
+				                                    : "middle"));
 
 			const Types::UnwrappedTsn unwrappedTsn = this->tsnUnwrapper.Unwrap(tsn);
 
@@ -144,8 +144,8 @@ namespace RTC
 
 				this->deferredResetStreams->deferredActions.emplace_back(
 				  [this,
-				   newCumulativeTsn,
-				   skippedStreams2 = std::vector<AnyForwardTsnChunk::SkippedStream>(
+					 newCumulativeTsn,
+					 skippedStreams2 = std::vector<AnyForwardTsnChunk::SkippedStream>(
 				     skippedStreams.begin(), skippedStreams.end())]
 				  {
 					  this->queuedBytes -= ForwardTsnCost(skippedStreams2.size());

package/worker/src/RTC/SCTP/tx/OutstandingData.cpp

@@ -24,15 +24,15 @@ namespace RTC
 		OutstandingData::Item::Item(
 		  uint32_t outgoingMessageId,
 		  UserData data,
-		  uint64_t timeSentMs,
+		  int64_t timeSentUs,
 		  uint16_t maxRetransmissions,
-		  uint64_t expiresAtMs,
+		  int64_t expiresAtUs,
 		  std::optional<uint64_t> lifecycleId)
 		  : outgoingMessageId(outgoingMessageId),
 		    data(std::move(data)),
-		    timeSentMs(timeSentMs),
+		    timeSentUs(timeSentUs),
 		    maxRetransmissions(maxRetransmissions),
-		    expiresAtMs(expiresAtMs),
+		    expiresAtUs(expiresAtUs),
 		    lifecycleId(lifecycleId)
 		{
 			MS_TRACE();
@@ -90,7 +90,7 @@ namespace RTC
 			MS_TRACE();
 
 			MS_ASSERT(
-			  this->expiresAtMs != Types::ExpiresAtMsInfinite ||
+			  this->expiresAtUs != Types::ExpiresAtUsInfinite ||
 			    this->maxRetransmissions != Types::MaxRetransmitsNoLimit,
 			  "item should not have infinite expiration time or its retransmission times shouldn't be the maximum");
 
@@ -173,7 +173,7 @@ namespace RTC
 			return ExtractChunksThatCanFit(this->toBeRetransmitted, maxLength);
 		}
 
-		void OutstandingData::ExpireOutstandingChunks(uint64_t nowMs)
+		void OutstandingData::ExpireOutstandingChunks(int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -192,7 +192,7 @@ namespace RTC
 				{
 					// Already abandoned.
 				}
-				else if (item.IsNacked() && item.HasExpired(nowMs))
+				else if (item.IsNacked() && item.HasExpired(nowUs))
 				{
 					tsnsToExpire.push_back(tsn);
 				}
@@ -232,9 +232,9 @@ namespace RTC
 		std::optional<Types::UnwrappedTsn> OutstandingData::Insert(
 		  uint32_t outgoingMessageId,
 		  const UserData& data,
-		  uint64_t timeSentMs,
+		  int64_t timeSentUs,
 		  uint16_t maxRetransmissions,
-		  uint64_t expiresAtMs,
+		  int64_t expiresAtUs,
 		  std::optional<uint64_t> lifecycleId)
 		{
 			MS_TRACE();
@@ -248,9 +248,9 @@ namespace RTC
 
 			const Types::UnwrappedTsn tsn = GetNextTsn();
 			const Item& item              = this->outstandingData.emplace_back(
-			  outgoingMessageId, data.Clone(), timeSentMs, maxRetransmissions, expiresAtMs, lifecycleId);
+			  outgoingMessageId, data.Clone(), timeSentUs, maxRetransmissions, expiresAtUs, lifecycleId);
 
-			if (item.HasExpired(timeSentMs))
+			if (item.HasExpired(timeSentUs))
 			{
 				// No need to send it, it was expired when it was in the send queue.
 				MS_WARN_TAG(
@@ -390,7 +390,7 @@ namespace RTC
 			return iForwardTsnChunk;
 		}
 
-		std::optional<uint64_t> OutstandingData::MeasureRtt(uint64_t nowMs, Types::UnwrappedTsn tsn) const
+		std::optional<int64_t> OutstandingData::MeasureRttUs(int64_t nowUs, Types::UnwrappedTsn tsn) const
 		{
 			MS_TRACE();
 
@@ -406,7 +406,7 @@ namespace RTC
 					// that were retransmitted (and thus for which it is ambiguous
 					// whether the reply was for the first instance of the Chunk or for a
 					// later instance)"
-					return nowMs - item.GetTimeSentMs();
+					return nowUs - item.GetTimeSentUs();
 				}
 			}
 
@@ -772,9 +772,9 @@ namespace RTC
 				Item& addedItem = this->outstandingData.emplace_back(
 				  item.GetOutgoingMessageId(),
 				  std::move(messageEnd),
-				  /*timeSentMs*/ 0,
+				  /*timeSentUs*/ 0,
 				  /*maxRetransmissions*/ 0,
-				  /*expiresAtMs*/ Types::ExpiresAtMsInfinite,
+				  /*expiresAtUs*/ Types::ExpiresAtUsInfinite,
 				  /*lifecycleId*/ std::nullopt);
 
 				// The added chunk shouldn't be included in `this->unackedPacketBytes`,