mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/TransportCongestionControlClient.cpp

@@ -5,18 +5,19 @@
 #include "RTC/TransportCongestionControlClient.hpp"
 #include "Logger.hpp"
 #include <libwebrtc/api/transport/network_types.h> // webrtc::TargetRateConstraints
+#include <cmath>                                   // std::llround()
 #include <limits>                                  // std::numeric_limits
 
 namespace RTC
 {
 	/* Static. */
 
-	// NOTE: TransportCongestionControlMinOutgoingBitrate is defined in
-	// TransportCongestionControlClient.hpp and exposed publicly.
-	static constexpr float MaxBitrateMarginFactor{ 0.1f };
-	static constexpr float MaxBitrateIncrementFactor{ 1.35f };
-	static constexpr float MaxPaddingBitrateFactor{ 0.85f };
-	static constexpr uint64_t AvailableBitrateEventInterval{ 1000u }; // In ms.
+	// NOTE: These are double rather than float because they are applied to bitrates,
+	// and float only holds exact integers up to 2^24 (16.7 Mbps).
+	static constexpr double MaxBitrateMarginFactor{ 0.1 };
+	static constexpr double MaxBitrateIncrementFactor{ 1.35 };
+	static constexpr double MaxPaddingBitrateFactor{ 0.85 };
+	static constexpr int64_t AvailableBitrateEventIntervalMs{ 1000 };
 	static constexpr size_t PacketLossHistogramLength{ 24 };
 
 	/* Instance methods. */
@@ -25,15 +26,15 @@ namespace RTC
 	  RTC::TransportCongestionControlClient::Listener* listener,
 	  SharedInterface* shared,
 	  RTC::BweType bweType,
-	  uint32_t initialAvailableBitrate,
-	  uint32_t maxOutgoingBitrate,
-	  uint32_t minOutgoingBitrate)
+	  int64_t absoluteMinOutgoingBitrate,
+	  int64_t initialAvailableBitrate,
+	  int64_t maxOutgoingBitrate,
+	  int64_t minOutgoingBitrate)
 	  : listener(listener),
 	    shared(shared),
 	    bweType(bweType),
-	    initialAvailableBitrate(
-	      std::max<uint32_t>(
-	        initialAvailableBitrate, RTC::TransportCongestionControlMinOutgoingBitrate)),
+	    absoluteMinOutgoingBitrate(absoluteMinOutgoingBitrate),
+	    initialAvailableBitrate(std::max<int64_t>(initialAvailableBitrate, absoluteMinOutgoingBitrate)),
 	    maxOutgoingBitrate(maxOutgoingBitrate),
 	    minOutgoingBitrate(minOutgoingBitrate)
 	{
@@ -64,7 +65,10 @@ namespace RTC
 		MS_ASSERT(this->rtpTransportControllerSend == nullptr, "transport controller already initialized");
 
 		webrtc::BitrateConstraints bitrateConfig;
-		bitrateConfig.start_bitrate_bps = static_cast<int>(this->initialAvailableBitrate);
+
+		// NOTE: The dependency takes a signed 32 bits bitrate, so it is clamped here.
+		bitrateConfig.start_bitrate_bps = static_cast<int>(
+		  std::min<int64_t>(this->initialAvailableBitrate, std::numeric_limits<int>::max()));
 
 		this->rtpTransportControllerSend =
 		  new webrtc::RtpTransportControllerSend(this, nullptr, this->controllerFactory, bitrateConfig);
@@ -78,7 +82,8 @@ namespace RTC
 		// videos are muted or using screensharing with still images)
 		this->rtpTransportControllerSend->EnablePeriodicAlrProbing(true);
 
-		this->processTimer = this->shared->CreateTimer(this);
+		this->processTimer =
+		  this->shared->CreateTimer(this, "transport-congestion-control-client-process");
 
 		this->processTimer->Start(
 		  std::min(
@@ -119,14 +124,14 @@ namespace RTC
 		MS_TRACE();
 
 #ifdef USE_TREND_CALCULATOR
-		const auto nowMs = this->shared->GetTimeMsInt64();
+		const auto nowMs = this->shared->GetTimeMs();
 #endif
 
-		this->bitrates.desiredBitrate          = 0u;
-		this->bitrates.effectiveDesiredBitrate = 0u;
+		this->bitrates.desiredBitrate          = 0;
+		this->bitrates.effectiveDesiredBitrate = 0;
 
 #ifdef USE_TREND_CALCULATOR
-		this->desiredBitrateTrend.ForceUpdate(0u, nowMs);
+		this->desiredBitrateTrend.ForceUpdate(0, nowMs);
 #endif
 
 		this->rtpTransportControllerSend->OnNetworkAvailability(false);
@@ -158,7 +163,7 @@ namespace RTC
 	}
 
 	void TransportCongestionControlClient::PacketSent(
-	  const webrtc::RtpPacketSendInfo& packetInfo, int64_t nowMs)
+	  const webrtc::RtpPacketSendInfo& packetInfo, int64_t nowUs)
 	{
 		MS_TRACE();
 
@@ -168,11 +173,14 @@ namespace RTC
 		}
 
 		// Notify the transport feedback adapter about the sent packet.
-		const rtc::SentPacket sentPacket(packetInfo.transport_sequence_number, nowMs);
+		// NOTE: The send time is truncated to whole milliseconds because that's the
+		// resolution the current estimator takes.
+		const rtc::SentPacket sentPacket(packetInfo.transport_sequence_number, nowUs / 1000);
+
 		this->rtpTransportControllerSend->OnSentPacket(sentPacket, packetInfo.length);
 	}
 
-	void TransportCongestionControlClient::ReceiveEstimatedBitrate(uint32_t bitrate)
+	void TransportCongestionControlClient::ReceiveEstimatedBitrate(int64_t bitrate)
 	{
 		MS_TRACE();
 
@@ -181,11 +189,13 @@ namespace RTC
 			return;
 		}
 
-		this->rtpTransportControllerSend->OnReceivedEstimatedBitrate(bitrate);
+		// NOTE: The dependency takes an unsigned 32 bits bitrate, so it is clamped here.
+		this->rtpTransportControllerSend->OnReceivedEstimatedBitrate(
+		  static_cast<uint32_t>(std::clamp<int64_t>(bitrate, 0, std::numeric_limits<uint32_t>::max())));
 	}
 
 	void TransportCongestionControlClient::ReceiveRtcpReceiverReport(
-	  RTC::RTCP::ReceiverReportPacket* packet, float rtt, int64_t nowMs)
+	  RTC::RTCP::ReceiverReportPacket* packet, float rttMs, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -211,8 +221,10 @@ namespace RTC
 			return;
 		}
 
+		// NOTE: The dependency works in milliseconds, so the arrival time is
+		// truncated here.
 		this->rtpTransportControllerSend->OnReceivedRtcpReceiverReport(
-		  reportBlockList, static_cast<int64_t>(rtt), nowMs);
+		  reportBlockList, static_cast<int64_t>(rttMs), receivedAtUs / 1000);
 	}
 
 	void TransportCongestionControlClient::ReceiveRtcpTransportFeedback(
@@ -224,9 +236,9 @@ namespace RTC
 		const size_t expectedPackets = feedback->GetPacketStatusCount();
 		size_t lostPackets           = 0;
 
-		for (const auto& result : feedback->GetPacketResults())
+		for (const auto& packetStatus : feedback->GetPacketStatuses())
 		{
-			if (!result.received)
+			if (!packetStatus.received)
 			{
 				lostPackets += 1;
 			}
@@ -286,7 +298,7 @@ namespace RTC
 		this->packetLoss = totalPacketLoss / samples;
 	}
 
-	void TransportCongestionControlClient::SetMaxOutgoingBitrate(uint32_t maxBitrate)
+	void TransportCongestionControlClient::SetMaxOutgoingBitrate(int64_t maxBitrate)
 	{
 		MS_TRACE();
 
@@ -294,14 +306,14 @@ namespace RTC
 
 		ApplyBitrateUpdates();
 
-		if (this->maxOutgoingBitrate > 0u)
+		if (this->maxOutgoingBitrate > 0)
 		{
 			this->bitrates.availableBitrate =
-			  std::min<uint32_t>(this->maxOutgoingBitrate, this->bitrates.availableBitrate);
+			  std::min<int64_t>(this->maxOutgoingBitrate, this->bitrates.availableBitrate);
 		}
 	}
 
-	void TransportCongestionControlClient::SetMinOutgoingBitrate(uint32_t minBitrate)
+	void TransportCongestionControlClient::SetMinOutgoingBitrate(int64_t minBitrate)
 	{
 		MS_TRACE();
 
@@ -309,16 +321,16 @@ namespace RTC
 
 		ApplyBitrateUpdates();
 
-		this->bitrates.minBitrate = std::max<uint32_t>(
-		  this->minOutgoingBitrate, RTC::TransportCongestionControlMinOutgoingBitrate);
+		this->bitrates.minBitrate =
+		  std::max<int64_t>(this->minOutgoingBitrate, this->absoluteMinOutgoingBitrate);
 	}
 
-	void TransportCongestionControlClient::SetDesiredBitrate(uint32_t desiredBitrate, bool force)
+	void TransportCongestionControlClient::SetDesiredBitrate(int64_t desiredBitrate, bool force)
 	{
 		MS_TRACE();
 
 #ifdef USE_TREND_CALCULATOR
-		const auto nowMs = this->shared->GetTimeMsInt64();
+		const auto nowMs = this->shared->GetTimeMs();
 #endif
 
 		// Manage it via trending and increase it a bit to avoid immediate oscillations.
@@ -341,13 +353,13 @@ namespace RTC
 		this->bitrates.effectiveDesiredBitrate = desiredBitrate;
 #endif
 
-		this->bitrates.minBitrate = std::max<uint32_t>(
-		  this->minOutgoingBitrate, RTC::TransportCongestionControlMinOutgoingBitrate);
+		this->bitrates.minBitrate =
+		  std::max<int64_t>(this->minOutgoingBitrate, this->absoluteMinOutgoingBitrate);
 
 		// NOTE: Setting 'startBitrate' to 'availableBitrate' has proven to generate
 		// more stable values.
-		this->bitrates.startBitrate = std::max<uint32_t>(
-		  RTC::TransportCongestionControlMinOutgoingBitrate, this->bitrates.availableBitrate);
+		this->bitrates.startBitrate =
+		  std::max<int64_t>(this->absoluteMinOutgoingBitrate, this->bitrates.availableBitrate);
 
 		ApplyBitrateUpdates();
 	}
@@ -357,27 +369,28 @@ namespace RTC
 		MS_TRACE();
 
 		auto currentMaxBitrate = this->bitrates.maxBitrate;
-		uint32_t newMaxBitrate = 0;
+		int64_t newMaxBitrate  = 0;
 
 #ifdef USE_TREND_CALCULATOR
-		if (this->desiredBitrateTrend.GetValue() > 0u)
+		if (this->desiredBitrateTrend.GetValue() > 0)
 #else
-		if (this->bitrates.desiredBitrate > 0u)
+		if (this->bitrates.desiredBitrate > 0)
 #endif
 		{
-			newMaxBitrate = std::max<uint32_t>(
+			newMaxBitrate = std::max<int64_t>(
 			  this->initialAvailableBitrate,
 #ifdef USE_TREND_CALCULATOR
-			  this->desiredBitrateTrend.GetValue() * MaxBitrateIncrementFactor);
+			  std::llround(this->desiredBitrateTrend.GetValue() * MaxBitrateIncrementFactor));
 #else
-			  this->bitrates.desiredBitrate * MaxBitrateIncrementFactor);
+			  std::llround(this->bitrates.desiredBitrate * MaxBitrateIncrementFactor));
 #endif
 
 			// If max bitrate requested didn't change by more than a small % keep the
 			// previous settings to avoid constant small fluctuations requiring extra
 			// probing and making the estimation less stable (requires constant
 			// redistribution of bitrate accross consumers).
-			auto maxBitrateMargin = newMaxBitrate * MaxBitrateMarginFactor;
+			const int64_t maxBitrateMargin = std::llround(newMaxBitrate * MaxBitrateMarginFactor);
+
 			if (currentMaxBitrate > newMaxBitrate - maxBitrateMargin && currentMaxBitrate < newMaxBitrate + maxBitrateMargin)
 			{
 				newMaxBitrate = currentMaxBitrate;
@@ -388,23 +401,23 @@ namespace RTC
 			newMaxBitrate = this->initialAvailableBitrate;
 		}
 
-		if (this->maxOutgoingBitrate > 0u)
+		if (this->maxOutgoingBitrate > 0)
 		{
-			newMaxBitrate = std::min<uint32_t>(this->maxOutgoingBitrate, newMaxBitrate);
+			newMaxBitrate = std::min<int64_t>(this->maxOutgoingBitrate, newMaxBitrate);
 		}
 
 		if (newMaxBitrate != currentMaxBitrate)
 		{
-			this->bitrates.maxPaddingBitrate = newMaxBitrate * MaxPaddingBitrateFactor;
+			this->bitrates.maxPaddingBitrate = std::llround(newMaxBitrate * MaxPaddingBitrateFactor);
 			this->bitrates.maxBitrate        = newMaxBitrate;
 		}
 
-		this->bitrates.minBitrate = std::max<uint32_t>(
-		  this->minOutgoingBitrate, RTC::TransportCongestionControlMinOutgoingBitrate);
+		this->bitrates.minBitrate =
+		  std::max<int64_t>(this->minOutgoingBitrate, this->absoluteMinOutgoingBitrate);
 
 		MS_DEBUG_DEV(
-		  "[desiredBitrate:%" PRIu32 ", desiredBitrateTrend:%" PRIu32 ", startBitrate:%" PRIu32
-		  ", minBitrate:%" PRIu32 ", maxBitrate:%" PRIu32 ", maxPaddingBitrate:%" PRIu32 "]",
+		  "[desiredBitrate:%" PRIi64 ", desiredBitrateTrend:%" PRIu32 ", startBitrate:%" PRIi64
+		  ", minBitrate:%" PRIi64 ", maxBitrate:%" PRIi64 ", maxPaddingBitrate:%" PRIi64 "]",
 		  this->bitrates.desiredBitrate,
 		  this->desiredBitrateTrend.GetValue(),
 		  this->bitrates.startBitrate,
@@ -430,7 +443,7 @@ namespace RTC
 		this->rtpTransportControllerSend->SetClientBitratePreferences(constraints);
 	}
 
-	uint32_t TransportCongestionControlClient::GetAvailableBitrate() const
+	int64_t TransportCongestionControlClient::GetAvailableBitrate() const
 	{
 		MS_TRACE();
 
@@ -451,17 +464,17 @@ namespace RTC
 		this->lastAvailableBitrateEventAtMs = this->shared->GetTimeMs();
 	}
 
-	void TransportCongestionControlClient::MayEmitAvailableBitrateEvent(uint32_t previousAvailableBitrate)
+	void TransportCongestionControlClient::MayEmitAvailableBitrateEvent(int64_t previousAvailableBitrate)
 	{
 		MS_TRACE();
 
-		const uint64_t nowMs = this->shared->GetTimeMsInt64();
+		const int64_t nowMs = this->shared->GetTimeMs();
 		bool notify{ false };
 
 		// Ignore if first event.
 		// NOTE: Otherwise it will make the Transport crash since this event also happens
 		// during the constructor of this class.
-		if (this->lastAvailableBitrateEventAtMs == 0u)
+		if (this->lastAvailableBitrateEventAtMs == 0)
 		{
 			this->lastAvailableBitrateEventAtMs = nowMs;
 
@@ -475,8 +488,8 @@ namespace RTC
 
 			notify = true;
 		}
-		// Emit event if AvailableBitrateEventInterval elapsed.
-		else if (nowMs - this->lastAvailableBitrateEventAtMs >= AvailableBitrateEventInterval)
+		// Emit event if AvailableBitrateEventIntervalMs elapsed.
+		else if (nowMs - this->lastAvailableBitrateEventAtMs >= AvailableBitrateEventIntervalMs)
 		{
 			notify = true;
 		}
@@ -485,7 +498,7 @@ namespace RTC
 		{
 			MS_WARN_TAG(
 			  bwe,
-			  "high BWE value decrease detected, notifying the listener [now:%" PRIu32 ", before:%" PRIu32
+			  "high BWE value decrease detected, notifying the listener [now:%" PRIi64 ", before:%" PRIi64
 			  "]",
 			  this->bitrates.availableBitrate,
 			  previousAvailableBitrate);
@@ -497,7 +510,7 @@ namespace RTC
 		{
 			MS_DEBUG_TAG(
 			  bwe,
-			  "high BWE value increase detected, notifying the listener [now:%" PRIu32 ", before:%" PRIu32
+			  "high BWE value increase detected, notifying the listener [now:%" PRIi64 ", before:%" PRIi64
 			  "]",
 			  this->bitrates.availableBitrate,
 			  previousAvailableBitrate);
@@ -508,7 +521,7 @@ namespace RTC
 		if (notify)
 		{
 			MS_DEBUG_DEV(
-			  "notifying the listener with new available bitrate:%" PRIu32,
+			  "notifying the listener with new available bitrate:%" PRIi64,
 			  this->bitrates.availableBitrate);
 
 			this->lastAvailableBitrateEventAtMs = nowMs;
@@ -532,17 +545,11 @@ namespace RTC
 		auto previousAvailableBitrate = this->bitrates.availableBitrate;
 
 		// Update availableBitrate.
-		// NOTE: Just in case.
-		if (targetTransferRate.target_rate.bps() > std::numeric_limits<uint32_t>::max())
-		{
-			this->bitrates.availableBitrate = std::numeric_limits<uint32_t>::max();
-		}
-		else
-		{
-			this->bitrates.availableBitrate = static_cast<uint32_t>(targetTransferRate.target_rate.bps());
-		}
+		// NOTE: The dependency gives a signed 64 bits bitrate, so no clamping is
+		// needed other than discarding a negative value.
+		this->bitrates.availableBitrate = std::max<int64_t>(targetTransferRate.target_rate.bps(), 0);
 
-		MS_DEBUG_DEV("new available bitrate:%" PRIu32, this->bitrates.availableBitrate);
+		MS_DEBUG_DEV("new available bitrate:%" PRIi64, this->bitrates.availableBitrate);
 
 		MayEmitAvailableBitrateEvent(previousAvailableBitrate);
 	}

package/worker/src/RTC/TransportCongestionControlServer.cpp

@@ -9,9 +9,9 @@ namespace RTC
 {
 	/* Static. */
 
-	static constexpr uint64_t TransportCcFeedbackSendInterval{ 100u }; // In ms.
-	static constexpr uint64_t LimitationRembInterval{ 1500u };         // In ms.
-	static constexpr uint64_t PacketArrivalTimestampWindow{ 500u };    // In ms.
+	static constexpr int64_t TransportCcFeedbackSendIntervalMs{ 100 };
+	static constexpr int64_t LimitationRembIntervalMs{ 1500 };
+	static constexpr int64_t PacketArrivalTimestampWindowUs{ 500 * 1000 };
 	static constexpr uint8_t UnlimitedRembNumPackets{ 4u };
 	static constexpr size_t PacketLossHistogramLength{ 24 };
 
@@ -34,7 +34,8 @@ namespace RTC
 				ResetTransportCcFeedback(0u);
 
 				// Create the feedback send periodic timer.
-				this->transportCcFeedbackSendPeriodicTimer = this->shared->CreateTimer(this);
+				this->transportCcFeedbackSendPeriodicTimer =
+				  this->shared->CreateTimer(this, "transport-congestion-control-server-feedback-send");
 
 				break;
 			}
@@ -69,7 +70,7 @@ namespace RTC
 			case RTC::BweType::TRANSPORT_CC:
 			{
 				this->transportCcFeedbackSendPeriodicTimer->Start(
-				  TransportCcFeedbackSendInterval, TransportCcFeedbackSendInterval);
+				  TransportCcFeedbackSendIntervalMs, TransportCcFeedbackSendIntervalMs);
 
 				break;
 			}
@@ -105,7 +106,7 @@ namespace RTC
 		return this->packetLoss;
 	}
 
-	void TransportCongestionControlServer::IncomingPacket(uint64_t nowMs, const RTC::RTP::Packet* packet)
+	void TransportCongestionControlServer::IncomingPacket(int64_t nowUs, const RTC::RTP::Packet* packet)
 	{
 		MS_TRACE();
 
@@ -121,7 +122,7 @@ namespace RTC
 				}
 
 				// Only insert the packet when receiving it for the first time.
-				if (!this->mapPacketArrivalTimes.try_emplace(wideSeqNumber, nowMs).second)
+				if (!this->mapPacketArrivalTimes.try_emplace(wideSeqNumber, nowUs).second)
 				{
 					break;
 				}
@@ -140,13 +141,13 @@ namespace RTC
 
 				this->transportWideSeqNumberReceived = true;
 
-				MayDropOldPacketArrivalTimes(wideSeqNumber, nowMs);
+				MayDropOldPacketArrivalTimes(wideSeqNumber, nowUs);
 
 				// Update the RTCP media SSRC of the ongoing Transport-CC Feedback packet.
 				this->transportCcFeedbackSenderSsrc = 0u;
 				this->transportCcFeedbackMediaSsrc  = packet->GetSsrc();
 
-				MaySendLimitationRembFeedback(nowMs);
+				MaySendLimitationRembFeedback(nowUs / 1000);
 
 				break;
 			}
@@ -160,12 +161,8 @@ namespace RTC
 					break;
 				}
 
-				// NOTE: nowMs is uint64_t but we need to "convert" it to int64_t before
-				// we give it to libwebrtc lib (althought this is implicit in the
-				// conversion so it would be converted within the method call).
-				auto nowMsInt64 = static_cast<int64_t>(nowMs);
-
-				this->rembServer->IncomingPacket(nowMsInt64, packet->GetPayloadLength(), *packet, absSendTime);
+				this->rembServer->IncomingPacket(
+				  nowUs / 1000, packet->GetPayloadLength(), *packet, absSendTime);
 
 				break;
 			}
@@ -191,7 +188,7 @@ namespace RTC
 		for (; it != this->mapPacketArrivalTimes.end(); ++it)
 		{
 			auto sequenceNumber = it->first;
-			auto timestamp      = it->second;
+			auto timestampUs    = it->second;
 
 			// If the base is not set in this packet let's set it.
 			// NOTE: This maybe needed many times during this loop since the current
@@ -200,11 +197,12 @@ namespace RTC
 			if (!this->transportCcFeedbackPacket->IsBaseSet())
 			{
 				// Set base sequence num and reference time.
-				this->transportCcFeedbackPacket->SetBase(this->transportCcFeedbackWideSeqNumStart, timestamp);
+				this->transportCcFeedbackPacket->SetBase(
+				  this->transportCcFeedbackWideSeqNumStart, timestampUs);
 			}
 
 			auto result = this->transportCcFeedbackPacket->AddPacket(
-			  sequenceNumber, timestamp, this->maxRtcpPacketLen);
+			  sequenceNumber, timestampUs, this->maxRtcpPacketLen);
 
 			switch (result)
 			{
@@ -273,7 +271,7 @@ namespace RTC
 		ResetTransportCcFeedback(this->transportCcFeedbackPacketCount);
 	}
 
-	void TransportCongestionControlServer::SetMaxIncomingBitrate(uint32_t bitrate)
+	void TransportCongestionControlServer::SetMaxIncomingBitrate(int64_t bitrate)
 	{
 		MS_TRACE();
 
@@ -281,12 +279,12 @@ namespace RTC
 
 		this->maxIncomingBitrate = bitrate;
 
-		if (previousMaxIncomingBitrate != 0u && this->maxIncomingBitrate == 0u)
+		if (previousMaxIncomingBitrate > 0 && this->maxIncomingBitrate == 0)
 		{
 			// This is to ensure that we send N REMB packets with bitrate 0 (unlimited).
 			this->unlimitedRembCounter = UnlimitedRembNumPackets;
 
-			auto nowMs = this->shared->GetTimeMs();
+			const int64_t nowMs = this->shared->GetTimeMs();
 
 			MaySendLimitationRembFeedback(nowMs);
 		}
@@ -315,9 +313,9 @@ namespace RTC
 		const size_t expectedPackets = this->transportCcFeedbackPacket->GetPacketStatusCount();
 		size_t lostPackets           = 0;
 
-		for (const auto& result : this->transportCcFeedbackPacket->GetPacketResults())
+		for (const auto& packetStatus : this->transportCcFeedbackPacket->GetPacketStatuses())
 		{
-			if (!result.received)
+			if (!packetStatus.received)
 			{
 				lostPackets += 1;
 			}
@@ -333,47 +331,47 @@ namespace RTC
 		return true;
 	}
 
-	void TransportCongestionControlServer::MayDropOldPacketArrivalTimes(uint16_t seqNum, uint64_t nowMs)
+	void TransportCongestionControlServer::MayDropOldPacketArrivalTimes(uint16_t seqNum, int64_t nowUs)
 	{
 		MS_TRACE();
 
-		// Ignore nowMs value if it's smaller than PacketArrivalTimestampWindow in
+		// Ignore nowUs value if it's smaller than PacketArrivalTimestampWindowUs in
 		// order to avoid negative values (should never happen) and return early if
 		// the condition is met.
-		if (nowMs >= PacketArrivalTimestampWindow)
+		if (nowUs >= PacketArrivalTimestampWindowUs)
 		{
-			const uint64_t expiryTimestamp = nowMs - PacketArrivalTimestampWindow;
-			auto it                        = this->mapPacketArrivalTimes.begin();
+			const int64_t expiryTimestampUs = nowUs - PacketArrivalTimestampWindowUs;
+			auto it                         = this->mapPacketArrivalTimes.begin();
 
 			while (it != this->mapPacketArrivalTimes.end() &&
 			       it->first != this->transportCcFeedbackWideSeqNumStart &&
 			       RTC::SeqManager<uint16_t>::IsSeqLowerThan(it->first, seqNum) &&
-			       it->second <= expiryTimestamp)
+			       it->second <= expiryTimestampUs)
 			{
 				it = this->mapPacketArrivalTimes.erase(it);
 			}
 		}
 	}
 
-	void TransportCongestionControlServer::MaySendLimitationRembFeedback(uint64_t nowMs)
+	void TransportCongestionControlServer::MaySendLimitationRembFeedback(int64_t nowMs)
 	{
 		MS_TRACE();
 
 		// May fix unlimitedRembCounter.
-		if (this->unlimitedRembCounter > 0u && this->maxIncomingBitrate != 0u)
+		if (this->unlimitedRembCounter > 0 && this->maxIncomingBitrate > 0)
 		{
-			this->unlimitedRembCounter = 0u;
+			this->unlimitedRembCounter = 0;
 		}
 
 		// In case this is the first unlimited REMB packet, send it fast.
 		if (
-		  ((this->bweType != RTC::BweType::REMB && this->maxIncomingBitrate != 0u) ||
-		   this->unlimitedRembCounter > 0u) &&
-		  (nowMs - this->limitationRembSentAtMs > LimitationRembInterval ||
-		   this->unlimitedRembCounter == UnlimitedRembNumPackets))
+		  ((this->bweType != RTC::BweType::REMB && this->maxIncomingBitrate > 0) ||
+			 this->unlimitedRembCounter > 0) &&
+		  (nowMs - this->limitationRembSentAtMs > LimitationRembIntervalMs ||
+			 this->unlimitedRembCounter == UnlimitedRembNumPackets))
 		{
 			MS_DEBUG_DEV(
-			  "sending limitation RTCP REMB packet [bitrate:%" PRIu32 "]", this->maxIncomingBitrate);
+			  "sending limitation RTCP REMB packet [bitrate:%" PRIi64 "]", this->maxIncomingBitrate);
 
 			RTC::RTCP::FeedbackPsRembPacket packet(0u, 0u);
 
@@ -435,12 +433,12 @@ namespace RTC
 	void TransportCongestionControlServer::OnRembServerAvailableBitrate(
 	  const webrtc::RemoteBitrateEstimator* /*rembServer*/,
 	  const std::vector<uint32_t>& ssrcs,
-	  uint32_t availableBitrate)
+	  int64_t availableBitrate)
 	{
 		MS_TRACE();
 
 		// Limit announced bitrate if requested via API.
-		if (this->maxIncomingBitrate != 0u)
+		if (this->maxIncomingBitrate > 0)
 		{
 			availableBitrate = std::min(availableBitrate, this->maxIncomingBitrate);
 		}
@@ -455,7 +453,7 @@ namespace RTC
 		}
 
 		MS_DEBUG_DEV(
-		  "sending RTCP REMB packet [bitrate:%" PRIu32 ", ssrcs:%s]",
+		  "sending RTCP REMB packet [bitrate:%" PRIi64 ", ssrcs:%s]",
 		  availableBitrate,
 		  ssrcsStream.str().c_str());
 #endif

package/worker/src/RTC/TrendCalculator.cpp

@@ -11,7 +11,7 @@ namespace RTC
 		MS_TRACE();
 	}
 
-	void TrendCalculator::Update(uint32_t value, uint64_t nowMs)
+	void TrendCalculator::Update(uint32_t value, int64_t nowMs)
 	{
 		MS_TRACE();
 
@@ -34,7 +34,7 @@ namespace RTC
 		// Otherwise decrease current value.
 		else
 		{
-			const uint64_t elapsedMs = nowMs - this->highestValueUpdatedAtMs;
+			const int64_t elapsedMs = nowMs - this->highestValueUpdatedAtMs;
 			auto subtraction =
 			  static_cast<uint32_t>(this->highestValue * this->decreaseFactor * (elapsedMs / 1000.0));
 
@@ -43,7 +43,7 @@ namespace RTC
 		}
 	}
 
-	void TrendCalculator::ForceUpdate(uint32_t value, uint64_t nowMs)
+	void TrendCalculator::ForceUpdate(uint32_t value, int64_t nowMs)
 	{
 		MS_TRACE();
 

package/worker/src/RTC/UdpSocket.cpp

@@ -11,10 +11,15 @@ namespace RTC
 	/* Instance methods. */
 
 	UdpSocket::UdpSocket(
-	  Listener* listener, std::string& ip, uint16_t port, RTC::Transport::SocketFlags& flags)
+	  Listener* listener,
+	  SharedInterface* shared,
+	  std::string& ip,
+	  uint16_t port,
+	  RTC::Transport::SocketFlags& flags)
 	  : // This may throw.
 	    ::UdpSocketHandle::UdpSocketHandle(RTC::PortManager::BindUdp(ip, port, flags)),
 	    listener(listener),
+	    shared(shared),
 	    fixedPort(true)
 	{
 		MS_TRACE();
@@ -22,6 +27,7 @@ namespace RTC
 
 	UdpSocket::UdpSocket(
 	  Listener* listener,
+	  SharedInterface* shared,
 	  std::string& ip,
 	  uint16_t minPort,
 	  uint16_t maxPort,
@@ -30,7 +36,8 @@ namespace RTC
 	  : // This may throw.
 	    ::UdpSocketHandle::UdpSocketHandle(
 	      RTC::PortManager::BindUdp(ip, minPort, maxPort, flags, portRangeKey)),
-	    listener(listener)
+	    listener(listener),
+	    shared(shared)
 	{
 		MS_TRACE();
 
@@ -52,6 +59,10 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		// NOTE: Take the arrival time before anything else is done with the
+		// datagram, so that it doesn't include the cost of processing it.
+		const int64_t receivedAtUs = this->shared->GetTimeUs();
+
 		if (!this->listener)
 		{
 			MS_ERROR("no listener set");
@@ -60,6 +71,6 @@ namespace RTC
 		}
 
 		// Notify the reader.
-		this->listener->OnUdpSocketPacketReceived(this, data, len, bufferLen, addr);
+		this->listener->OnUdpSocketPacketReceived(this, data, len, bufferLen, addr, receivedAtUs);
 	}
 } // namespace RTC