mediasoup 3.26.0 → 3.27.1

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`,

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);