mediasoup 3.28.0 → 3.29.0

package/worker/src/RTC/BWE/SenderTransportCongestionController.cpp

@@ -0,0 +1,599 @@
+#define MS_CLASS "RTC::BWE::SenderTransportCongestionController"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/BWE/SenderTransportCongestionController.hpp"
+#include "Logger.hpp"
+#include "RTC/BWE/BitrateUtils.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/* Static. */
+
+		// How often everything that depends on time rather than on an arrival is run.
+		// The shortest deadline it has to meet is the interval the loss based
+		// controller waits before lowering the target again, so it is a good deal
+		// finer than that.
+		static constexpr int64_t ProcessIntervalMs{ 100 };
+		// How far below the throughput a probe result may drag the estimate. A probe
+		// far below what is already acknowledged is unlikely to be measuring the
+		// link, but dropping to slightly below the throughput is what drains the
+		// queues when there really is an overuse.
+		static constexpr double ProbeDropThroughputFraction{ 0.85 };
+
+		/* Static methods. */
+
+		/**
+		 * What is holding the target back, which is what tells the probe controller
+		 * whether a probe would make any sense right now.
+		 */
+		static ProbeController::BandwidthLimitedCause getBandwidthLimitedCause(
+		  LossBasedController::State lossBasedState,
+		  bool isRttAboveLimit,
+		  Types::BandwidthUsage bandwidthUsage)
+		{
+			if (bandwidthUsage == Types::BandwidthUsage::OVERUSING || bandwidthUsage == Types::BandwidthUsage::UNDERUSING)
+			{
+				return ProbeController::BandwidthLimitedCause::DELAY_BASED_LIMITED_DELAY_INCREASED;
+			}
+
+			if (isRttAboveLimit)
+			{
+				return ProbeController::BandwidthLimitedCause::RTT_BASED_BACK_OFF_HIGH_RTT;
+			}
+
+			switch (lossBasedState)
+			{
+				case LossBasedController::State::DECREASING:
+				{
+					// No probe is sent in this state.
+					return ProbeController::BandwidthLimitedCause::LOSS_LIMITED_BWE;
+				}
+
+				case LossBasedController::State::INCREASING:
+				{
+					// Probes may be sent in this state.
+					return ProbeController::BandwidthLimitedCause::LOSS_LIMITED_BWE_INCREASING;
+				}
+
+				case LossBasedController::State::DELAY_BASED_ESTIMATE:
+				{
+					return ProbeController::BandwidthLimitedCause::DELAY_BASED_LIMITED;
+				}
+
+					NO_DEFAULT();
+			}
+		}
+
+		/* Instance methods. */
+
+		SenderTransportCongestionController::SenderTransportCongestionController(
+		  Listener* listener, SharedInterface* shared, SenderTransportCongestionControllerOptions options)
+		  : listener(listener),
+		    shared(shared),
+		    processTimer(shared->CreateTimer(this, "sender-transport-congestion-controller-process")),
+		    feedbackAdapter(std::addressof(this->sendPacketHistory)),
+		    alrDetector(shared),
+		    // An SFU forwards what others produce and cannot make more of it, so it
+		    // spends most of its time not filling the link. Without probing there, the
+		    // target would only grow when the traffic being forwarded happens to fill
+		    // it, and after a quiet spell the first stream admitted would be measured
+		    // against a figure from long ago.
+		    probeController({ .enablePeriodicAlrProbing = true }),
+		    probingScheduler(this, shared),
+		    startBitrate(options.startBitrate)
+		{
+			MS_TRACE();
+
+			this->minBitrate = options.minBitrate;
+			this->maxBitrate = options.maxBitrate;
+
+			ResetConstraints(this->shared->GetTimeUs(), /*applyStartBitrate*/ true);
+
+			// NOTE: Safe to apply from a constructor, where the listener must not be
+			// called: the only thing that can be pending at this point is a burst,
+			// which goes to a member of this class, since `MayNotifyTargetBitrate()`
+			// is not called from here and so there is no target to announce.
+			ApplyPendingUpdate();
+
+			this->processTimer->Start(ProcessIntervalMs, ProcessIntervalMs);
+		}
+
+		void SenderTransportCongestionController::SetNetworkAvailable(bool networkAvailable)
+		{
+			MS_TRACE();
+
+			const int64_t nowUs = this->shared->GetTimeUs();
+
+			AddProbeClusters(this->probeController.OnNetworkAvailability(networkAvailable, nowUs));
+
+			ApplyPendingUpdate();
+		}
+
+		std::optional<int64_t> SenderTransportCongestionController::OnRtpPacketToBeSent(
+		  RTC::RTP::Packet* packet, const RtpPacketToBeSentOptions& options)
+		{
+			MS_TRACE();
+
+			return AddRtpPacket(packet, options, /*probeCluster*/ std::nullopt);
+		}
+
+		void SenderTransportCongestionController::OnRtpPacketSent(
+		  std::optional<int64_t> sequenceNumber, size_t size, int64_t sentAtUs)
+		{
+			MS_TRACE();
+
+			// A packet that was never taken note of still took room in the link, so its
+			// bytes are attributed to the next one that does carry a sequence number.
+			if (!sequenceNumber.has_value())
+			{
+				this->sendPacketHistory.ProcessSentUntrackedPacket(size + this->packetOverhead, sentAtUs);
+
+				return;
+			}
+
+			const auto sentPacket =
+			  this->sendPacketHistory.ProcessSentPacket(sequenceNumber.value(), sentAtUs);
+
+			// Nothing is known about a packet the history does not hold, so there is
+			// nothing to tell anybody about it either.
+			if (!sentPacket.has_value())
+			{
+				return;
+			}
+
+			const auto& sentPacketValue = sentPacket.value();
+
+			this->alrDetector.OnBytesSent(static_cast<int64_t>(sentPacketValue.size), sentAtUs);
+			this->acknowledgedBitrateEstimator.SetAlr(this->alrDetector.GetAlrStartTimeUs().has_value());
+
+			if (!this->firstPacketSent)
+			{
+				this->firstPacketSent = true;
+
+				// Until a feedback arrives there is no round trip to measure, so the
+				// instant the first packet left is taken as the start of one. Without
+				// this the backoff by round trip time would have nothing to work with
+				// during the first seconds.
+				this->targetRateController.UpdatePropagationRtt(0, sentAtUs);
+			}
+
+			this->targetRateController.OnPacketSent(sentAtUs);
+		}
+
+		void SenderTransportCongestionController::ReceiveTransportWideCcFeedback(
+		  const RTC::RTCP::FeedbackRtpTransportPacket* feedback, int64_t receivedAtUs)
+		{
+			MS_TRACE();
+
+			const auto processedFeedback =
+			  this->feedbackAdapter.ProcessTransportWideCcFeedback(feedback, receivedAtUs);
+
+			if (!processedFeedback.has_value())
+			{
+				return;
+			}
+
+			const auto& transportPacketsFeedback = processedFeedback.value();
+
+			if (transportPacketsFeedback.packetFeedbacks.empty())
+			{
+				return;
+			}
+
+			// Something reports back, so the estimation is ours to do and not the
+			// remote endpoint's.
+			this->firstTransportFeedbackReceived = true;
+
+			const int64_t feedbackTimeUs    = transportPacketsFeedback.feedbackTimeUs;
+			const auto receivedWithSendInfo = transportPacketsFeedback.ReceivedWithSendInfo();
+
+			// The round trip of the whole feedback is the time since the oldest packet
+			// it reports on left, minus how long the rest of them waited at the remote
+			// endpoint before it decided to report. Taking the smallest of those is
+			// what leaves the propagation alone, without the wait.
+			//
+			// NOTE: Every packet below has an arrival time, since only the ones that
+			// were received are in `ReceivedWithSendInfo()`.
+			int64_t minPropagationRttUs{ Types::TimeUsInfinite };
+			int64_t maxReceiveTimeUs{ 0 };
+
+			for (const auto& packetResult : receivedWithSendInfo)
+			{
+				// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+				maxReceiveTimeUs = std::max(maxReceiveTimeUs, packetResult.receiveTimeUs.value());
+			}
+
+			for (const auto& packetResult : receivedWithSendInfo)
+			{
+				// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+				const int64_t receiveTimeUs    = packetResult.receiveTimeUs.value();
+				const int64_t feedbackRttUs    = feedbackTimeUs - packetResult.sentPacket.sendTimeUs;
+				const int64_t minPendingTimeUs = maxReceiveTimeUs - receiveTimeUs;
+				const int64_t propagationRttUs = feedbackRttUs - minPendingTimeUs;
+
+				minPropagationRttUs = std::min(minPropagationRttUs, propagationRttUs);
+			}
+
+			if (!receivedWithSendInfo.empty())
+			{
+				this->targetRateController.UpdatePropagationRtt(minPropagationRttUs, feedbackTimeUs);
+			}
+
+			const auto alrStartTimeUs = this->alrDetector.GetAlrStartTimeUs();
+
+			// Leaving the state has to be told to both of them, since each one holds
+			// its own idea of when it ended.
+			if (this->previouslyInAlr && !alrStartTimeUs.has_value())
+			{
+				this->acknowledgedBitrateEstimator.SetAlrEndedTimeUs(feedbackTimeUs);
+				this->probeController.SetAlrEndedTimeUs(feedbackTimeUs);
+			}
+
+			this->previouslyInAlr = alrStartTimeUs.has_value();
+
+			this->acknowledgedBitrateEstimator.IncomingPacketFeedbackVector(
+			  transportPacketsFeedback.SortedByReceiveTime());
+
+			const auto acknowledgedBitrate = this->acknowledgedBitrateEstimator.GetBitrate();
+
+			this->targetRateController.SetAcknowledgedBitrate(
+			  acknowledgedBitrate.value_or(Types::BitrateInfinite));
+
+			for (const auto& packetResult : transportPacketsFeedback.SortedByReceiveTime())
+			{
+				if (packetResult.sentPacket.probeCluster.has_value())
+				{
+					this->probeBitrateEstimator.HandleProbeAndEstimateBitrate(packetResult);
+				}
+			}
+
+			auto probeBitrate = this->probeBitrateEstimator.FetchAndResetLastEstimatedBitrate();
+
+			// A probe that measured far below what is already acknowledged is not
+			// measuring the link, so the drop it would cause is bounded.
+			if (probeBitrate.has_value() && acknowledgedBitrate.has_value())
+			{
+				const int64_t limit = std::min(
+				  this->delayBasedBwe.GetLastEstimate(),
+				  BitrateUtils::ApplyBitrateFactor(acknowledgedBitrate.value(), ProbeDropThroughputFraction));
+
+				probeBitrate = std::max(probeBitrate.value(), limit);
+			}
+
+			const auto result = this->delayBasedBwe.IncomingPacketFeedbackVector(
+			  transportPacketsFeedback,
+			  acknowledgedBitrate,
+			  probeBitrate,
+			  /*networkEstimate*/ std::nullopt,
+			  alrStartTimeUs.has_value());
+
+			if (result.updated)
+			{
+				// A probe result replaces the estimate instead of nudging it, and that
+				// has to happen before the delay based estimate is handed over, since
+				// setting it clears what the delay based path had.
+				if (result.probe)
+				{
+					this->targetRateController.SetSendBitrate(result.targetBitrate);
+				}
+
+				this->targetRateController.SetDelayBasedEstimate(result.targetBitrate);
+			}
+
+			this->targetRateController.UpdateLossBasedController(
+			  transportPacketsFeedback.packetFeedbacks, alrStartTimeUs.has_value(), feedbackTimeUs);
+
+			if (result.updated)
+			{
+				MayNotifyTargetBitrate(feedbackTimeUs);
+			}
+
+			// Coming out of an overuse is the one moment where a probe is worth it
+			// without waiting for anything else.
+			if (result.recoveredFromOveruse)
+			{
+				this->probeController.SetAlrStartTimeUs(alrStartTimeUs);
+
+				AddProbeClusters(this->probeController.RequestProbe(feedbackTimeUs));
+			}
+
+			ApplyPendingUpdate();
+		}
+
+		void SenderTransportCongestionController::ReceiveRtcpReceiverReport(
+		  int64_t lostPackets, int64_t expectedPackets)
+		{
+			MS_TRACE();
+
+			// Nothing moved since the previous report, so there is no stretch of the
+			// stream to work a loss ratio out of.
+			if (expectedPackets < 1)
+			{
+				return;
+			}
+
+			// Not a single packet got through. That is not a loss ratio of one but a
+			// stretch the remote endpoint could not report on, so it is left out rather
+			// than fed as the worst possible measurement.
+			if (expectedPackets - lostPackets < 1)
+			{
+				return;
+			}
+
+			this->targetRateController.UpdatePacketsLost(
+			  lostPackets, expectedPackets, this->shared->GetTimeUs());
+		}
+
+		void SenderTransportCongestionController::ReceiveEstimatedBitrate(int64_t bitrate)
+		{
+			MS_TRACE();
+
+			this->targetRateController.SetReceiverEstimate(bitrate);
+		}
+
+		void SenderTransportCongestionController::OnRttUpdate(int64_t rttUs)
+		{
+			MS_TRACE();
+
+			// NOTE: The round trip is taken in whole milliseconds, which is the
+			// resolution the thresholds it is compared against are expressed in.
+			const int64_t roundedRttUs = Utils::Time::TimeUsToMs(rttUs) * 1000;
+
+			if (roundedRttUs == 0)
+			{
+				return;
+			}
+
+			this->delayBasedBwe.OnRttUpdate(roundedRttUs);
+			this->targetRateController.UpdateRtt(roundedRttUs);
+		}
+
+		void SenderTransportCongestionController::SetBitrateLimits(int64_t minBitrate, int64_t maxBitrate)
+		{
+			MS_TRACE();
+
+			const int64_t nowUs = this->shared->GetTimeUs();
+
+			this->minBitrate = minBitrate;
+			this->maxBitrate = maxBitrate;
+
+			ResetConstraints(nowUs, /*applyStartBitrate*/ false);
+
+			MayNotifyTargetBitrate(nowUs);
+
+			ApplyPendingUpdate();
+		}
+
+		void SenderTransportCongestionController::SetDesiredBitrate(int64_t desiredBitrate)
+		{
+			MS_TRACE();
+
+			const int64_t nowUs = this->shared->GetTimeUs();
+
+			AddProbeClusters(this->probeController.OnMaxTotalAllocatedBitrate(desiredBitrate, nowUs));
+
+			ApplyPendingUpdate();
+		}
+
+		void SenderTransportCongestionController::SetPacketOverhead(size_t packetOverhead)
+		{
+			MS_TRACE();
+
+			this->packetOverhead = packetOverhead;
+
+			this->probingScheduler.SetPacketOverhead(packetOverhead);
+		}
+
+		int64_t SenderTransportCongestionController::GetAvailableBitrate() const
+		{
+			MS_TRACE();
+
+			return this->targetRateController.GetTargetBitrate();
+		}
+
+		void SenderTransportCongestionController::OnProbingSchedulerSendRtpPacket(
+		  ProbingScheduler* /*probingScheduler*/,
+		  RTC::RTP::Packet* packet,
+		  const Types::ProbeCluster& probeCluster)
+		{
+			MS_TRACE();
+
+			// The generator leaves room for both extensions but writes neither, and
+			// since it reuses a single packet what is left unwritten is whatever the
+			// previous one carried.
+			const auto sequenceNumber = AddRtpPacket(packet, RtpPacketToBeSentOptions{}, probeCluster);
+
+			// The generator builds every packet with room for both extensions, so
+			// there is always a sequence number to hand over.
+			MS_ASSERT(sequenceNumber.has_value(), "probe packet has no transport wide sequence number");
+
+			this->listener->OnSenderTransportCongestionControllerSendRtpProbePacket(
+			  this, packet, sequenceNumber.value());
+		}
+
+		void SenderTransportCongestionController::OnTimer(TimerHandleInterface* timer)
+		{
+			MS_TRACE();
+
+			if (timer == this->processTimer.get())
+			{
+				Process();
+			}
+		}
+
+		std::optional<int64_t> SenderTransportCongestionController::AddRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  const RtpPacketToBeSentOptions& options,
+		  std::optional<Types::ProbeCluster> probeCluster)
+		{
+			MS_TRACE();
+
+			// Whatever the packet carries there now, which is only read to find out
+			// whether it has room for the sequence number at all. Without it the
+			// remote endpoint cannot report on this packet, so taking note of it
+			// would only fill the history with entries no feedback can ever name.
+			uint16_t previousWideSeqNumber{ 0 };
+
+			if (!packet->ReadTransportWideCc01(previousWideSeqNumber))
+			{
+				return std::nullopt;
+			}
+
+			const int64_t nowUs = this->shared->GetTimeUs();
+
+			const int64_t sequenceNumber = this->sendPacketHistory.AddPacket(
+			  SendPacketHistory::AddPacketOptions{
+			    .ssrc = packet->GetSsrc(),
+			    .seq  = packet->GetSequenceNumber(),
+			    // What the link carries is the packet plus everything below RTP, so
+			    // that is what the rate control has to reason about.
+			    .size             = packet->GetLength() + this->packetOverhead,
+			    .isAudio          = options.isAudio,
+			    .isRetransmission = options.isRetransmission,
+			    .originalSsrc     = options.originalSsrc,
+			    .probeCluster     = probeCluster,
+			    .createdAtUs      = nowUs });
+
+			packet->UpdateTransportWideCc01(static_cast<uint16_t>(sequenceNumber));
+			packet->UpdateAbsSendTime(Utils::Time::TimeUsToAbsSendTime(nowUs));
+
+			return sequenceNumber;
+		}
+
+		void SenderTransportCongestionController::Process()
+		{
+			MS_TRACE();
+
+			const int64_t nowUs = this->shared->GetTimeUs();
+
+			this->targetRateController.Update(nowUs);
+
+			// Probing while the remote endpoint is the one estimating would be probing
+			// something nobody is measuring, so it waits for the first feedback.
+			this->probeController.SetAlrStartTimeUs(
+			  this->firstTransportFeedbackReceived ? this->alrDetector.GetAlrStartTimeUs() : std::nullopt);
+
+			AddProbeClusters(this->probeController.Process(nowUs));
+
+			MayNotifyTargetBitrate(nowUs);
+
+			ApplyPendingUpdate();
+		}
+
+		void SenderTransportCongestionController::AddProbeClusters(
+		  const std::vector<Types::ProbeClusterConfig>& clusterConfigs)
+		{
+			MS_TRACE();
+
+			this->pendingUpdate.probeClusterConfigs.insert(
+			  this->pendingUpdate.probeClusterConfigs.end(), clusterConfigs.begin(), clusterConfigs.end());
+		}
+
+		void SenderTransportCongestionController::ApplyPendingUpdate()
+		{
+			MS_TRACE();
+
+			// Taken out before anything leaves this class, so that a listener calling
+			// back in starts a cycle of its own instead of finding this one half
+			// applied.
+			const auto probeClusterConfigs   = std::move(this->pendingUpdate.probeClusterConfigs);
+			const auto targetBitrateToNotify = this->pendingUpdate.targetBitrateToNotify;
+
+			this->pendingUpdate = {};
+
+			if (!probeClusterConfigs.empty())
+			{
+				this->probingScheduler.CreateProbeClusters(probeClusterConfigs);
+			}
+
+			if (targetBitrateToNotify.has_value())
+			{
+				this->listener->OnSenderTransportCongestionControllerTargetBitrate(
+				  this, targetBitrateToNotify.value());
+			}
+		}
+
+		void SenderTransportCongestionController::MayNotifyTargetBitrate(int64_t nowUs)
+		{
+			MS_TRACE();
+
+			const int64_t targetBitrate = this->targetRateController.GetTargetBitrate();
+			const uint8_t fractionLost  = this->targetRateController.GetFractionLost();
+			const int64_t rttUs         = this->targetRateController.GetRttUs();
+			const LossBasedController::State lossBasedState =
+			  this->targetRateController.GetLossBasedState();
+			// Not filling the link is not the same as not being able to fill it, and
+			// what is announced is whether the link is what holds the sender back.
+			const bool isBandwidthLimited = !this->alrDetector.GetAlrStartTimeUs().has_value();
+
+			// Everything the listener reasons about is compared, since a reallocation
+			// is far more expensive than this comparison.
+			if (
+			  this->lastTargetBitrate.has_value() && targetBitrate == this->lastTargetBitrate.value() &&
+			  fractionLost == this->lastFractionLost && rttUs == this->lastRttUs &&
+			  lossBasedState == this->lastLossBasedState &&
+			  isBandwidthLimited == this->lastIsBandwidthLimited)
+			{
+				return;
+			}
+
+			this->lastTargetBitrate      = targetBitrate;
+			this->lastFractionLost       = fractionLost;
+			this->lastRttUs              = rttUs;
+			this->lastLossBasedState     = lossBasedState;
+			this->lastIsBandwidthLimited = isBandwidthLimited;
+
+			this->alrDetector.SetEstimatedBitrate(targetBitrate);
+
+			AddProbeClusters(this->probeController.SetEstimatedBitrate(
+			  targetBitrate,
+			  getBandwidthLimitedCause(
+			    lossBasedState,
+			    this->targetRateController.IsRttAboveLimit(),
+			    this->delayBasedBwe.GetLastState()),
+			  nowUs));
+
+			this->pendingUpdate.targetBitrateToNotify = targetBitrate;
+		}
+
+		void SenderTransportCongestionController::ResetConstraints(int64_t nowUs, bool applyStartBitrate)
+		{
+			MS_TRACE();
+
+			// Nothing below may be driven to a bitrate it treats as none at all, since
+			// with nothing going out there would be nothing left to measure.
+			this->minBitrate = std::max(this->minBitrate, RTC::Consts::BweMinBitrate);
+
+			if (this->maxBitrate < this->minBitrate)
+			{
+				MS_WARN_TAG(
+				  bwe,
+				  "max bitrate is lower than min bitrate [maxBitrate:%" PRIi64 ", minBitrate:%" PRIi64 "]",
+				  this->maxBitrate,
+				  this->minBitrate);
+
+				this->maxBitrate = this->minBitrate;
+			}
+
+			// NOTE: Raised here and not where it is kept, so that the member stays
+			// what was configured.
+			const int64_t startBitrate =
+			  applyStartBitrate ? std::max(this->startBitrate, this->minBitrate) : 0;
+
+			this->targetRateController.SetBitrateLimits(this->minBitrate, this->maxBitrate);
+
+			this->delayBasedBwe.SetMinBitrate(this->minBitrate);
+
+			if (applyStartBitrate)
+			{
+				this->targetRateController.SetSendBitrate(startBitrate);
+				this->delayBasedBwe.SetStartBitrate(startBitrate);
+			}
+
+			AddProbeClusters(
+			  this->probeController.SetBitrates(this->minBitrate, startBitrate, this->maxBitrate, nowUs));
+		}
+	} // namespace BWE
+} // namespace RTC

package/worker/src/RTC/BWE/TransportWideCcFeedbackGenerator.cpp

@@ -45,7 +45,7 @@ namespace RTC
 			this->sendPeriodicTimer->Start(this->sendIntervalMs, this->sendIntervalMs);
 		}
 
-		void TransportWideCcFeedbackGenerator::IncomingPacket(
+		void TransportWideCcFeedbackGenerator::ReceiveRtpPacket(
 		  int64_t arrivalTimeUs, const RTC::RTP::Packet* packet)
 		{
 			MS_TRACE();
@@ -247,8 +247,7 @@ namespace RTC
 
 			const auto latestWideSeqNumber = this->feedbackPacket->GetLatestSequenceNumber();
 
-			this->listener->OnTransportWideCcFeedbackGeneratorSendRtcpPacket(
-			  this, this->feedbackPacket.get());
+			this->listener->OnTransportWideCcFeedbackGeneratorSendPacket(this, this->feedbackPacket.get());
 
 			this->feedbackWideSeqNumStart = latestWideSeqNumber + 1;
 

package/worker/src/RTC/BWE/TrendlineEstimator.cpp

@@ -297,16 +297,16 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			if (!this->lastThresholdUpdateAtUs.has_value())
+			if (!this->lastSampleArrivalTimeUs.has_value())
 			{
-				this->lastThresholdUpdateAtUs = arrivalTimeUs;
+				this->lastSampleArrivalTimeUs = arrivalTimeUs;
 			}
 
 			// Avoid adapting the threshold to big latency spikes, caused for instance
 			// by a sudden capacity drop.
 			if (std::fabs(modifiedTrend) > this->threshold + MaxAdaptOffset)
 			{
-				this->lastThresholdUpdateAtUs = arrivalTimeUs;
+				this->lastSampleArrivalTimeUs = arrivalTimeUs;
 
 				return;
 			}
@@ -318,13 +318,13 @@ namespace RTC
 			// NOTE: The coefficients above are rates per millisecond, so the step is
 			// expressed in those units no matter that the instants are microseconds.
 			const double elapsedMs = std::min(
-			  static_cast<double>(arrivalTimeUs - this->lastThresholdUpdateAtUs.value()) / 1000.0,
+			  static_cast<double>(arrivalTimeUs - this->lastSampleArrivalTimeUs.value()) / 1000.0,
 			  static_cast<double>(MaxThresholdUpdateDeltaMs));
 
 			this->threshold += coef * (std::fabs(modifiedTrend) - this->threshold) * elapsedMs;
 			this->threshold = std::clamp(this->threshold, ThresholdMin, ThresholdMax);
 
-			this->lastThresholdUpdateAtUs = arrivalTimeUs;
+			this->lastSampleArrivalTimeUs = arrivalTimeUs;
 		}
 	} // namespace BWE
 } // namespace RTC

package/worker/src/RTC/Consumer.cpp

@@ -1526,13 +1526,14 @@ namespace RTC
 		}
 	}
 
-	void Consumer::ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs)
+	std::optional<RTC::RTP::RtpStreamSend::Loss> Consumer::ReceiveRtcpReceiverReport(
+	  RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		auto* rtpStream = this->mapSsrcRtpStream.at(report->GetSsrc());
 
-		rtpStream->ReceiveRtcpReceiverReport(report, receivedAtUs);
+		return rtpStream->ReceiveRtcpReceiverReport(report, receivedAtUs);
 	}
 
 	void Consumer::ReceiveRtcpXrReceiverReferenceTime(

package/worker/src/RTC/DataConsumer.cpp

@@ -598,8 +598,8 @@ namespace RTC
 			MS_WARN_TAG(
 			  message,
 			  "message exceeds maxMessageSize value [maxMessageSize:%zu, len:%zu]",
-			  messageLen,
-			  this->maxMessageSize);
+			  this->maxMessageSize,
+			  messageLen);
 
 			if (cb)
 			{