mediasoup 3.20.4 → 3.20.6

package/worker/src/RTC/SCTP/packet/Packet.cpp

@@ -419,7 +419,7 @@ namespace RTC
 
 			auto crc32c = GetChecksum();
 
-			// NOTE: Cannot use SetChecksum() because its a `const` method.
+			// NOTE: Cannot use `SetChecksum()` because this is a `const` method.
 			GetHeaderPointer()->checksum = 0;
 
 			auto computedCrc32c = Utils::Crypto::GetCRC32c(GetBuffer(), GetLength());

package/worker/src/RTC/SCTP/packet/parameters/StateCookieParameter.cpp

@@ -122,7 +122,10 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities)
+		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  uint64_t creationTimestampMs,
+		  const uint8_t* macKey,
+		  size_t macKeyLength)
 		{
 			MS_TRACE();
 
@@ -144,9 +147,15 @@ namespace RTC
 			  remoteInitialTsn,
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
-			  negotiatedCapabilities);
+			  negotiatedCapabilities,
+			  creationTimestampMs,
+			  macKey,
+			  macKeyLength);
 
-			SetVariableLengthValueLength(StateCookie::StateCookieLength);
+			const size_t cookieLength = macKey != nullptr ? StateCookie::AuthenticatedStateCookieLength
+			                                              : StateCookie::StateCookieLength;
+
+			SetVariableLengthValueLength(cookieLength);
 		}
 
 		StateCookieParameter* StateCookieParameter::SoftClone(const uint8_t* buffer) const

package/worker/src/RTC/SCTP/public/SctpOptions.cpp

@@ -84,6 +84,10 @@ namespace RTC
 			  ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethodToString(
 			    this->zeroChecksumAlternateErrorDetectionMethod)
 			    .c_str());
+			MS_DUMP_CLEAN(
+			  indentation,
+			  "  require authenticated cookie: %s",
+			  this->requireAuthenticatedCookie ? "yes" : "no");
 			MS_DUMP_CLEAN(indentation, "</SCTP::SctpOptions>");
 		}
 	} // namespace SCTP

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/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/SimpleProducerStreamManager.cpp

@@ -0,0 +1,343 @@
+#define MS_CLASS "RTC::SimpleProducerStreamManager"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SimpleProducerStreamManager.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	/* Instance methods. */
+
+	SimpleProducerStreamManager::SimpleProducerStreamManager(
+	  const std::vector<RTC::RtpEncodingParameters>& consumableRtpEncodings,
+	  const RTC::ConsumerTypes::VideoLayers& preferredLayers,
+	  std::unique_ptr<RTC::RTP::Codecs::EncodingContext> encodingContext,
+	  RTC::Media::Kind kind,
+	  bool keyFrameSupported,
+	  Listener* listener,
+	  SharedInterface* shared)
+	  : ProducerStreamManager(
+	      consumableRtpEncodings,
+	      preferredLayers,
+	      std::move(encodingContext),
+	      kind,
+	      keyFrameSupported,
+	      listener,
+	      shared)
+	{
+		MS_TRACE();
+	}
+
+	RTC::RTP::RtpStreamRecv* SimpleProducerStreamManager::GetProducerCurrentRtpStream() const
+	{
+		MS_TRACE();
+
+		return this->producerRtpStream;
+	}
+
+	RTC::RTP::RtpStreamRecv* SimpleProducerStreamManager::GetProducerTargetRtpStream() const
+	{
+		MS_TRACE();
+
+		return this->producerRtpStream;
+	}
+
+	bool SimpleProducerStreamManager::IsActive() const
+	{
+		MS_TRACE();
+
+		// clang-format off
+		return (
+		  this->listener->IsActive() &&
+		  this->producerRtpStream &&
+		  // If there is no RTP inactivity check do not consider the stream
+		  // inactive despite it has score 0.
+		  (this->producerRtpStream->GetScore() > 0u || !this->producerRtpStream->HasRtpInactivityCheckEnabled())
+		);
+		// clang-format on
+	}
+
+	void SimpleProducerStreamManager::ProducerRtpStream(
+	  RTC::RTP::RtpStreamRecv* rtpStream, uint32_t /*mappedSsrc*/)
+	{
+		MS_TRACE();
+
+		this->producerRtpStream = rtpStream;
+	}
+
+	void SimpleProducerStreamManager::ProducerNewRtpStream(
+	  RTC::RTP::RtpStreamRecv* rtpStream, uint32_t /*mappedSsrc*/)
+	{
+		MS_TRACE();
+
+		this->producerRtpStream = rtpStream;
+
+		// Emit the score event.
+		this->listener->OnProducerStreamManagerScore();
+	}
+
+	void SimpleProducerStreamManager::ProducerRtpStreamScore(
+	  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*score*/, uint8_t /*previousScore*/)
+	{
+		MS_TRACE();
+	}
+
+	void SimpleProducerStreamManager::ProducerRtcpSenderReport(
+	  RTC::RTP::RtpStreamRecv* /*rtpStream*/, bool /*first*/)
+	{
+		MS_TRACE();
+
+		// Do nothing.
+	}
+
+	uint32_t SimpleProducerStreamManager::IncreaseLayer(
+	  uint32_t bitrate, bool /*considerLoss*/, float /*lossPercentage*/, uint64_t nowMs)
+	{
+		MS_TRACE();
+
+		MS_ASSERT(this->externallyManagedBitrate, "bitrate is not externally managed");
+		MS_ASSERT(this->kind == RTC::Media::Kind::VIDEO, "should be video");
+		MS_ASSERT(IsActive(), "should be active");
+
+		// If this is not the first time this method is called within the same
+		// iteration, return 0 since a video Simple consumer does not keep state
+		// about this.
+		if (this->managingBitrate)
+		{
+			return 0u;
+		}
+
+		this->managingBitrate = true;
+
+		if (!this->producerRtpStream)
+		{
+			return 0u;
+		}
+
+		// Video Simple consumer does not really play the BWE game. However, let's
+		// be honest and try to be nice.
+		auto desiredBitrate = this->producerRtpStream->GetBitrate(nowMs);
+
+		if (desiredBitrate < bitrate)
+		{
+			return desiredBitrate;
+		}
+		else
+		{
+			return bitrate;
+		}
+	}
+
+	void SimpleProducerStreamManager::ApplyLayers(uint64_t /*rtpStreamActiveMs*/)
+	{
+		MS_TRACE();
+
+		MS_ASSERT(this->externallyManagedBitrate, "bitrate is not externally managed");
+		MS_ASSERT(this->kind == RTC::Media::Kind::VIDEO, "should be video");
+		MS_ASSERT(IsActive(), "should be active");
+
+		this->managingBitrate = false;
+
+		// Simple does not play the BWE game (even if video kind).
+	}
+
+	uint32_t SimpleProducerStreamManager::GetDesiredBitrate(uint64_t nowMs) const
+	{
+		MS_TRACE();
+
+		MS_ASSERT(this->externallyManagedBitrate, "bitrate is not externally managed");
+
+		// Audio does not play the BWE game.
+		if (this->kind != RTC::Media::Kind::VIDEO)
+		{
+			return 0u;
+		}
+
+		if (!IsActive())
+		{
+			return 0u;
+		}
+
+		return this->producerRtpStream->GetBitrate(nowMs);
+	}
+
+	ProducerStreamManager::RtpPacketProcessResult SimpleProducerStreamManager::ProcessRtpPacket(
+	  RTC::RTP::Packet* packet,
+	  bool /*lastSentPacketHasMarker*/,
+	  uint32_t /*clockRate*/,
+	  uint32_t /*maxPacketTs*/)
+	{
+		MS_TRACE();
+
+		RtpPacketProcessResult result;
+
+		// If we need to sync, support key frames and this is not a key frame,
+		// ignore the packet.
+		if (this->syncRequired && this->keyFrameSupported && !packet->IsKeyFrame())
+		{
+			// NOTE: No need to drop the packet in the RTP sequence manager since here
+			// we are blocking all packets but the key frame that would trigger sync
+			// below.
+
+			// Store the packet for the scenario in which this packet is part of the
+			// key frame and it arrived before the first packet of the key frame.
+			result.type = RtpPacketProcessResult::Type::BUFFER;
+
+#ifdef MS_RTC_LOGGER_RTP
+			packet->logger.Discarded(RTC::RtcLogger::RtpPacket::DiscardReason::NOT_A_KEYFRAME);
+#endif
+
+			return result;
+		}
+
+		// Packets with only padding are not forwarded.
+		if (packet->GetPayloadLength() == 0)
+		{
+			result.type = RtpPacketProcessResult::Type::DROP;
+
+#ifdef MS_RTC_LOGGER_RTP
+			packet->logger.Discarded(RTC::RtcLogger::RtpPacket::DiscardReason::EMPTY_PAYLOAD);
+#endif
+
+			return result;
+		}
+
+		// Preserve the original marker bit. ProcessPayload may update it.
+		bool marker{ packet->HasMarker() };
+
+		// Process the payload if needed. Drop packet if necessary.
+		if (this->encodingContext && !packet->ProcessPayload(this->encodingContext.get(), marker))
+		{
+			MS_DEBUG_DEV(
+			  "discarding packet [ssrc:%" PRIu32 ", seq:%" PRIu16 ", ts:%" PRIu32 "]",
+			  packet->GetSsrc(),
+			  packet->GetSequenceNumber(),
+			  packet->GetTimestamp());
+
+			result.type = RtpPacketProcessResult::Type::DROP;
+
+#ifdef MS_RTC_LOGGER_RTP
+			packet->logger.Discarded(RTC::RtcLogger::RtpPacket::DiscardReason::DROPPED_BY_CODEC);
+#endif
+
+			return result;
+		}
+
+		// Whether this is the first packet after re-sync.
+		const bool isSyncPacket = this->syncRequired;
+
+		// Whether packets stored in the target layer retransmission buffer must be
+		// sent once this packet is sent.
+		bool sendBufferedPackets{ false };
+
+		// Sync sequence number and timestamp if required.
+		if (isSyncPacket)
+		{
+			if (packet->IsKeyFrame())
+			{
+				MS_DEBUG_TAG(
+				  rtp,
+				  "sync key frame received [ssrc:%" PRIu32 ", seq:%" PRIu16 ", ts:%" PRIu32 "]",
+				  packet->GetSsrc(),
+				  packet->GetSequenceNumber(),
+				  packet->GetTimestamp());
+
+				sendBufferedPackets = true;
+			}
+
+			result.isSyncPacket = true;
+			result.syncSeqValue = packet->GetSequenceNumber() - 1;
+
+			this->syncRequired = false;
+		}
+
+		// Set forward action.
+		result.type                = RtpPacketProcessResult::Type::FORWARD;
+		result.tsOffset            = 0u;
+		result.marker              = marker;
+		result.sendBufferedPackets = sendBufferedPackets;
+
+		return result;
+	}
+
+	void SimpleProducerStreamManager::RequestKeyFrame()
+	{
+		MS_TRACE();
+
+		if (this->kind != RTC::Media::Kind::VIDEO)
+		{
+			return;
+		}
+
+		auto mappedSsrc = this->consumableRtpEncodings[0].ssrc;
+
+		this->listener->OnProducerStreamManagerKeyFrameRequested(mappedSsrc);
+	}
+
+	void SimpleProducerStreamManager::RequestKeyFrameForTargetSpatialLayer()
+	{
+		MS_TRACE();
+
+		RequestKeyFrame();
+	}
+
+	void SimpleProducerStreamManager::RequestKeyFrameForCurrentSpatialLayer()
+	{
+		MS_TRACE();
+
+		RequestKeyFrame();
+	}
+
+	void SimpleProducerStreamManager::UpdateTargetLayers(int16_t /*spatial*/, int16_t /*temporal*/)
+	{
+		MS_TRACE();
+	}
+
+	bool SimpleProducerStreamManager::RecalculateTargetLayers(
+	  RTC::ConsumerTypes::VideoLayers& /*newTargetLayers*/) const
+	{
+		MS_TRACE();
+
+		// No layer changes possible for Simple.
+		return false;
+	}
+
+	void SimpleProducerStreamManager::OnTransportConnected()
+	{
+		MS_TRACE();
+
+		this->syncRequired = true;
+
+		if (IsActive())
+		{
+			RequestKeyFrame();
+		}
+	}
+
+	void SimpleProducerStreamManager::OnTransportDisconnected()
+	{
+		MS_TRACE();
+
+		// Nothing specific for Simple.
+	}
+
+	void SimpleProducerStreamManager::OnPaused()
+	{
+		MS_TRACE();
+
+		// Nothing specific for Simple.
+	}
+
+	void SimpleProducerStreamManager::OnResumed()
+	{
+		MS_TRACE();
+
+		this->syncRequired = true;
+
+		if (IsActive())
+		{
+			RequestKeyFrame();
+		}
+	}
+
+} // namespace RTC