mediasoup 3.28.0 → 3.29.0

package/worker/include/RTC/RTP/RtpStreamSend.hpp

@@ -1,31 +1,44 @@
 #ifndef MS_RTC_RTP_RTP_STREAM_SEND_HPP
 #define MS_RTC_RTP_RTP_STREAM_SEND_HPP
 
-#include "RTC/RTCP/FeedbackPs.hpp"
+#include "common.hpp"
+#include "FBS/rtpStream.h"
+#include "Utils/UnwrappedSequenceNumber.hpp"
+#include "handles/TimerHandleInterface.hpp"
+#include "RTC/RTCP/Feedback.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/ReceiverReport.hpp"
 #include "RTC/RTCP/Sdes.hpp"
+#include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTCP/XrReceiverReferenceTime.hpp"
+#include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RetransmissionBuffer.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RateCalculator.hpp"
+#include "SharedInterface.hpp"
+#include <flatbuffers/flatbuffer_builder.h>
+#include <ankerl/unordered_dense.h>
+#include <deque>
+#include <set>
+#include <string>
 
 namespace RTC
 {
 	namespace RTP
 	{
-		class RtpStreamSend : public RTP::RtpStream
+		class RtpStreamSend : public RTP::RtpStream, public TimerHandleInterface::Listener
 		{
 		public:
 			/**
 			 * Maximum retransmission buffer size for video (ms).
 			 */
-			static constexpr int64_t MaxRetransmissionDelayForVideoMs{ 2000 };
+			static constexpr int64_t MaxRetransmissionDelayForVideoMs{ 4000 };
 			/**
 			 * Maximum retransmission buffer size for audio (ms).
 			 */
-			static constexpr int64_t MaxRetransmissionDelayForAudioMs{ 1000 };
+			static constexpr int64_t MaxRetransmissionDelayForAudioMs{ 2000 };
 			/**
 			 * How old the last packet sent may be for a Sender Report to still be generated
 			 * (ms).
@@ -36,6 +49,40 @@ namespace RTC
 			 *   a stream that has really stopped sending.
 			 */
 			static constexpr int64_t MaxSenderReportReferenceAgeMs{ 2000 };
+			/**
+			 * How many sequence numbers that were never sent are remembered.
+			 *
+			 * @remarks
+			 * - Only a Receiver Report drains them and a remote endpoint may stop
+			 *   reporting, so this bounds what a stream whose reports never arrive can
+			 *   hold on to.
+			 * - What it has to cover is the sequence numbers skipped between two
+			 *   Receiver Reports. Taking the 5 seconds that RFC 3550 gives as a report
+			 *   interval and the 520 packets per second of a 5 Mbps video stream, this
+			 *   is close to four seconds of such a stream skipped whole.
+			 */
+			static constexpr size_t MaxUnsentSeqNumbers{ 2000 };
+
+		public:
+			/**
+			 * How many packets the remote endpoint missed and how many it should have
+			 * got, over the time between the previous Receiver Report and this one,
+			 * counting only what this link is answerable for.
+			 */
+			struct Loss
+			{
+				/**
+				 * Packets lost. It may be negative, since a hole that a previous report
+				 * already counted and that a late packet has filled in since gives back
+				 * what that report was charged for.
+				 */
+				int64_t lostPackets;
+				/**
+				 * Packets expected, which is what the sequence numbers of the interval
+				 * covered once the ones that were never sent are taken out of it.
+				 */
+				int64_t expectedPackets;
+			};
 
 		public:
 			enum class ReceivePacketResult : uint8_t
@@ -92,7 +139,13 @@ namespace RTC
 
 			void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType);
 
-			void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs);
+			/**
+			 * @returns What this link lost and what it was expected to deliver since
+			 *   the previous Receiver Report, or no value if this one measures no
+			 *   interval at all.
+			 */
+			std::optional<Loss> ReceiveRtcpReceiverReport(
+			  RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs);
 
 			void ReceiveRtcpXrReceiverReferenceTime(
 			  RTC::RTCP::ReceiverReferenceTime* report, int64_t receivedAtUs);
@@ -119,17 +172,50 @@ namespace RTC
 			int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
 
 		private:
-			void FillRetransmissionContainer(uint16_t seq, uint16_t bitmask);
+			void RetransmitPendingPackets();
 
-			void UpdateScore(RTC::RTCP::ReceiverReport* report);
+			/**
+			 * @param loss What the latest Receiver Report measured, or no value if it
+			 *   measured nothing.
+			 */
+			void UpdateScore(const std::optional<Loss>& loss);
+
+			/**
+			 * Take note of the sequence numbers that the packet just accepted leaves
+			 * behind for good, or forget one that it fills in late.
+			 */
+			void UpdateUnsentSeqNumbers(uint16_t seq);
+
+			/**
+			 * Work out how much of what the Receiver Report reports as lost really was
+			 * lost on the way to the remote endpoint, and take note of it.
+			 *
+			 * @returns What this link lost and what it was expected to deliver since
+			 *   the previous Receiver Report, or no value if this one measures no
+			 *   interval at all.
+			 *
+			 * @remarks
+			 * - What it takes note of in `fractionLost` and `packetsLost` is held at
+			 *   zero and at the packets expected, since neither may go backwards. What
+			 *   it returns is not, so that whoever adds up several of them gets the
+			 *   negative ones back.
+			 */
+			std::optional<Loss> UpdateSendLoss(RTC::RTCP::ReceiverReport* report);
+
+			/**
+			 * Forget everything measured over a numbering that is not in use anymore.
+			 */
+			void ResetSendLoss();
 
 			/* Pure virtual methods inherited from RTP::RtpStream. */
 		public:
 			void UserOnSequenceNumberReset() override;
 
+			/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
+		public:
+			void OnTimer(TimerHandleInterface* timer) override;
+
 		private:
-			// Packets lost at last interval for score calculation.
-			int32_t lostPriorScore{ 0 };
 			// Packets sent at last interval for score calculation.
 			// NOTE: As wide as the counter it snapshots, which does not wrap, so that
 			// the difference against it stays exact however long the stream runs.
@@ -138,8 +224,35 @@ namespace RTC
 			uint16_t rtxSeq{ 0 };
 			RTC::RtpDataCounter transmissionCounter;
 			RTP::RetransmissionBuffer* retransmissionBuffer{ nullptr };
+			// Sequence numbers requested by received NACKs and not retransmitted yet,
+			// in the order they were requested.
+			std::deque<uint16_t> pendingRetransmissionsQueue;
+			// Same sequence numbers as in pendingRetransmissionsQueue, to tell whether
+			// a requested one is already pending.
+			ankerl::unordered_dense::set<uint16_t> pendingRetransmissionsSet;
+			// Timer to retransmit the pending retransmissions spaced in time. Only
+			// created if NACK is enabled.
+			const std::unique_ptr<TimerHandleInterface> retransmissionTimer;
 			// Timing data of the most recent Receiver Reference Time received.
 			std::optional<ReceiverReferenceTime> lastReceiverReferenceTime;
+			// Unwraps the sequence numbers of what is sent, so that comparing them
+			// against the ones a Receiver Report names needs no wrapping arithmetic.
+			Utils::UnwrappedSequenceNumber<uint16_t>::Unwrapper seqUnwrapper;
+			// Sequence numbers that were skipped and will never be sent, which is what
+			// the uplink of the Producer lost, unwrapped.
+			std::set<int64_t> unsentSeqs;
+			// Highest sequence number sent so far, unwrapped.
+			std::optional<int64_t> highestSentSeq;
+			// Highest sequence number the previous Receiver Report had seen, unwrapped
+			// into our own numbering, which is where the interval of the next one
+			// starts. Seeded one below the first sequence number sent, so that the
+			// first report measures from that one onwards.
+			std::optional<int64_t> lastRrSeq;
+			// What the previous Receiver Report reported as lost in total. Left without
+			// a value when the numbering is reset, since the remote endpoint counts
+			// over the whole session and does not reset along with us, so the next
+			// report can only be taken as a new mark.
+			std::optional<int32_t> lastRrTotalLost{ 0 };
 		};
 	} // namespace RTP
 } // namespace RTC

package/worker/include/RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp

@@ -37,12 +37,20 @@ namespace RTC
 		public:
 			/**
 			 * Zero Checksum Alternate Error Detection Method.
+			 *
+			 * @remarks
+			 * - `TRUSTED_NETWORK` is not assigned by IANA. It's a mediasoup specific
+			 *   method meant to be used between mediasoup endpoints only, when the
+			 *   network path between them is trusted (such as localhost). Its value
+			 *   is taken from the top of the range to minimize the chances of
+			 *   colliding with a method assigned by IANA in the future.
 			 */
 			// NOLINTNEXTLINE(performance-enum-size)
 			enum class AlternateErrorDetectionMethod : uint32_t
 			{
-				NONE           = 0x0000,
-				SCTP_OVER_DTLS = 0x0001,
+				NONE            = 0x00000000,
+				SCTP_OVER_DTLS  = 0x00000001,
+				TRUSTED_NETWORK = 0xFFFFFFFE,
 			};
 
 		public:
@@ -100,7 +108,8 @@ namespace RTC
 
 				if (
 				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::NONE) ||
-				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::SCTP_OVER_DTLS))
+				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::SCTP_OVER_DTLS) ||
+				  method == static_cast<uint32_t>(AlternateErrorDetectionMethod::TRUSTED_NETWORK))
 				{
 					return static_cast<AlternateErrorDetectionMethod>(method);
 				}

package/worker/include/RTC/TransportCongestionControlClient.hpp

@@ -14,7 +14,6 @@
 #include <libwebrtc/api/transport/network_types.h>
 #include <libwebrtc/call/rtp_transport_controller_send.h>
 #include <libwebrtc/modules/pacing/packet_router.h>
-#include <deque>
 
 namespace RTC
 {
@@ -87,12 +86,10 @@ namespace RTC
 			return this->bitrates;
 		}
 		int64_t GetAvailableBitrate() const;
-		double GetPacketLoss() const;
 		void RescheduleNextAvailableBitrateEvent();
 
 	private:
 		void MayEmitAvailableBitrateEvent(int64_t previousAvailableBitrate);
-		void UpdatePacketLoss(double packetLoss);
 		void ApplyBitrateUpdates();
 
 		void InitializeController();
@@ -133,8 +130,6 @@ namespace RTC
 		bool availableBitrateEventCalled{ false };
 		int64_t lastAvailableBitrateEventAtMs{ 0 };
 		RTC::TrendCalculator desiredBitrateTrend;
-		std::deque<double> packetLossHistory;
-		double packetLoss{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/TransportCongestionControlServer.hpp

@@ -10,7 +10,6 @@
 #include "RTC/SeqManager.hpp"
 #include "SharedInterface.hpp"
 #include <libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h>
-#include <deque>
 
 namespace RTC
 {
@@ -54,7 +53,6 @@ namespace RTC
 					return 0;
 			}
 		}
-		double GetPacketLoss() const;
 		void IncomingPacket(int64_t nowUs, const RTC::RTP::Packet* packet);
 		void SetMaxIncomingBitrate(int64_t bitrate);
 		void FillAndSendTransportCcFeedback();
@@ -64,7 +62,6 @@ namespace RTC
 		bool SendTransportCcFeedback();
 		void MayDropOldPacketArrivalTimes(uint16_t seqNum, int64_t nowUs);
 		void MaySendLimitationRembFeedback(int64_t nowMs);
-		void UpdatePacketLoss(double packetLoss);
 		void ResetTransportCcFeedback(uint8_t feedbackPacketCount);
 
 		/* Pure virtual methods inherited from webrtc::RemoteBitrateEstimator::Listener. */
@@ -95,8 +92,6 @@ namespace RTC
 		int64_t maxIncomingBitrate{ 0 };
 		int64_t limitationRembSentAtMs{ 0 };
 		uint8_t unlimitedRembCounter{ 0 };
-		std::deque<double> packetLossHistory;
-		double packetLoss{ 0 };
 		// Whether any packet with transport wide sequence number was received.
 		bool transportWideSeqNumberReceived{ false };
 		uint16_t transportCcFeedbackWideSeqNumStart{ 0 };

package/worker/include/Utils.hpp

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "RTC/Consts.hpp"
 #include <openssl/evp.h>
+#include <array>
 #include <cassert>
 #include <cmath>
 #include <cstring> // std::memcmp(), std::memcpy()
@@ -275,8 +276,14 @@ namespace Utils
 		static thread_local EVP_MAC* mac;
 		static thread_local EVP_MAC_CTX* hmacSha1Ctx;
 		static thread_local uint8_t hmacSha1Buffer[];
-		static const uint32_t Crc32Table[256];
-		static const uint32_t Crc32cTable[256];
+		// Number of input bytes consumed per iteration of the slice-by-8 loop.
+		static constexpr size_t CrcSlices{ 8u };
+		using CrcTables = std::array<std::array<uint32_t, 256>, CrcSlices>;
+		static const CrcTables crc32Tables;
+		static const CrcTables crc32cTables;
+		static constexpr CrcTables generateCrcTables(uint32_t polynomial) noexcept;
+		static uint32_t ReadLe32(const uint8_t* data);
+		static uint32_t ComputeCrc(const CrcTables& tables, const uint8_t* data, size_t size);
 	};
 
 	class String

package/worker/meson.build

@@ -193,7 +193,9 @@ common_sources = [
   'src/RTC/BWE/ProbeController.cpp',
   'src/RTC/BWE/ProbePacketGenerator.cpp',
   'src/RTC/BWE/ProbingScheduler.cpp',
+  'src/RTC/BWE/ReceiverTransportCongestionController.cpp',
   'src/RTC/BWE/RembGenerator.cpp',
+  'src/RTC/BWE/SenderTransportCongestionController.cpp',
   'src/RTC/BWE/RemoteBitrateEstimatorAbsSendTime.cpp',
   'src/RTC/BWE/RobustThroughputEstimator.cpp',
   'src/RTC/BWE/SendPacketHistory.cpp',
@@ -515,7 +517,9 @@ test_sources = [
   'test/src/RTC/BWE/TestProbeController.cpp',
   'test/src/RTC/BWE/TestProbePacketGenerator.cpp',
   'test/src/RTC/BWE/TestProbingScheduler.cpp',
+  'test/src/RTC/BWE/TestReceiverTransportCongestionController.cpp',
   'test/src/RTC/BWE/TestRembGenerator.cpp',
+  'test/src/RTC/BWE/TestSenderTransportCongestionController.cpp',
   'test/src/RTC/BWE/TestRemoteBitrateEstimatorAbsSendTime.cpp',
   'test/src/RTC/BWE/TestRobustThroughputEstimator.cpp',
   'test/src/RTC/BWE/TestSendPacketHistory.cpp',

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

@@ -72,7 +72,7 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		int64_t AimdRateControl::Update(const Types::RateControlInput& input, int64_t atTimeUs)
+		int64_t AimdRateControl::Update(const Types::RateControlInput& input, int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -84,11 +84,11 @@ namespace RTC
 				{
 					if (input.estimatedThroughput.has_value())
 					{
-						this->timeFirstThroughputEstimateUs = atTimeUs;
+						this->timeFirstThroughputEstimateUs = nowUs;
 					}
 				}
 				else if (
-				  atTimeUs - this->timeFirstThroughputEstimateUs.value() > InitializationTimeUs &&
+				  nowUs - this->timeFirstThroughputEstimateUs.value() > InitializationTimeUs &&
 				  input.estimatedThroughput.has_value())
 				{
 					this->currentBitrate       = input.estimatedThroughput.value();
@@ -96,18 +96,18 @@ namespace RTC
 				}
 			}
 
-			ChangeBitrate(input, atTimeUs);
+			ChangeBitrate(input, nowUs);
 
 			return this->currentBitrate;
 		}
 
-		void AimdRateControl::SetEstimate(int64_t bitrate, int64_t atTimeUs)
+		void AimdRateControl::SetEstimate(int64_t bitrate, int64_t nowUs)
 		{
 			MS_TRACE();
 
 			this->bitrateIsInitialized    = true;
 			this->currentBitrate          = ClampBitrate(bitrate);
-			this->timeLastBitrateChangeUs = atTimeUs;
+			this->timeLastBitrateChangeUs = nowUs;
 		}
 
 		void AimdRateControl::SetStartBitrate(int64_t startBitrate)
@@ -149,7 +149,7 @@ namespace RTC
 			this->networkEstimate = estimate;
 		}
 
-		bool AimdRateControl::IsTimeToReduceFurther(int64_t atTimeUs, int64_t estimatedThroughput) const
+		bool AimdRateControl::IsTimeToReduceFurther(int64_t nowUs, int64_t estimatedThroughput) const
 		{
 			MS_TRACE();
 
@@ -162,7 +162,7 @@ namespace RTC
 				return true;
 			}
 
-			if (atTimeUs - this->timeLastBitrateChangeUs.value() >= bitrateReductionIntervalUs)
+			if (nowUs - this->timeLastBitrateChangeUs.value() >= bitrateReductionIntervalUs)
 			{
 				return true;
 			}
@@ -177,11 +177,11 @@ namespace RTC
 			return false;
 		}
 
-		bool AimdRateControl::IsInitialTimeToReduceFurther(int64_t atTimeUs) const
+		bool AimdRateControl::IsInitialTimeToReduceFurther(int64_t nowUs) const
 		{
 			MS_TRACE();
 
-			return IsValidEstimate() && IsTimeToReduceFurther(atTimeUs, (GetLatestEstimate() / 2) - 1);
+			return IsValidEstimate() && IsTimeToReduceFurther(nowUs, (GetLatestEstimate() / 2) - 1);
 		}
 
 		double AimdRateControl::GetNearMaxIncreaseRateBpsPerSecond() const
@@ -217,7 +217,7 @@ namespace RTC
 			return std::clamp(intervalUs, MinFeedbackIntervalUs, MaxFeedbackIntervalUs);
 		}
 
-		void AimdRateControl::ChangeBitrate(const Types::RateControlInput& input, int64_t atTimeUs)
+		void AimdRateControl::ChangeBitrate(const Types::RateControlInput& input, int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -238,7 +238,7 @@ namespace RTC
 				return;
 			}
 
-			ChangeState(input, atTimeUs);
+			ChangeState(input, nowUs);
 
 			switch (this->rateControlState)
 			{
@@ -288,7 +288,7 @@ namespace RTC
 							  "there is a link capacity estimate but the bitrate was never changed");
 
 							const int64_t additiveIncrease =
-							  AdditiveRateIncrease(atTimeUs, this->timeLastBitrateChangeUs.value());
+							  AdditiveRateIncrease(nowUs, this->timeLastBitrateChangeUs.value());
 
 							increasedBitrate = this->currentBitrate + additiveIncrease;
 						}
@@ -297,7 +297,7 @@ namespace RTC
 							// Without an estimate of the link capacity, ramp up faster to
 							// discover it.
 							const int64_t multiplicativeIncrease = MultiplicativeRateIncrease(
-							  atTimeUs, this->timeLastBitrateChangeUs, this->currentBitrate);
+							  nowUs, this->timeLastBitrateChangeUs, this->currentBitrate);
 
 							increasedBitrate = this->currentBitrate + multiplicativeIncrease;
 						}
@@ -305,7 +305,7 @@ namespace RTC
 						newBitrate = std::min(increasedBitrate, increaseLimit);
 					}
 
-					this->timeLastBitrateChangeUs = atTimeUs;
+					this->timeLastBitrateChangeUs = nowUs;
 
 					break;
 				}
@@ -352,7 +352,7 @@ namespace RTC
 
 					// Stay on hold until the queues of the network are drained.
 					this->rateControlState        = RateControlState::HOLD;
-					this->timeLastBitrateChangeUs = atTimeUs;
+					this->timeLastBitrateChangeUs = nowUs;
 
 					break;
 				}
@@ -363,7 +363,7 @@ namespace RTC
 			this->currentBitrate = ClampBitrate(newBitrate.value_or(this->currentBitrate));
 		}
 
-		void AimdRateControl::ChangeState(const Types::RateControlInput& input, int64_t atTimeUs)
+		void AimdRateControl::ChangeState(const Types::RateControlInput& input, int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -373,7 +373,7 @@ namespace RTC
 				{
 					if (this->rateControlState == RateControlState::HOLD)
 					{
-						this->timeLastBitrateChangeUs = atTimeUs;
+						this->timeLastBitrateChangeUs = nowUs;
 						this->rateControlState        = RateControlState::INCREASE;
 					}
 
@@ -436,7 +436,7 @@ namespace RTC
 		}
 
 		int64_t AimdRateControl::MultiplicativeRateIncrease(
-		  int64_t atTimeUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const
+		  int64_t nowUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const
 		{
 			MS_TRACE();
 
@@ -445,7 +445,7 @@ namespace RTC
 			if (lastTimeUs.has_value())
 			{
 				const double timeSinceLastUpdateSeconds =
-				  static_cast<double>(atTimeUs - lastTimeUs.value()) / 1000000.0;
+				  static_cast<double>(nowUs - lastTimeUs.value()) / 1000000.0;
 
 				alpha = std::pow(alpha, std::min(timeSinceLastUpdateSeconds, 1.0));
 			}
@@ -455,11 +455,11 @@ namespace RTC
 			  MinMultiplicativeIncrease);
 		}
 
-		int64_t AimdRateControl::AdditiveRateIncrease(int64_t atTimeUs, int64_t lastTimeUs) const
+		int64_t AimdRateControl::AdditiveRateIncrease(int64_t nowUs, int64_t lastTimeUs) const
 		{
 			MS_TRACE();
 
-			const double timePeriodSeconds = static_cast<double>(atTimeUs - lastTimeUs) / 1000000.0;
+			const double timePeriodSeconds = static_cast<double>(nowUs - lastTimeUs) / 1000000.0;
 
 			return static_cast<int64_t>(GetNearMaxIncreaseRateBpsPerSecond() * timePeriodSeconds);
 		}

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

@@ -78,7 +78,7 @@ namespace RTC
 			  ackedBitrate, probeBitrate, recoveredFromOveruse, feedback.feedbackTimeUs);
 		}
 
-		void DelayBasedBwe::IncomingPacketFeedback(const Types::PacketResult& packetResult, int64_t atTimeUs)
+		void DelayBasedBwe::IncomingPacketFeedback(const Types::PacketResult& packetResult, int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -91,7 +91,7 @@ namespace RTC
 
 			// Reset if the stream has timed out, since nothing measured before such a
 			// silence still describes this link.
-			if (!this->lastSeenPacketUs.has_value() || atTimeUs - this->lastSeenPacketUs.value() > StreamTimeOutUs)
+			if (!this->lastSeenPacketUs.has_value() || nowUs - this->lastSeenPacketUs.value() > StreamTimeOutUs)
 			{
 				this->videoInterArrivalDelta.emplace(SendTimeGroupLengthUs);
 				this->audioInterArrivalDelta.emplace(SendTimeGroupLengthUs);
@@ -101,7 +101,7 @@ namespace RTC
 				this->activeDelayDetector = std::addressof(this->videoDelayDetector.value());
 			}
 
-			this->lastSeenPacketUs = atTimeUs;
+			this->lastSeenPacketUs = nowUs;
 
 			// As an alternative to ignoring small packets, audio and video can be given
 			// a delay detector of their own.
@@ -148,16 +148,14 @@ namespace RTC
 			    : this->videoInterArrivalDelta.value();
 
 			const auto deltas = interArrivalForPacket.ComputeDeltas(
-			  packetResult.sentPacket.sendTimeUs, receiveTimeUs, atTimeUs, packetResult.sentPacket.size);
+			  packetResult.sentPacket.sendTimeUs, receiveTimeUs, nowUs, packetResult.sentPacket.size);
 
 			if (deltas.has_value())
 			{
+				const auto& deltasValue = deltas.value();
+
 				delayDetectorForPacket->Update(
-				  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-				  deltas.value().sendDeltaUs,
-				  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-				  deltas.value().arrivalDeltaUs,
-				  receiveTimeUs);
+				  deltasValue.sendDeltaUs, deltasValue.arrivalDeltaUs, receiveTimeUs);
 			}
 		}
 
@@ -165,7 +163,7 @@ namespace RTC
 		  std::optional<int64_t> ackedBitrate,
 		  std::optional<int64_t> probeBitrate,
 		  bool recoveredFromOveruse,
-		  int64_t atTimeUs)
+		  int64_t nowUs)
 		{
 			MS_TRACE();
 
@@ -173,19 +171,17 @@ namespace RTC
 
 			if (this->activeDelayDetector->GetState() == Types::BandwidthUsage::OVERUSING)
 			{
-				if (
-				  ackedBitrate.has_value() &&
-				  this->rateControl.IsTimeToReduceFurther(atTimeUs, ackedBitrate.value()))
+				if (ackedBitrate.has_value() && this->rateControl.IsTimeToReduceFurther(nowUs, ackedBitrate.value()))
 				{
-					result.updated = UpdateEstimate(atTimeUs, ackedBitrate, result.targetBitrate);
+					result.updated = UpdateEstimate(nowUs, ackedBitrate, result.targetBitrate);
 				}
 				else if (
 				  !ackedBitrate.has_value() && this->rateControl.IsValidEstimate() &&
-				  this->rateControl.IsInitialTimeToReduceFurther(atTimeUs))
+				  this->rateControl.IsInitialTimeToReduceFurther(nowUs))
 				{
 					// Overusing before any throughput has been measured, so halve the
 					// bitrate instead of aiming at a measurement we don't have.
-					this->rateControl.SetEstimate(this->rateControl.GetLatestEstimate() / 2, atTimeUs);
+					this->rateControl.SetEstimate(this->rateControl.GetLatestEstimate() / 2, nowUs);
 
 					result.updated       = true;
 					result.probe         = false;
@@ -199,13 +195,13 @@ namespace RTC
 					result.probe   = true;
 					result.updated = true;
 
-					this->rateControl.SetEstimate(probeBitrate.value(), atTimeUs);
+					this->rateControl.SetEstimate(probeBitrate.value(), nowUs);
 
 					result.targetBitrate = this->rateControl.GetLatestEstimate();
 				}
 				else
 				{
-					result.updated = UpdateEstimate(atTimeUs, ackedBitrate, result.targetBitrate);
+					result.updated              = UpdateEstimate(nowUs, ackedBitrate, result.targetBitrate);
 					result.recoveredFromOveruse = recoveredFromOveruse;
 				}
 			}
@@ -224,14 +220,14 @@ namespace RTC
 		}
 
 		bool DelayBasedBwe::UpdateEstimate(
-		  int64_t atTimeUs, std::optional<int64_t> ackedBitrate, int64_t& targetBitrate)
+		  int64_t nowUs, std::optional<int64_t> ackedBitrate, int64_t& targetBitrate)
 		{
 			MS_TRACE();
 
 			const Types::RateControlInput input{ .bandwidthUsage = this->activeDelayDetector->GetState(),
 			                                     .estimatedThroughput = ackedBitrate };
 
-			targetBitrate = this->rateControl.Update(input, atTimeUs);
+			targetBitrate = this->rateControl.Update(input, nowUs);
 
 			return this->rateControl.IsValidEstimate();
 		}

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

@@ -16,7 +16,7 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		std::optional<Types::TransportPacketsFeedback> FeedbackAdapter::ProcessTransportFeedback(
+		std::optional<Types::TransportPacketsFeedback> FeedbackAdapter::ProcessTransportWideCcFeedback(
 		  const RTCP::FeedbackRtpTransportPacket* feedback, int64_t receivedAtUs)
 		{
 			MS_TRACE();