mediasoup 3.26.0 → 3.27.1

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);
@@ -142,6 +143,63 @@ namespace RTC
 			}
 		}
 
+		bool StreamResetHandler::MayLeaveDeferredReset()
+		{
+			MS_TRACE();
+
+			if (!this->deferredIncomingRequest.has_value())
+			{
+				return false;
+			}
+
+			// https://tools.ietf.org/html/rfc6525#section-5.2.2
+			//
+			// "In this mode, any data arriving with a TSN larger than the Sender's
+			// Last Assigned TSN for the affected stream(s) MUST be queued locally and
+			// held until the cumulative acknowledgment point reaches the Sender's Last
+			// Assigned TSN."
+			//
+			// So deferred reset processing must end as soon as the cumulative ack TSN
+			// reaches the sender's last assigned TSN. Otherwise the queued data would
+			// be held (and accounted for) until the peer decides to retransmit its
+			// request, which it may never do.
+			if (this->dataTracker->IsLaterThanCumulativeAckedTsn(this->deferredIncomingRequest->senderLastAssignedTsn))
+			{
+				return false;
+			}
+
+			MS_DEBUG_DEV(
+			  "leaving deferred reset processing, sender last assigned tsn %" PRIu32 " reached",
+			  this->deferredIncomingRequest->senderLastAssignedTsn);
+
+			// Remember the request being performed here. The peer was told "in
+			// progress" and will retry it with a new request sequence number, and that
+			// retry must not reset the very same streams a second time.
+			this->performedDeferredRequest = std::move(this->deferredIncomingRequest);
+
+			this->deferredIncomingRequest = std::nullopt;
+
+			// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+			const auto& streamIds = this->performedDeferredRequest.value().streamIds;
+
+			// https://tools.ietf.org/html/rfc6525#section-5.2.2
+			//
+			// E3) "If no stream numbers are listed in the parameter, then all incoming
+			// streams MUST be reset to 0 as the next expected SSN. If specific stream
+			// numbers are listed, then only these specific streams MUST be reset to 0,
+			// and all other non-listed SSNs remain unchanged." E4: "Any queued TSNs
+			// (queued at step E2) MUST now be released and processed normally."
+			this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(streamIds);
+
+			this->associationListenerDeferrer.OnAssociationInboundStreamsReset(streamIds);
+
+			// The request has now been performed, so a retransmission of it must get
+			// the final response rather than "in progress" again.
+			this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
+
+			return true;
+		}
+
 		bool StreamResetHandler::ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
@@ -168,21 +226,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;
 				}
@@ -283,6 +341,11 @@ namespace RTC
 			  validationResult == ReqSeqNbrValidationResult::RETRANSMISSION &&
 			  this->lastProcessedReqResult != ReconfigurationResponseParameter::Result::IN_PROGRESS)
 			{
+				// The peer is getting the final result of this request, so there is no
+				// longer a need to remember that it may have been performed when leaving
+				// deferred reset processing.
+				this->performedDeferredRequest = std::nullopt;
+
 				auto* reconfigurationResponseParameter =
 				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
 
@@ -300,7 +363,33 @@ namespace RTC
 			// "In Progress" request. In all cases, re-evaluate the state.
 			this->lastProcessedReqSeqNbr = requestSn;
 
-			if (
+			// This very same request may have already been performed when the
+			// cumulative ack TSN reached its sender's last assigned TSN. The peer was
+			// told "in progress" and doesn't know it yet, so it retries it with a new
+			// request sequence number. Resetting those streams again would set their
+			// next expected SSN back to 0 after post reset data may have already been
+			// received, so just reply the final result.
+			const bool alreadyPerformed =
+			  this->performedDeferredRequest.has_value() &&
+			  this->performedDeferredRequest->senderLastAssignedTsn ==
+			    receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn() &&
+			  this->performedDeferredRequest->streamIds ==
+			    receivedOutgoingSsnResetRequestParameter->GetStreamIds();
+
+			this->performedDeferredRequest = std::nullopt;
+
+			if (alreadyPerformed)
+			{
+				// Set the result again rather than relying on the one stored when the
+				// reset was performed, since a received incoming stream reset request
+				// may have overwritten it in the meantime.
+				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
+
+				MS_DEBUG_DEV(
+				  "reset outgoing already performed when leaving deferred reset processing, sender last assigned tsn %" PRIu32,
+				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
+			}
+			else if (
 			  this->dataTracker->IsLaterThanCumulativeAckedTsn(
 			    receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn()))
 			{
@@ -313,6 +402,21 @@ namespace RTC
 				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
+				// Remember the request so that deferred reset processing can end as soon
+				// as the cumulative ack TSN reaches the sender's last assigned TSN,
+				// without depending on the peer retransmitting its request.
+				//
+				// NOTE: Just like ReassemblyQueue::EnterDeferredReset() does, a new
+				// request is ignored while already in deferred reset processing.
+				if (!this->deferredIncomingRequest.has_value())
+				{
+					this->deferredIncomingRequest = DeferredIncomingRequest{
+						.senderLastAssignedTsn =
+						  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
+						.streamIds = receivedOutgoingSsnResetRequestParameter->GetStreamIds(),
+					};
+				}
+
 				// "If the endpoint enters 'deferred reset processing', it MUST put a
 				// Re-configuration Response Parameter into a RE-CONFIG chunk indicating
 				// 'In progress' and MUST send the RE-CONFIG chunk.
@@ -334,6 +438,8 @@ namespace RTC
 				this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
+				this->deferredIncomingRequest = std::nullopt;
+
 				this->associationListenerDeferrer.OnAssociationInboundStreamsReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
@@ -435,7 +541,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 +576,7 @@ namespace RTC
 			}
 		}
 
-		void StreamResetHandler::OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop)
+		void StreamResetHandler::OnReConfigTimer(int64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
@@ -520,11 +627,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

@@ -14,7 +14,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			auto peerImplementationStringView = Types::SctpImplementationToString(this->peerImplementation);
+			auto peerImplementationStringView = Types::sctpImplementationToString(this->peerImplementation);
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::AssociationMetrics>");
 			MS_DUMP_CLEAN(indentation, "  tx packets count: %" PRIu64, this->txPacketsCount);
@@ -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");