mediasoup 3.26.0 → 3.27.0

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

@@ -35,7 +35,7 @@ namespace RTC
 		    supportsPartialReliability(supportsPartialReliability),
 		    dataChunkHeaderLength(
 		      useMessageInterleaving ? IDataChunk::IDataChunkHeaderLength
-		                             : DataChunk::DataChunkHeaderLength),
+					                       : DataChunk::DataChunkHeaderLength),
 		    t3RtxTimer(t3RtxTimer),
 		    cwnd(sctpOptions.initialCwndMtus * sctpOptions.mtu),
 		    rwnd(remoteAdvertisedReceiverWindowCredit),
@@ -62,7 +62,7 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		bool RetransmissionQueue::HandleReceivedSackChunk(uint64_t nowMs, const SackChunk* receivedSackChunk)
+		bool RetransmissionQueue::HandleReceivedSackChunk(int64_t nowUs, const SackChunk* receivedSackChunk)
 		{
 			MS_TRACE();
 
@@ -82,7 +82,7 @@ namespace RTC
 
 			if (receivedSackChunk->GetValidatedGapAckBlocks().empty())
 			{
-				UpdateRttMs(nowMs, cumulativeTsnAck);
+				UpdateRttUs(nowUs, cumulativeTsnAck);
 			}
 
 			// Exit fast recovery before continuing processing, in case it needs to go
@@ -301,7 +301,7 @@ namespace RTC
 		}
 
 		std::vector<std::pair<uint32_t /*tsn*/, UserData>> RetransmissionQueue::GetChunksToSend(
-		  uint64_t nowMs, size_t maxLength)
+		  int64_t nowUs, size_t maxLength)
 		{
 			MS_TRACE();
 
@@ -365,7 +365,7 @@ namespace RTC
 				  maxBytes);
 
 				std::optional<SendQueueInterface::DataToSend> dataToSend =
-				  this->sendQueue.Produce(nowMs, maxBytes - this->dataChunkHeaderLength);
+				  this->sendQueue.Produce(nowUs, maxBytes - this->dataChunkHeaderLength);
 
 				if (!dataToSend.has_value())
 				{
@@ -381,10 +381,10 @@ namespace RTC
 				const std::optional<Types::UnwrappedTsn> tsn = this->outstandingData.Insert(
 				  dataToSend->outgoingMessageId,
 				  dataToSend->data,
-				  nowMs,
+				  nowUs,
 				  this->supportsPartialReliability ? dataToSend->maxRetransmissions
-				                                   : Types::MaxRetransmitsNoLimit,
-				  this->supportsPartialReliability ? dataToSend->expiresAtMs : Types::ExpiresAtMsInfinite,
+					                                 : Types::MaxRetransmitsNoLimit,
+				  this->supportsPartialReliability ? dataToSend->expiresAtUs : Types::ExpiresAtUsInfinite,
 				  dataToSend->lifecycleId);
 
 				if (tsn.has_value())
@@ -450,7 +450,7 @@ namespace RTC
 			return toBeSent;
 		}
 
-		bool RetransmissionQueue::ShouldSendForwardTsn(uint64_t nowMs)
+		bool RetransmissionQueue::ShouldSendForwardTsn(int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -459,7 +459,7 @@ namespace RTC
 				return false;
 			}
 
-			this->outstandingData.ExpireOutstandingChunks(nowMs);
+			this->outstandingData.ExpireOutstandingChunks(nowUs);
 
 			return this->outstandingData.ShouldSendForwardTsn();
 		}
@@ -552,11 +552,11 @@ namespace RTC
 			  [&](const auto& block)
 			  {
 				  return Types::UnwrappedTsn::AddTo(cumulativeTsnAck, block.end) <=
-				         this->outstandingData.GetHighestOutstandingTsn();
+					       this->outstandingData.GetHighestOutstandingTsn();
 			  });
 		}
 
-		void RetransmissionQueue::UpdateRttMs(uint64_t nowMs, Types::UnwrappedTsn cumulativeTsnAck)
+		void RetransmissionQueue::UpdateRttUs(int64_t nowUs, Types::UnwrappedTsn cumulativeTsnAck)
 		{
 			MS_TRACE();
 
@@ -571,11 +571,11 @@ namespace RTC
 			// Consider occasionally sending DATA chunks with I-bit set and use only
 			// those packets for measurement.
 
-			const auto rttMs = this->outstandingData.MeasureRtt(nowMs, cumulativeTsnAck);
+			const auto rttUs = this->outstandingData.MeasureRttUs(nowUs, cumulativeTsnAck);
 
-			if (rttMs.has_value())
+			if (rttUs.has_value())
 			{
-				this->listener->OnRetransmissionQueueNewRttMs(rttMs.value());
+				this->listener->OnRetransmissionQueueNewRttUs(rttUs.value());
 			}
 		}
 

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

@@ -15,7 +15,7 @@ namespace RTC
 		static constexpr double RtoAlpha{ 1.0 / 8.0 };
 		static constexpr double RtoBeta{ 1.0 / 4.0 };
 
-		// A factor that the `minRttVarianceMs` configuration option will be divided
+		// A factor that the `minRttVarianceUs` configuration option will be divided
 		// by (before later multiplied with K, which is 4 according to RFC6298). When
 		// this value was introduced, it was unintentionally divided by 8 since that
 		// code worked with scaled numbers (to avoid floating point math). That
@@ -26,12 +26,15 @@ namespace RTC
 		/* Instance methods. */
 
 		RetransmissionTimeout::RetransmissionTimeout(const SctpOptions& sctpOptions)
-		  : minRtoMs(sctpOptions.minRtoMs),
-		    maxRtoMs(sctpOptions.maxRtoMs),
-		    maxRttMs(sctpOptions.maxRttMs),
-		    minRttVarianceMs(sctpOptions.minRttVarianceMs / HeuristicVarianceAdjustment),
-		    srttMs(sctpOptions.initialRtoMs),
-		    rtoMs(sctpOptions.initialRtoMs),
+		  // NOTE: The options are in milliseconds, while this class works in
+		  // microseconds so that sub-millisecond RTTs are not lost.
+		  : minRtoUs(sctpOptions.minRtoMs * 1000),
+		    maxRtoUs(sctpOptions.maxRtoMs * 1000),
+		    maxRttUs(sctpOptions.maxRttMs * 1000),
+		    minRttVarianceUs(
+		      static_cast<int64_t>((sctpOptions.minRttVarianceMs * 1000) / HeuristicVarianceAdjustment)),
+		    srttUs(sctpOptions.initialRtoMs * 1000),
+		    rtoUs(sctpOptions.initialRtoMs * 1000),
 		    firstMeasurement(true)
 		{
 			MS_TRACE();
@@ -47,25 +50,25 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::RetransmissionTimeout>");
-			MS_DUMP_CLEAN(indentation, "  min rto (ms): %" PRIu64, this->minRtoMs);
-			MS_DUMP_CLEAN(indentation, "  max rto (ms): %" PRIu64, this->maxRtoMs);
-			MS_DUMP_CLEAN(indentation, "  max rtt (ms): %" PRIu64, this->maxRttMs);
-			MS_DUMP_CLEAN(indentation, "  min rtt variance (ms): %" PRIu64, this->minRttVarianceMs);
-			MS_DUMP_CLEAN(indentation, "  rto (ms): %" PRIu64, GetRtoMs());
-			MS_DUMP_CLEAN(indentation, "  srtt (ms): %" PRIu64, GetSrttMs());
+			MS_DUMP_CLEAN(indentation, "  min rto (us): %" PRIi64, this->minRtoUs);
+			MS_DUMP_CLEAN(indentation, "  max rto (us): %" PRIi64, this->maxRtoUs);
+			MS_DUMP_CLEAN(indentation, "  max rtt (us): %" PRIi64, this->maxRttUs);
+			MS_DUMP_CLEAN(indentation, "  min rtt variance (us): %" PRIi64, this->minRttVarianceUs);
+			MS_DUMP_CLEAN(indentation, "  rto (us): %" PRIi64, GetRtoUs());
+			MS_DUMP_CLEAN(indentation, "  srtt (us): %" PRIi64, GetSrttUs());
 			MS_DUMP_CLEAN(indentation, "</SCTP::RetransmissionTimeout>");
 		}
 
-		void RetransmissionTimeout::ObserveRttMs(uint64_t rttMs)
+		void RetransmissionTimeout::ObserveRttUs(int64_t rttUs)
 		{
 			MS_TRACE();
 
 			// Unrealistic values will be skipped. If a wrongly measured (or otherwise
 			// corrupt) value was processed, it could change the state in a way that
 			// would take a very long time to recover.
-			if (rttMs == 0 || rttMs > this->maxRttMs)
+			if (rttUs <= 0 || rttUs > this->maxRttUs)
 			{
-				MS_WARN_DEV(sctp, "skipping given unrealistic rttMs value %" PRIu64, rttMs);
+				MS_WARN_DEV(sctp, "skipping given unrealistic rttUs value %" PRIi64, rttUs);
 
 				return;
 			}
@@ -73,25 +76,25 @@ namespace RTC
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-6.3.1
 			if (this->firstMeasurement)
 			{
-				this->srttMs           = rttMs;
-				this->rttVarMs         = rttMs / 2.0;
+				this->srttUs           = rttUs;
+				this->rttVarUs         = rttUs / 2.0;
 				this->firstMeasurement = false;
 			}
 			else
 			{
-				const double rttDiffMs = std::abs(this->srttMs - static_cast<double>(rttMs));
+				const double rttDiffUs = std::abs(this->srttUs - static_cast<double>(rttUs));
 
-				this->rttVarMs = ((1.0 - RtoBeta) * this->rttVarMs) + (RtoBeta * rttDiffMs);
-				this->srttMs   = ((1.0 - RtoAlpha) * this->srttMs) + (RtoAlpha * rttMs);
+				this->rttVarUs = ((1.0 - RtoBeta) * this->rttVarUs) + (RtoBeta * rttDiffUs);
+				this->srttUs   = ((1.0 - RtoAlpha) * this->srttUs) + (RtoAlpha * rttUs);
 			}
 
-			this->rttVarMs = std::max(this->rttVarMs, static_cast<double>(this->minRttVarianceMs));
-			this->rtoMs    = this->srttMs + (4.0 * this->rttVarMs);
-			this->rtoMs    = std::round(
+			this->rttVarUs = std::max(this->rttVarUs, static_cast<double>(this->minRttVarianceUs));
+			this->rtoUs    = this->srttUs + (4.0 * this->rttVarUs);
+			this->rtoUs    = std::round(
 			  std::clamp(
-			    this->rtoMs, static_cast<double>(this->minRtoMs), static_cast<double>(this->maxRtoMs)));
+			    this->rtoUs, static_cast<double>(this->minRtoUs), static_cast<double>(this->maxRtoUs)));
 
-			MS_DEBUG_DEV("new computed RTO: %" PRIu64 " ms", this->rtoMs);
+			MS_DEBUG_DEV("new computed RTO: %" PRIi64 " us", static_cast<int64_t>(this->rtoUs));
 		}
 	} // namespace SCTP
 } // namespace RTC

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

@@ -43,7 +43,7 @@ namespace RTC
 		}
 
 		void RoundRobinSendQueue::AddMessage(
-		  uint64_t nowMs, Message message, const SendMessageOptions& sendMessageOptions)
+		  int64_t nowUs, Message message, const SendMessageOptions& sendMessageOptions)
 		{
 			MS_TRACE();
 
@@ -51,17 +51,18 @@ namespace RTC
 
 			// Any limited lifetime should start counting from now - when the message
 			// has been added to the queue.
-			// `expiresAtMs` is the time when it expires. Which is slightly larger
+			// `expiresAtUs` is the time when it expires. Which is slightly larger
 			// than the message's lifetime, as the message is alive during its entire
 			// lifetime (which may be zero).
+			// NOTE: `lifetimeMs` is in milliseconds, being it given by the API.
 			const MessageAttributes attributes = {
 				.isUnordered        = sendMessageOptions.unordered,
 				.maxRetransmissions = sendMessageOptions.maxRetransmissions.has_value()
 				                        ? sendMessageOptions.maxRetransmissions.value()
 				                        : Types::MaxRetransmitsNoLimit,
-				.expiresAtMs        = sendMessageOptions.lifetimeMs.has_value()
-				                        ? nowMs + sendMessageOptions.lifetimeMs.value() + 1
-				                        : Types::ExpiresAtMsInfinite,
+				.expiresAtUs        = sendMessageOptions.lifetimeMs.has_value()
+				                        ? nowUs + (sendMessageOptions.lifetimeMs.value() * 1000) + 1
+				                        : Types::ExpiresAtUsInfinite,
 				.lifecycleId        = sendMessageOptions.lifecycleId,
 			};
 
@@ -98,11 +99,11 @@ namespace RTC
 		}
 
 		std::optional<SendQueueInterface::DataToSend> RoundRobinSendQueue::Produce(
-		  uint64_t nowMs, size_t maxLength)
+		  int64_t nowUs, size_t maxLength)
 		{
 			MS_TRACE();
 
-			return this->scheduler.Produce(nowMs, maxLength);
+			return this->scheduler.Produce(nowUs, maxLength);
 		}
 
 		bool RoundRobinSendQueue::Discard(uint16_t streamId, uint32_t outgoingMessageId)
@@ -418,7 +419,7 @@ namespace RTC
 		}
 
 		std::optional<SendQueueInterface::DataToSend> RoundRobinSendQueue::OutgoingStream::Produce(
-		  uint64_t nowMs, size_t maxLength)
+		  int64_t nowUs, size_t maxLength)
 		{
 			MS_TRACE();
 
@@ -435,7 +436,7 @@ namespace RTC
 				if (!item.mid.has_value())
 				{
 					// This entire message has already expired. Try the next one.
-					if (item.attributes.expiresAtMs != Types::ExpiresAtMsInfinite && item.attributes.expiresAtMs <= nowMs)
+					if (item.attributes.expiresAtUs != Types::ExpiresAtUsInfinite && item.attributes.expiresAtUs <= nowUs)
 					{
 						HandleMessageExpired(item);
 
@@ -472,7 +473,7 @@ namespace RTC
 				// Zero-copy the payload if the message fits in a single chunk.
 				std::vector<uint8_t> payload =
 				  isBeginning && isEnd ? std::move(message).ReleasePayload()
-				                       : std::vector<uint8_t>(chunkPayload.begin(), chunkPayload.end());
+					                     : std::vector<uint8_t>(chunkPayload.begin(), chunkPayload.end());
 
 				const uint32_t fsn = item.currentFsn;
 
@@ -495,7 +496,7 @@ namespace RTC
 				    item.attributes.isUnordered));
 
 				dataToSend.maxRetransmissions = item.attributes.maxRetransmissions;
-				dataToSend.expiresAtMs        = item.attributes.expiresAtMs;
+				dataToSend.expiresAtUs        = item.attributes.expiresAtUs;
 				dataToSend.lifecycleId        = isEnd ? item.attributes.lifecycleId : std::nullopt;
 
 				if (isEnd)

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

@@ -11,7 +11,7 @@ namespace RTC
 	{
 		/* Instance methods. */
 
-		std::optional<SendQueueInterface::DataToSend> StreamScheduler::Produce(uint64_t nowMs, size_t maxLength)
+		std::optional<SendQueueInterface::DataToSend> StreamScheduler::Produce(int64_t nowUs, size_t maxLength)
 		{
 			MS_TRACE();
 
@@ -56,7 +56,7 @@ namespace RTC
 					  "current stream should be in active streams");
 				}
 
-				dataToSend = this->currentStream->Produce(nowMs, maxLength);
+				dataToSend = this->currentStream->Produce(nowUs, maxLength);
 			}
 
 			if (!dataToSend.has_value())
@@ -234,12 +234,12 @@ namespace RTC
 		}
 
 		std::optional<SendQueueInterface::DataToSend> StreamScheduler::Stream::Produce(
-		  uint64_t nowMs, size_t maxLength)
+		  int64_t nowUs, size_t maxLength)
 		{
 			MS_TRACE();
 
 			std::optional<SendQueueInterface::DataToSend> dataToSend =
-			  this->producer.Produce(nowMs, maxLength);
+			  this->producer.Produce(nowUs, maxLength);
 
 			if (dataToSend.has_value())
 			{

package/worker/src/RTC/SctpDictionaries/SctpStreamParameters.cpp

@@ -66,8 +66,8 @@ namespace RTC
 		  this->streamId,
 		  this->ordered,
 		  this->maxPacketLifeTime ? flatbuffers::Optional<uint16_t>(this->maxPacketLifeTime)
-		                          : flatbuffers::nullopt,
+			                        : flatbuffers::nullopt,
 		  this->maxRetransmits ? flatbuffers::Optional<uint16_t>(this->maxRetransmits)
-		                       : flatbuffers::nullopt);
+			                     : flatbuffers::nullopt);
 	}
 } // namespace RTC

package/worker/src/RTC/SimpleProducerStreamManager.cpp

@@ -90,8 +90,8 @@ namespace RTC
 		// Do nothing.
 	}
 
-	uint32_t SimpleProducerStreamManager::IncreaseLayer(
-	  uint32_t bitrate, bool /*considerLoss*/, float /*lossPercentage*/, uint64_t nowMs)
+	int64_t SimpleProducerStreamManager::IncreaseLayer(
+	  int64_t bitrate, bool /*considerLoss*/, float /*lossPercentage*/, int64_t nowMs)
 	{
 		MS_TRACE();
 
@@ -103,7 +103,7 @@ namespace RTC
 		// about this.
 		if (this->managingBitrate)
 		{
-			return 0u;
+			return 0;
 		}
 
 		this->managingBitrate = true;
@@ -112,10 +112,10 @@ namespace RTC
 		// because Consumer::GetBitratePriority() does not account for the producer
 		// stream presence/score, so the Transport may still ask us to increase.
 		if (
-		  !this->producerRtpStream || (this->producerRtpStream->GetScore() == 0u &&
-		                               this->producerRtpStream->HasRtpInactivityCheckEnabled()))
+		  !this->producerRtpStream || (this->producerRtpStream->GetScore() == 0 &&
+			                             this->producerRtpStream->HasRtpInactivityCheckEnabled()))
 		{
-			return 0u;
+			return 0;
 		}
 
 		// Video Simple consumer does not really play the BWE game. However, let's
@@ -132,7 +132,7 @@ namespace RTC
 		}
 	}
 
-	void SimpleProducerStreamManager::ApplyLayers(uint64_t /*rtpStreamActiveMs*/)
+	void SimpleProducerStreamManager::ApplyLayers(int64_t /*rtpStreamActiveMs*/)
 	{
 		MS_TRACE();
 
@@ -144,7 +144,7 @@ namespace RTC
 		// Simple does not play the BWE game (even if video kind).
 	}
 
-	uint32_t SimpleProducerStreamManager::GetDesiredBitrate(uint64_t nowMs) const
+	int64_t SimpleProducerStreamManager::GetDesiredBitrate(int64_t nowMs) const
 	{
 		MS_TRACE();
 
@@ -153,12 +153,12 @@ namespace RTC
 		// Audio does not play the BWE game.
 		if (this->kind != RTC::Media::Kind::VIDEO)
 		{
-			return 0u;
+			return 0;
 		}
 
 		if (!IsActive())
 		{
-			return 0u;
+			return 0;
 		}
 
 		return this->producerRtpStream->GetBitrate(nowMs);

package/worker/src/RTC/SimulcastProducerStreamManager.cpp

@@ -8,10 +8,10 @@ namespace RTC
 {
 	/* Static. */
 
-	static constexpr uint64_t StreamMinActiveMs{ 2000u };
-	static constexpr uint64_t BweDowngradeConservativeMs{ 10000u };
-	static constexpr uint64_t BweDowngradeMinActiveMs{ 8000u };
-	static constexpr uint16_t MaxSequenceNumberGap{ 100u };
+	static constexpr int64_t StreamMinActiveMs{ 2000 };
+	static constexpr int64_t BweDowngradeConservativeMs{ 10000 };
+	static constexpr int64_t BweDowngradeMinActiveMs{ 8000 };
+	static constexpr uint16_t MaxSequenceNumberGap{ 100 };
 
 	/* Instance methods. */
 
@@ -200,18 +200,18 @@ namespace RTC
 		}
 	}
 
-	uint32_t SimulcastProducerStreamManager::IncreaseLayer(
-	  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs)
+	int64_t SimulcastProducerStreamManager::IncreaseLayer(
+	  int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs)
 	{
 		MS_TRACE();
 
 		// If already in the preferred layers, do nothing.
 		if (this->provisionalTargetLayers == this->preferredLayers)
 		{
-			return 0u;
+			return 0;
 		}
 
-		uint32_t virtualBitrate;
+		int64_t virtualBitrate;
 
 		if (considerLoss)
 		{
@@ -235,7 +235,7 @@ namespace RTC
 			virtualBitrate = bitrate;
 		}
 
-		uint32_t requiredBitrate{ 0u };
+		int64_t requiredBitrate{ 0 };
 		int16_t spatialLayer{ 0 };
 		int16_t temporalLayer{ 0 };
 		// Whether a usable spatial layer has been found, in which case we must not
@@ -351,7 +351,7 @@ namespace RTC
 				// temporal spatial layer if this is the temporal layer 0 of a higher
 				// spatial layer.
 				if (
-				  requiredBitrate && temporalLayer == 0 && this->provisionalTargetLayers.spatial > -1 &&
+				  requiredBitrate > 0 && temporalLayer == 0 && this->provisionalTargetLayers.spatial > -1 &&
 				  spatialLayer > this->provisionalTargetLayers.spatial)
 				{
 					auto* provisionalProducerRtpStream =
@@ -365,13 +365,13 @@ namespace RTC
 					}
 					else
 					{
-						requiredBitrate = 1u; // Don't set 0 since it would be ignored.
+						requiredBitrate = 1; // Don't set 0 since it would be ignored.
 					}
 				}
 
 				MS_DEBUG_DEV(
-				  "testing layers %" PRIi16 ":%" PRIi16 " [virtual bitrate:%" PRIu32
-				  ", required bitrate:%" PRIu32 "]",
+				  "testing layers %" PRIi16 ":%" PRIi16 " [virtual bitrate:%" PRIi64
+				  ", required bitrate:%" PRIi64 "]",
 				  spatialLayer,
 				  temporalLayer,
 				  virtualBitrate,
@@ -379,7 +379,7 @@ namespace RTC
 
 				// If active layer, end iterations here. Otherwise move to next spatial
 				// layer.
-				if (requiredBitrate)
+				if (requiredBitrate > 0)
 				{
 					goto done;
 				}
@@ -399,15 +399,15 @@ namespace RTC
 	done:
 
 		// No higher active layers found.
-		if (!requiredBitrate)
+		if (requiredBitrate <= 0)
 		{
-			return 0u;
+			return 0;
 		}
 
 		// No luck.
 		if (requiredBitrate > virtualBitrate)
 		{
-			return 0u;
+			return 0;
 		}
 
 		// Set provisional layers.
@@ -415,8 +415,8 @@ namespace RTC
 		this->provisionalTargetLayers.temporal = temporalLayer;
 
 		MS_DEBUG_DEV(
-		  "setting provisional layers to %" PRIi16 ":%" PRIi16 " [virtual bitrate:%" PRIu32
-		  ", required bitrate:%" PRIu32 "]",
+		  "setting provisional layers to %" PRIi16 ":%" PRIi16 " [virtual bitrate:%" PRIi64
+		  ", required bitrate:%" PRIi64 "]",
 		  this->provisionalTargetLayers.spatial,
 		  this->provisionalTargetLayers.temporal,
 		  virtualBitrate,
@@ -436,7 +436,7 @@ namespace RTC
 		}
 	}
 
-	void SimulcastProducerStreamManager::ApplyLayers(uint64_t rtpStreamActiveMs)
+	void SimulcastProducerStreamManager::ApplyLayers(int64_t rtpStreamActiveMs)
 	{
 		MS_TRACE();
 
@@ -467,11 +467,11 @@ namespace RTC
 		}
 	}
 
-	uint32_t SimulcastProducerStreamManager::GetDesiredBitrate(uint64_t nowMs) const
+	int64_t SimulcastProducerStreamManager::GetDesiredBitrate(int64_t nowMs) const
 	{
 		MS_TRACE();
 
-		uint32_t desiredBitrate{ 0u };
+		int64_t desiredBitrate{ 0 };
 
 		// Let's iterate all streams of the Producer (from highest to lowest) and
 		// obtain their bitrate. Choose the highest one.
@@ -673,13 +673,13 @@ namespace RTC
 				else
 				{
 					// Calculate capture instant and TS stuff.
-					const auto captureMs1 = tsReferenceCaptureMapping.value().captureMs;
-					const auto ts1        = tsReferenceCaptureMapping.value().ts;
-					const auto captureMs2 = captureMapping.value().captureMs;
-					const auto ts2        = captureMapping.value().ts;
-					const int64_t diffMs = static_cast<int64_t>(captureMs2) - static_cast<int64_t>(captureMs1);
-					const int64_t diffTs  = diffMs * clockRate / 1000;
-					const uint32_t newTs2 = ts2 - diffTs;
+					const auto captureAtUs1 = tsReferenceCaptureMapping.value().captureAtUs;
+					const auto ts1          = tsReferenceCaptureMapping.value().ts;
+					const auto captureAtUs2 = captureMapping.value().captureAtUs;
+					const auto ts2          = captureMapping.value().ts;
+					const int64_t diffUs    = captureAtUs2 - captureAtUs1;
+					const int64_t diffTs    = (diffUs * clockRate) / 1000000;
+					const uint32_t newTs2   = ts2 - diffTs;
 
 					// Apply offset. This is the difference that later must be removed from
 					// the sending RTP packet.
@@ -695,15 +695,17 @@ namespace RTC
 			{
 				// Max delay in ms we allow for the stream when switching.
 				// https://en.wikipedia.org/wiki/Audio-to-video_synchronization#Recommendations
-				static constexpr uint32_t MaxExtraOffsetMs{ 75 };
+				static constexpr int64_t MaxExtraOffsetMs{ 75 };
 
 				// Outgoing packet matches the highest timestamp seen in the previous
 				// stream. Apply an expected offset for a new frame in a 30fps stream.
-				static constexpr uint8_t MsOffset{ 33 }; // (1 / 30 * 1000).
+				static constexpr int64_t OffsetMs{ 33 }; // (1 / 30 * 1000).
 
 				const int64_t maxTsExtraOffset = MaxExtraOffsetMs * clockRate / 1000;
-				uint32_t tsExtraOffset =
-				  maxPacketTs - packet->GetTimestamp() + tsOffset + (MsOffset * clockRate / 1000);
+
+				// NOTE: RTP timestamps wrap around, so the sum is truncated on purpose.
+				auto tsExtraOffset = static_cast<uint32_t>(
+				  maxPacketTs - packet->GetTimestamp() + tsOffset + (OffsetMs * clockRate / 1000));
 
 				// NOTE: Don't ask for a key frame if already done.
 				if (this->keyFrameForTsOffsetRequested)
@@ -717,7 +719,7 @@ namespace RTC
 						  "which still too high RTP timestamp extra offset is needed (%" PRIu32 ")",
 						  tsExtraOffset);
 
-						tsExtraOffset = 1u;
+						tsExtraOffset = 1;
 					}
 				}
 				else if (std::cmp_greater(tsExtraOffset, maxTsExtraOffset))
@@ -746,7 +748,7 @@ namespace RTC
 					return result;
 				}
 
-				if (tsExtraOffset > 0u)
+				if (tsExtraOffset > 0)
 				{
 					MS_DEBUG_TAG(
 					  simulcast,
@@ -918,7 +920,7 @@ namespace RTC
 		if (
 		  newTargetSpatialLayer != -1 &&
 		  (this->tsReferenceSpatialLayer == -1 ||
-		   !GetProducerTsReferenceRtpStream()->GetCaptureMapping().has_value()))
+			 !GetProducerTsReferenceRtpStream()->GetCaptureMapping().has_value()))
 		{
 			MS_DEBUG_TAG(
 			  simulcast, "using spatial layer %" PRIi16 " as RTP timestamp reference", newTargetSpatialLayer);
@@ -982,7 +984,7 @@ namespace RTC
 		// Start with no layers.
 		newTargetLayers.Reset();
 
-		auto nowMs = this->shared->GetTimeMs();
+		const int64_t nowMs = this->shared->GetTimeMs();
 
 		for (size_t sIdx{ 0u }; sIdx < this->producerRtpStreams.size(); ++sIdx)
 		{