mediasoup 3.20.3 → 3.20.5

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

@@ -21,6 +21,7 @@ namespace RTC
 		/* Instance methods. */
 
 		TransmissionControlBlock::TransmissionControlBlock(
+		  TransmissionControlBlockContextInterface::Listener* listener,
 		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  const SctpOptions& sctpOptions,
 		  SharedInterface* shared,
@@ -35,7 +36,8 @@ namespace RTC
 		  const NegotiatedCapabilities& negotiatedCapabilities,
 		  size_t maxPacketLength,
 		  std::function<bool()> isAssociationEstablished)
-		  : associationListenerDeferrer(associationListenerDeferrer),
+		  : listener(listener),
+		    associationListenerDeferrer(associationListenerDeferrer),
 		    sctpOptions(sctpOptions),
 		    shared(shared),
 		    packetSender(packetSender),
@@ -407,10 +409,19 @@ namespace RTC
 			}
 		}
 
-		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& stop)
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->t3RtxTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->t3RtxTimer->GetLabel().c_str(),
+			  this->t3RtxTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			// This is a top-level timer entry point (invoked by libuv outside any other
 			// SCTP API call), so it must establish the deferrer scope itself, just like
 			// Association does in its own timer handlers.
@@ -432,6 +443,15 @@ namespace RTC
 
 					SendBufferedPackets(nowMs);
 				}
+				else
+				{
+					// `IncrementTxErrorCounter()` has closed (and destroyed) this TCB and
+					// its timers. Signal the firing timer to stop and don't touch any
+					// member afterwards.
+					stop = true;
+
+					return;
+				}
 			}
 		}
 
@@ -439,6 +459,18 @@ namespace RTC
 		{
 			MS_TRACE();
 
+#if MS_LOG_DEV_LEVEL == 3
+			const auto maxRestarts = this->delayedAckTimer->GetMaxRestarts();
+#endif
+
+			// NOTE: This timer expires very frequently (whenever received data is
+			// pending to be acked), so it's logged at dev level to avoid being noisy.
+			MS_DEBUG_DEV(
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->delayedAckTimer->GetLabel().c_str(),
+			  this->delayedAckTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			// This is a top-level timer entry point (invoked by libuv outside any other
 			// SCTP API call), so it must establish the deferrer scope itself, just like
 			// Association does in its own timer handlers.
@@ -454,15 +486,6 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = backoffTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "%s timer has expired [expìrations:%zu/%s]",
-			  backoffTimer->GetLabel().c_str(),
-			  backoffTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
-
 			if (backoffTimer == this->t3RtxTimer.get())
 			{
 				OnT3RtxTimer(baseTimeoutMs, stop);

package/worker/src/RTC/SCTP/rx/DataTracker.cpp

@@ -268,7 +268,9 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			UpdateAckState(AckState::IMMEDIATE, "force immediate SACK");
+			// NOTE: Assign directly instead of going through UpdateAckState() to avoid
+			// its side effect of stopping the delayed-ack timer.
+			this->ackState = AckState::IMMEDIATE;
 		}
 
 		bool DataTracker::WillIncreaseCumAckTsn(uint32_t tsn) const
@@ -359,6 +361,7 @@ namespace RTC
 				{
 					this->delayedAckTimer->Start();
 				}
+
 				this->ackState = newAckState;
 			}
 		}

package/worker/src/RTC/SCTP/rx/ReassemblyQueue.cpp

@@ -140,12 +140,16 @@ namespace RTC
 			{
 				MS_DEBUG_DEV("forward TSN to %" PRIu32 ", deferring", tsn.Wrap());
 
+				this->queuedBytes += ForwardTsnCost(skippedStreams.size());
+
 				this->deferredResetStreams->deferredActions.emplace_back(
 				  [this,
 				   newCumulativeTsn,
 				   skippedStreams2 = std::vector<AnyForwardTsnChunk::SkippedStream>(
 				     skippedStreams.begin(), skippedStreams.end())]
 				  {
+					  this->queuedBytes -= ForwardTsnCost(skippedStreams2.size());
+
 					  HandleForwardTsn(newCumulativeTsn, skippedStreams2);
 				  });
 
@@ -216,15 +220,13 @@ namespace RTC
 
 			if (!this->deferredResetStreams.has_value())
 			{
-				return;
-			}
-
-			MS_DEBUG_DEV(
-			  "entering deferred reset [senderLastAssignedTsn:%" PRIu32 "]", senderLastAssignedTsn);
+				MS_DEBUG_DEV(
+				  "entering deferred reset [senderLastAssignedTsn:%" PRIu32 "]", senderLastAssignedTsn);
 
-			this->deferredResetStreams = std::make_optional<DeferredResetStreams>(
-			  this->tsnUnwrapper.Unwrap(senderLastAssignedTsn),
-			  std::set<uint16_t>(streamIds.begin(), streamIds.end()));
+				this->deferredResetStreams = std::make_optional<DeferredResetStreams>(
+				  this->tsnUnwrapper.Unwrap(senderLastAssignedTsn),
+				  std::set<uint16_t>(streamIds.begin(), streamIds.end()));
+			}
 
 			AssertIsConsistent();
 		}
@@ -244,6 +246,13 @@ namespace RTC
 			}
 		}
 
+		size_t ReassemblyQueue::ForwardTsnCost(size_t numStreams)
+		{
+			MS_TRACE();
+
+			return (1 + numStreams) * 4;
+		}
+
 		void ReassemblyQueue::AddReassembledMessage(std::span<const Types::UnwrappedTsn> tsns, Message message)
 		{
 			MS_TRACE();

package/worker/src/RTC/SeqManager.cpp

@@ -63,9 +63,15 @@ namespace RTC
 		{
 			this->maxInput   = input;
 			this->maxDropped = input;
-			// Insert input in the last position.
-			// Explicitly insert at the end, which is more performant.
-			this->dropped.insert(this->dropped.end(), input);
+			// Insert input in sorted order, if not present.
+			const SeqLowerThan seqLowerThan;
+			const auto it =
+			  std::lower_bound(this->dropped.begin(), this->dropped.end(), input, seqLowerThan);
+
+			if (it == this->dropped.end() || *it != input)
+			{
+				this->dropped.insert(it, input);
+			}
 
 			ClearDropped();
 		}
@@ -74,7 +80,15 @@ namespace RTC
 		// Allows for properly accounting for out of order drops until an input is forwarded.
 		else if (this->maxInput == this->maxDropped && SeqManager<T, N>::IsSeqHigherThan(input, this->maxForwarded))
 		{
-			this->dropped.insert(input);
+			// Insert input in sorted order, if not present.
+			const SeqLowerThan seqLowerThan;
+			const auto it =
+			  std::lower_bound(this->dropped.begin(), this->dropped.end(), input, seqLowerThan);
+
+			if (it == this->dropped.end() || *it != input)
+			{
+				this->dropped.insert(it, input);
+			}
 
 			ClearDropped();
 		}
@@ -112,22 +126,24 @@ namespace RTC
 		{
 			goto done;
 		}
-		// This input was dropped.
-		else if (this->dropped.find(input) != this->dropped.end())
-		{
-			MS_DEBUG_DEV("trying to send a dropped input");
-
-			return false;
-		}
-		// There are dropped inputs, calculate 'base' for this input.
 		else
 		{
-			auto droppedCount = this->dropped.size();
+			const SeqLowerThan seqLowerThan;
+			const auto it =
+			  std::lower_bound(this->dropped.begin(), this->dropped.end(), input, seqLowerThan);
 
-			// Get the first dropped input which is higher than or equal 'input'.
-			auto it = this->dropped.lower_bound(input);
+			if (it != this->dropped.end() && *it == input)
+			{
+				MS_DEBUG_DEV("trying to send a dropped input");
+
+				return false;
+			}
+
+			// There are dropped inputs, calculate 'base' for this input.
+			auto droppedCount = std::distance(
+			  this->dropped.begin(),
+			  std::lower_bound(this->dropped.begin(), this->dropped.end(), input, SeqLowerThan()));
 
-			droppedCount -= std::distance(it, this->dropped.end());
 			base = (this->base - droppedCount) & SeqManager::MaxValue;
 		}
 
@@ -191,19 +207,16 @@ namespace RTC
 
 		const size_t previousDroppedSize = this->dropped.size();
 
-		for (auto it = this->dropped.begin(); it != this->dropped.end();)
-		{
-			auto value = *it;
-
-			if (SeqManager<T, N>::IsSeqHigherThan(value, this->maxInput))
-			{
-				it = this->dropped.erase(it);
-			}
-			else
-			{
-				break;
-			}
-		}
+		// Cleanup dropped values.
+		this->dropped.erase(
+		  this->dropped.begin(),
+		  std::find_if(
+		    this->dropped.begin(),
+		    this->dropped.end(),
+		    [this](T value)
+		    {
+			    return !SeqManager<T, N>::IsSeqHigherThan(value, this->maxInput);
+		    }));
 
 		// Adapt base.
 		this->base = (this->base - (previousDroppedSize - this->dropped.size())) & SeqManager::MaxValue;

package/worker/src/RTC/Transport.cpp

@@ -91,7 +91,7 @@ namespace RTC
 			};
 
 			this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(
-			  sctpOptions, this, this->shared, options->isDataChannel());
+			  sctpOptions, this, this->shared, options->isDataChannel(), /*mayConnectOnReceivedSctpData*/ true);
 		}
 
 		// Create the RTCP timer.