mediasoup 3.27.0 → 3.28.0

package/worker/src/RTC/RateCalculator.cpp

@@ -8,12 +8,23 @@
 
 namespace RTC
 {
+	/* Static. */
+
+	// Factor of the window size within which the latest sample still counts as
+	// recent.
+	static constexpr double RecentSampleMarginFactor{ 1.5 };
+
+	/* Instance methods. */
+
 	RateCalculator::RateCalculator(int64_t windowSizeMs, float scale, uint16_t windowItems)
 	{
 		MS_TRACE();
 
 		// Clamp the given values so every derived value is safe to use.
-		this->windowSizeMs = std::max<int64_t>(windowSizeMs, 1);
+		// NOTE: The upper bound is what keeps one window and a half, which is the
+		// margin computed at the end, within an int64_t.
+		this->windowSizeMs =
+		  std::clamp<int64_t>(windowSizeMs, 1, std::numeric_limits<int64_t>::max() / 2);
 
 		const int64_t items = std::max<int64_t>(windowItems, 1);
 
@@ -28,36 +39,73 @@ namespace RTC
 		this->buffer.resize(
 		  static_cast<size_t>((this->windowSizeMs + this->itemSizeMs - 1) / this->itemSizeMs));
 
-		this->rateScale = static_cast<double>(scale) / static_cast<double>(this->windowSizeMs);
+		// NOTE: A negative scale would give negative rates, which whoever reads them
+		// takes as a count of bits.
+		this->scale = std::max(static_cast<double>(scale), 0.0);
+
+		this->recentSampleMarginMs =
+		  static_cast<int64_t>(RecentSampleMarginFactor * static_cast<double>(this->windowSizeMs));
 	}
 
 	void RateCalculator::Update(size_t size, int64_t nowMs)
 	{
 		MS_TRACE();
 
-		// Ignore data older than the window. Should never happen.
+		// Whether the window still held data when this sample arrived, and the sample
+		// before it is recent enough for both to be taken as the same stretch of
+		// traffic.
+		// NOTE: Must be told before sliding the window, since sliding it is what
+		// expires that data.
+		const bool lastSampleIsRecent =
+		  this->totalSamples != 0 && this->lastSampleTimeMs.has_value() &&
+		  this->lastSampleTimeMs.value() > nowMs - this->recentSampleMarginMs;
+
+		// A sample whose instant lies before the whole window is still data that
+		// went through, so it is taken as if it had been given at the instant the
+		// newest item starts at. Dropping it would leave the meter reporting less
+		// than what flowed with nobody able to tell, while placing it at the wrong
+		// instant is an error bounded by the window.
 		if (!SlideWindow(nowMs))
 		{
-			MS_WARN_DEV("given nowMs is older than the current window, ignoring data");
+			MS_WARN_DEV("given nowMs is older than the current window, taking the data as newer");
+
+			nowMs = this->newestItemStartTimeMs;
+		}
 
-			return;
+		// The very first sample starts the measured period, and so does one that
+		// finds the window empty after long enough without traffic. A stream that
+		// just sends less often than the window keeps the period it had, so that it
+		// is measured over the window instead of restarting at every sample and
+		// hence never being measured at all.
+		if (!this->firstSampleTimeMs.has_value() || (this->totalSamples == 0 && !lastSampleIsRecent))
+		{
+			this->firstSampleTimeMs = nowMs;
+			this->firstSampleCount  = size;
 		}
 
-		this->buffer[this->newestItemIndex] += size;
+		Item& item = this->buffer[this->newestItemIndex];
+
+		item.count += size;
+		item.samples++;
+
 		this->totalCount += size;
+		this->totalSamples++;
 		this->bytes += size;
+		this->lastSampleTimeMs = nowMs;
 	}
 
-	int64_t RateCalculator::GetRate(int64_t nowMs)
+	std::optional<int64_t> RateCalculator::GetRate(int64_t nowMs)
 	{
 		MS_TRACE();
 
-		// If both keys match, the memoized rate is still exact. `lastRate` is a pure
-		// function of `totalCount`, so the value is right, and no expiration can be
-		// pending: SlideWindow() already ran for this very `nowMs` and
-		// `newestItemStartTimeMs` only moves forward afterwards, while the initial and
-		// post Reset() state has an empty ring anyway.
-		if (nowMs == this->lastTimeMs && this->totalCount == this->lastTotalCount)
+		// If every key matches, the memoized rate is still exact. `lastRate` is a
+		// pure function of the state the keys cover, so the value is right, and no
+		// expiration can be pending: SlideWindow() already ran for this very `nowMs`
+		// and `newestItemStartTimeMs` only moves forward afterwards, while the
+		// initial and post Reset() state has an empty ring anyway.
+		if (
+		  nowMs == this->lastTimeMs && this->totalCount == this->lastTotalCount &&
+		  this->totalSamples == this->lastTotalSamples)
 		{
 			MS_DEBUG_DEV("nothing changed since the latest call, early return");
 
@@ -66,13 +114,61 @@ namespace RTC
 
 		SlideWindow(nowMs);
 
-		const double rate = std::trunc((static_cast<double>(this->totalCount) * this->rateScale) + 0.5);
-
 		// NOTE: Must be read after SlideWindow(), which may have expired data.
-		this->lastTotalCount = this->totalCount;
-		this->lastTimeMs     = nowMs;
-		this->lastRate =
-		  static_cast<int64_t>(std::min(rate, static_cast<double>(std::numeric_limits<int64_t>::max())));
+		this->lastTotalCount   = this->totalCount;
+		this->lastTotalSamples = this->totalSamples;
+		this->lastTimeMs       = nowMs;
+		this->lastRate         = std::nullopt;
+
+		// Either no sample has ever been taken, or none of them is still within the
+		// window.
+		if (!this->firstSampleTimeMs.has_value() || this->totalSamples == 0)
+		{
+			return this->lastRate;
+		}
+
+		// Period the data within the window actually spans. The instant the first
+		// sample was taken at already counts as a millisecond, hence the increment,
+		// which is also what keeps this from ever being zero. And once the data
+		// reaches back beyond the window, the period is the window itself.
+		const int64_t periodMs =
+		  std::clamp<int64_t>(nowMs - this->firstSampleTimeMs.value() + 1, 1, this->windowSizeMs);
+
+		// A single millisecond gives no duration to divide by, and a single sample
+		// says how much data was taken at an instant but nothing about how fast it
+		// is flowing, so neither is a measurement until the window has filled.
+		if (periodMs <= 1 || (this->totalSamples <= 1 && periodMs < this->windowSizeMs))
+		{
+			return this->lastRate;
+		}
+
+		// While the period is anchored to a sample, that sample sits at its very
+		// start, so the period does not cover the time that sample took to arrive and
+		// its data is not part of what flowed during it. Counting it would report a
+		// rate too high by as much as the ratio of samples to gaps between them,
+		// which is double with two samples and a tenth with eleven.
+		//
+		// NOTE: Once the period is the whole window it is no longer anchored to any
+		// sample, all of them fall inside it, and every one of them counts. And that
+		// is also the point at which the anchoring sample has left the window, so
+		// there is nothing of it left to leave out.
+		const uint64_t count =
+		  periodMs < this->windowSizeMs ? this->totalCount - this->firstSampleCount : this->totalCount;
+
+		const double rate =
+		  std::trunc(((static_cast<double>(count) * this->scale) / static_cast<double>(periodMs)) + 0.5);
+
+		// A rate that does not fit is no rate at all, which is better than the
+		// garbage that converting it would give.
+		// NOTE: The comparison is not a strict one because converting the maximum of
+		// int64_t to double rounds it up, so a rate equal to that value is already
+		// out of range.
+		if (rate >= static_cast<double>(std::numeric_limits<int64_t>::max()))
+		{
+			return this->lastRate;
+		}
+
+		this->lastRate = static_cast<int64_t>(rate);
 
 		return this->lastRate;
 	}
@@ -81,14 +177,19 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		std::ranges::fill(this->buffer, 0);
+		std::ranges::fill(this->buffer, Item{});
 
+		this->firstSampleTimeMs.reset();
+		this->firstSampleCount = 0;
+		this->lastSampleTimeMs.reset();
 		this->newestItemIndex       = 0;
 		this->newestItemStartTimeMs = 0;
 		this->totalCount            = 0;
-		this->lastRate              = 0;
+		this->totalSamples          = 0;
+		this->lastRate              = std::nullopt;
 		this->lastTimeMs            = 0;
 		this->lastTotalCount        = 0;
+		this->lastTotalSamples      = 0;
 	}
 
 	/**
@@ -127,13 +228,14 @@ namespace RTC
 		{
 			MS_DEBUG_DEV("a whole window elapsed, resetting every item");
 
-			// NOTE: totalCount is the sum of every item, so a zero total means that
-			// the ring is already zeroed.
-			if (this->totalCount != 0)
+			// NOTE: totalSamples is the sum of the samples of every item, so a zero
+			// total means that the ring is already empty.
+			if (this->totalSamples != 0)
 			{
-				std::ranges::fill(this->buffer, 0);
+				std::ranges::fill(this->buffer, Item{});
 
-				this->totalCount = 0;
+				this->totalCount   = 0;
+				this->totalSamples = 0;
 			}
 
 			this->newestItemIndex       = 0;
@@ -151,9 +253,12 @@ namespace RTC
 				this->newestItemIndex = 0;
 			}
 
-			this->totalCount -= this->buffer[this->newestItemIndex];
+			Item& item = this->buffer[this->newestItemIndex];
+
+			this->totalCount -= item.count;
+			this->totalSamples -= item.samples;
 
-			this->buffer[this->newestItemIndex] = 0;
+			item = Item{};
 		}
 
 		// Advance by whole items rather than jumping to `nowMs`. The window is

package/worker/src/RTC/RemoteCaptureTimeEstimator.cpp

@@ -3,9 +3,18 @@
 
 #include "RTC/RemoteCaptureTimeEstimator.hpp"
 #include "Logger.hpp"
+#include "Utils.hpp"
 
 namespace RTC
 {
+	/* Static. */
+
+	// How long a sender that negotiated 'abs-capture-time' may go without sending it
+	// before the capture instant is read from its Sender Reports instead. It only has
+	// to outlast the first packets of a sender that does send it, since the extension
+	// travels on some of them rather than on every one.
+	static constexpr int64_t AbsCaptureTimeTimeoutMs{ 5 * 1000 };
+
 	/* Instance methods. */
 
 	void RemoteCaptureTimeEstimator::UpdateSource(bool absCaptureTimeNegotiated)
@@ -34,6 +43,50 @@ namespace RTC
 			                                                                     : "Sender Report");
 	}
 
+	void RemoteCaptureTimeEstimator::MayFallBackToSenderReport(
+	  const RTC::RTP::RtpStreamRecv* rtpStream, int64_t nowUs)
+	{
+		MS_TRACE();
+
+		if (this->source != RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME)
+		{
+			return;
+		}
+
+		// Some stream of this sender has carried the extension at some point, so it is
+		// being sent and whatever stream has none of it is just early.
+		if (this->absCaptureTimeReceived)
+		{
+			return;
+		}
+
+		if (rtpStream->HasAbsCaptureTime())
+		{
+			this->absCaptureTimeReceived = true;
+
+			return;
+		}
+
+		if (!this->firstPacketAtUs.has_value())
+		{
+			this->firstPacketAtUs = nowUs;
+
+			return;
+		}
+
+		if (Utils::Time::TimeUsToMs(nowUs - this->firstPacketAtUs.value()) < AbsCaptureTimeTimeoutMs)
+		{
+			return;
+		}
+
+		MS_WARN_2TAGS(
+		  rtp,
+		  rtcp,
+		  "abs-capture-time negotiated but never received, reading the capture instant from Sender Reports instead");
+
+		this->source = RemoteCaptureTimeEstimator::Source::SENDER_REPORT;
+	}
+
 	void RemoteCaptureTimeEstimator::SenderReportReceived(const RTC::RTP::RtpStreamRecv* rtpStream)
 	{
 		MS_TRACE();
@@ -54,7 +107,7 @@ namespace RTC
 	}
 
 	std::optional<int64_t> RemoteCaptureTimeEstimator::GetLocalCaptureAtUs(
-	  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const
+	  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts, int64_t nowUs)
 	{
 		MS_TRACE();
 
@@ -63,6 +116,8 @@ namespace RTC
 			return std::nullopt;
 		}
 
+		MayFallBackToSenderReport(rtpStream, nowUs);
+
 		const auto remoteCaptureAtUs = this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME
 		                                 ? rtpStream->GetRemoteCaptureAtUsFromAbsCaptureTime(ts)
 		                                 : rtpStream->GetRemoteCaptureAtUsFromSenderReport(ts);

package/worker/src/RTC/{RtcLogger.cpp → RtcLogger/RtpPacket.cpp}

@@ -1,7 +1,7 @@
-#define MS_CLASS "RTC::RtcLogger"
+#define MS_CLASS "RTC::RtcLogger::RtpPacket"
 // #define MS_LOG_DEV_LEVEL 3
 
-#include "RTC/RtcLogger.hpp"
+#include "RTC/RtcLogger/RtpPacket.hpp"
 #include "Logger.hpp"
 #include <sstream>
 

package/worker/src/RTC/RtcLogger/SendBurst.cpp

@@ -0,0 +1,124 @@
+#define MS_CLASS "RTC::RtcLogger::SendBurst"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/RtcLogger/SendBurst.hpp"
+#include "Logger.hpp"
+#include <sstream>
+
+namespace RTC
+{
+	namespace RtcLogger
+	{
+		/* Instance methods. */
+
+		void SendBurst::Sent(uint64_t loopTimeMs, size_t length, bool isRetransmission, bool isProbation)
+		{
+			MS_TRACE();
+
+			if (loopTimeMs != this->loopTimeMs)
+			{
+				CloseBurst();
+
+				this->loopTimeMs = loopTimeMs;
+			}
+
+			this->packets++;
+			this->bytes += length;
+
+			if (isRetransmission)
+			{
+				this->retransmissions++;
+			}
+
+			if (isProbation)
+			{
+				this->probations++;
+			}
+		}
+
+		void SendBurst::Log()
+		{
+			MS_TRACE();
+
+			// The iteration this runs in is not the one any burst belongs to, so whatever
+			// is in progress is already complete.
+			CloseBurst();
+
+			// Nothing has been sent since the last time, and a transport that sends
+			// nothing has nothing to say.
+			if (this->maxPackets == 0)
+			{
+				return;
+			}
+
+			std::stringstream ss;
+
+			ss << "{";
+			ss << R"("transportId": ")" << this->transportId << "\"";
+			ss << ", \"maxPackets\": " << this->maxPackets;
+			ss << ", \"maxBytes\": " << this->maxBytes;
+			ss << ", \"bursts\": [";
+
+			bool first{ true };
+
+			for (const auto& kv : this->bursts)
+			{
+				const auto packets   = kv.first;
+				const auto& counters = kv.second;
+
+				if (!first)
+				{
+					ss << ", ";
+				}
+
+				first = false;
+
+				ss << "{\"packets\": " << packets;
+				ss << ", \"count\": " << counters.count;
+				ss << ", \"retransmissions\": " << counters.retransmissions;
+				ss << ", \"probations\": " << counters.probations;
+				ss << "}";
+			}
+
+			ss << "]}";
+
+			MS_DUMP_CLEAN(0, "%s", ss.str().c_str());
+
+			Clear();
+		}
+
+		void SendBurst::CloseBurst()
+		{
+			MS_TRACE();
+
+			if (this->packets == 0)
+			{
+				return;
+			}
+
+			auto& counters = this->bursts[this->packets];
+
+			counters.count++;
+			counters.retransmissions += this->retransmissions;
+			counters.probations += this->probations;
+
+			this->maxPackets = std::max(this->maxPackets, this->packets);
+			this->maxBytes   = std::max(this->maxBytes, this->bytes);
+
+			this->packets         = 0;
+			this->retransmissions = 0;
+			this->probations      = 0;
+			this->bytes           = 0;
+		}
+
+		void SendBurst::Clear()
+		{
+			MS_TRACE();
+
+			this->bursts.clear();
+
+			this->maxPackets = 0;
+			this->maxBytes   = 0;
+		}
+	} // namespace RtcLogger
+} // namespace RTC

package/worker/src/RTC/RtpDictionaries/RtpHeaderExtensionUri.cpp

@@ -50,11 +50,6 @@ namespace RTC
 				return RtpHeaderExtensionUri::Type::VIDEO_ORIENTATION;
 			}
 
-			case FBS::RtpParameters::RtpHeaderExtensionUri::TimeOffset:
-			{
-				return RtpHeaderExtensionUri::Type::TIME_OFFSET;
-			}
-
 			case FBS::RtpParameters::RtpHeaderExtensionUri::PlayoutDelay:
 			{
 				return RtpHeaderExtensionUri::Type::PLAYOUT_DELAY;
@@ -75,7 +70,7 @@ namespace RTC
 				return RtpHeaderExtensionUri::Type::MEDIASOUP_PACKET_ID;
 			}
 
-				NO_DEFAULT_GCC();
+				NO_DEFAULT();
 		}
 	}
 
@@ -126,11 +121,6 @@ namespace RTC
 				return FBS::RtpParameters::RtpHeaderExtensionUri::VideoOrientation;
 			}
 
-			case RtpHeaderExtensionUri::Type::TIME_OFFSET:
-			{
-				return FBS::RtpParameters::RtpHeaderExtensionUri::TimeOffset;
-			}
-
 			case RtpHeaderExtensionUri::Type::ABS_CAPTURE_TIME:
 			{
 				return FBS::RtpParameters::RtpHeaderExtensionUri::AbsCaptureTime;
@@ -146,7 +136,7 @@ namespace RTC
 				return FBS::RtpParameters::RtpHeaderExtensionUri::MediasoupPacketId;
 			}
 
-				NO_DEFAULT_GCC();
+				NO_DEFAULT();
 		}
 	}
 

package/worker/src/RTC/RtpDictionaries/RtpParameters.cpp

@@ -92,7 +92,7 @@ namespace RTC
 				return FBS::RtpParameters::Type::PIPE;
 			}
 
-				NO_DEFAULT_GCC();
+				NO_DEFAULT();
 		}
 	}
 

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -107,7 +107,7 @@ namespace RTC
 			MS_TRACE();
 
 			const auto stateStringView = Association::StateToString(this->state);
-			const auto associationStateStringView = Types::AssociationStateToString(GetAssociationState());
+			const auto associationStateStringView = Types::associationStateToString(GetAssociationState());
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::Association>");
 
@@ -187,7 +187,7 @@ namespace RTC
 					return Types::AssociationState::SHUTTING_DOWN;
 				}
 
-					NO_DEFAULT_GCC();
+					NO_DEFAULT();
 			}
 		}
 
@@ -608,6 +608,20 @@ namespace RTC
 
 			if (this->tcb)
 			{
+				// The cumulative ack TSN may have advanced while processing the chunks
+				// in this packet, which may be what deferred reset processing (if any)
+				// was waiting for.
+				if (this->tcb->GetStreamResetHandler().MayLeaveDeferredReset())
+				{
+					// There may be chunks to deliver that were queued while waiting for
+					// the streams to reset.
+					//
+					// NOTE: Both this and the above are done before sending the SACK chunk
+					// below so that its advertised receiver window credit accounts for the
+					// released and delivered data.
+					MayDeliverMessages();
+				}
+
 				this->tcb->GetDataTracker().ObservePacketEnd();
 				this->tcb->MaySendSackChunk();
 			}

package/worker/src/RTC/SCTP/association/StreamResetHandler.cpp

@@ -143,6 +143,63 @@ namespace RTC
 			}
 		}
 
+		bool StreamResetHandler::MayLeaveDeferredReset()
+		{
+			MS_TRACE();
+
+			if (!this->deferredIncomingRequest.has_value())
+			{
+				return false;
+			}
+
+			// https://tools.ietf.org/html/rfc6525#section-5.2.2
+			//
+			// "In this mode, any data arriving with a TSN larger than the Sender's
+			// Last Assigned TSN for the affected stream(s) MUST be queued locally and
+			// held until the cumulative acknowledgment point reaches the Sender's Last
+			// Assigned TSN."
+			//
+			// So deferred reset processing must end as soon as the cumulative ack TSN
+			// reaches the sender's last assigned TSN. Otherwise the queued data would
+			// be held (and accounted for) until the peer decides to retransmit its
+			// request, which it may never do.
+			if (this->dataTracker->IsLaterThanCumulativeAckedTsn(this->deferredIncomingRequest->senderLastAssignedTsn))
+			{
+				return false;
+			}
+
+			MS_DEBUG_DEV(
+			  "leaving deferred reset processing, sender last assigned tsn %" PRIu32 " reached",
+			  this->deferredIncomingRequest->senderLastAssignedTsn);
+
+			// Remember the request being performed here. The peer was told "in
+			// progress" and will retry it with a new request sequence number, and that
+			// retry must not reset the very same streams a second time.
+			this->performedDeferredRequest = std::move(this->deferredIncomingRequest);
+
+			this->deferredIncomingRequest = std::nullopt;
+
+			// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+			const auto& streamIds = this->performedDeferredRequest.value().streamIds;
+
+			// https://tools.ietf.org/html/rfc6525#section-5.2.2
+			//
+			// E3) "If no stream numbers are listed in the parameter, then all incoming
+			// streams MUST be reset to 0 as the next expected SSN. If specific stream
+			// numbers are listed, then only these specific streams MUST be reset to 0,
+			// and all other non-listed SSNs remain unchanged." E4: "Any queued TSNs
+			// (queued at step E2) MUST now be released and processed normally."
+			this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(streamIds);
+
+			this->associationListenerDeferrer.OnAssociationInboundStreamsReset(streamIds);
+
+			// The request has now been performed, so a retransmission of it must get
+			// the final response rather than "in progress" again.
+			this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
+
+			return true;
+		}
+
 		bool StreamResetHandler::ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
@@ -284,6 +341,11 @@ namespace RTC
 			  validationResult == ReqSeqNbrValidationResult::RETRANSMISSION &&
 			  this->lastProcessedReqResult != ReconfigurationResponseParameter::Result::IN_PROGRESS)
 			{
+				// The peer is getting the final result of this request, so there is no
+				// longer a need to remember that it may have been performed when leaving
+				// deferred reset processing.
+				this->performedDeferredRequest = std::nullopt;
+
 				auto* reconfigurationResponseParameter =
 				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
 
@@ -301,7 +363,33 @@ namespace RTC
 			// "In Progress" request. In all cases, re-evaluate the state.
 			this->lastProcessedReqSeqNbr = requestSn;
 
-			if (
+			// This very same request may have already been performed when the
+			// cumulative ack TSN reached its sender's last assigned TSN. The peer was
+			// told "in progress" and doesn't know it yet, so it retries it with a new
+			// request sequence number. Resetting those streams again would set their
+			// next expected SSN back to 0 after post reset data may have already been
+			// received, so just reply the final result.
+			const bool alreadyPerformed =
+			  this->performedDeferredRequest.has_value() &&
+			  this->performedDeferredRequest->senderLastAssignedTsn ==
+			    receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn() &&
+			  this->performedDeferredRequest->streamIds ==
+			    receivedOutgoingSsnResetRequestParameter->GetStreamIds();
+
+			this->performedDeferredRequest = std::nullopt;
+
+			if (alreadyPerformed)
+			{
+				// Set the result again rather than relying on the one stored when the
+				// reset was performed, since a received incoming stream reset request
+				// may have overwritten it in the meantime.
+				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
+
+				MS_DEBUG_DEV(
+				  "reset outgoing already performed when leaving deferred reset processing, sender last assigned tsn %" PRIu32,
+				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
+			}
+			else if (
 			  this->dataTracker->IsLaterThanCumulativeAckedTsn(
 			    receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn()))
 			{
@@ -314,6 +402,21 @@ namespace RTC
 				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
+				// Remember the request so that deferred reset processing can end as soon
+				// as the cumulative ack TSN reaches the sender's last assigned TSN,
+				// without depending on the peer retransmitting its request.
+				//
+				// NOTE: Just like ReassemblyQueue::EnterDeferredReset() does, a new
+				// request is ignored while already in deferred reset processing.
+				if (!this->deferredIncomingRequest.has_value())
+				{
+					this->deferredIncomingRequest = DeferredIncomingRequest{
+						.senderLastAssignedTsn =
+						  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
+						.streamIds = receivedOutgoingSsnResetRequestParameter->GetStreamIds(),
+					};
+				}
+
 				// "If the endpoint enters 'deferred reset processing', it MUST put a
 				// Re-configuration Response Parameter into a RE-CONFIG chunk indicating
 				// 'In progress' and MUST send the RE-CONFIG chunk.
@@ -335,6 +438,8 @@ namespace RTC
 				this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
+				this->deferredIncomingRequest = std::nullopt;
+
 				this->associationListenerDeferrer.OnAssociationInboundStreamsReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());