mediasoup 3.20.4 → 3.20.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.20.4",
+	"version": "3.20.6",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -115,7 +115,7 @@
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
 		"@types/node": "^25.6.2",
-		"eslint": "^10.4.1",
+		"eslint": "^10.5.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.15.2",
 		"eslint-plugin-prettier": "^5.5.6",
@@ -126,10 +126,10 @@
 		"marked": "^18.0.5",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.0",
-		"prettier": "^3.8.3",
+		"prettier": "^3.8.4",
 		"ts-jest": "^29.4.11",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.60.1",
+		"typescript-eslint": "^8.61.0",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/include/RTC/Consumer.hpp

@@ -7,6 +7,7 @@
 #include "FBS/consumer.h"
 #include "FBS/transport.h"
 #include "RTC/ConsumerTypes.hpp"
+#include "RTC/ProducerStreamManager.hpp"
 #include "RTC/RTCP/CompoundPacket.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
 #include "RTC/RTCP/ReceiverReport.hpp"
@@ -16,15 +17,24 @@
 #include "RTC/RTP/RtpStreamSend.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "RTC/SeqManager.hpp"
+#include "Shared.hpp"
 #include "SharedInterface.hpp"
+#include <ankerl/unordered_dense.h>
 #include <bitset>
+#include <map>
 #include <string>
 #include <vector>
 
 namespace RTC
 {
-	class Consumer : public Channel::ChannelSocket::RequestHandler
+	class Consumer : public Channel::ChannelSocket::RequestHandler,
+	                 public RTC::RTP::RtpStreamSend::Listener,
+	                 public RTC::ProducerStreamManager::Listener
 	{
+		using RetransmissionBuffer =
+		  std::map<uint16_t, RTC::RTP::SharedPacket, RTC::SeqManager<uint16_t>::SeqLowerThan>;
+
 	public:
 		class Listener
 		{
@@ -56,20 +66,18 @@ namespace RTC
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,
-		  const FBS::Transport::ConsumeRequest* data,
-		  RTC::RtpParameters::Type type);
+		  const FBS::Transport::ConsumeRequest* data);
 		~Consumer() override;
 
 	public:
-		flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> FillBuffer(
+		flatbuffers::Offset<FBS::Consumer::DumpResponse> FillBuffer(
+		  flatbuffers::FlatBufferBuilder& builder) const;
+		flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> FillBufferBase(
+		  flatbuffers::FlatBufferBuilder& builder) const;
+		flatbuffers::Offset<FBS::Consumer::GetStatsResponse> FillBufferStats(
+		  flatbuffers::FlatBufferBuilder& builder);
+		flatbuffers::Offset<FBS::Consumer::ConsumerScore> FillBufferScore(
 		  flatbuffers::FlatBufferBuilder& builder) const;
-		virtual flatbuffers::Offset<FBS::Consumer::GetStatsResponse> FillBufferStats(
-		  flatbuffers::FlatBufferBuilder& builder) = 0;
-		virtual flatbuffers::Offset<FBS::Consumer::ConsumerScore> FillBufferScore(
-		  flatbuffers::FlatBufferBuilder& /*builder*/) const
-		{
-			return 0;
-		};
 		RTC::Media::Kind GetKind() const
 		{
 			return this->kind;
@@ -86,12 +94,9 @@ namespace RTC
 		{
 			return this->type;
 		}
-		virtual RTC::ConsumerTypes::VideoLayers GetPreferredLayers() const
+		RTC::ConsumerTypes::VideoLayers GetPreferredLayers() const
 		{
-			// By default return 1:1.
-			RTC::ConsumerTypes::VideoLayers layers;
-
-			return layers;
+			return this->producerStreamManager->GetPreferredLayers();
 		}
 		const std::vector<uint32_t>& GetMediaSsrcs() const
 		{
@@ -101,10 +106,8 @@ namespace RTC
 		{
 			return this->rtxSsrcs;
 		}
-		virtual bool IsActive() const
+		bool IsActive() const override
 		{
-			// The parent Consumer just checks whether Consumer and Producer are
-			// not paused and the transport connected.
 			// clang-format off
 			return (
 				this->transportConnected &&
@@ -126,32 +129,30 @@ namespace RTC
 		}
 		void ProducerPaused();
 		void ProducerResumed();
-		virtual void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc)    = 0;
-		virtual void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) = 0;
+		void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc);
+		void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc);
 		void ProducerRtpStreamScores(const std::vector<uint8_t>* scores);
-		virtual void ProducerRtpStreamScore(
-		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore)           = 0;
-		virtual void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+		void ProducerRtpStreamScore(RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore);
+		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first);
 		void ProducerClosed();
 		void SetExternallyManagedBitrate()
 		{
 			this->externallyManagedBitrate = true;
+			this->producerStreamManager->SetExternallyManagedBitrate();
 		}
-		virtual uint8_t GetBitratePriority() const                                                 = 0;
-		virtual uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss)                        = 0;
-		virtual void ApplyLayers()                                                                 = 0;
-		virtual uint32_t GetDesiredBitrate() const                                                 = 0;
-		virtual void SendRtpPacket(RTC::RTP::Packet* packet, RTC::RTP::SharedPacket& sharedPacket) = 0;
-		virtual bool GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs)                    = 0;
-		virtual const std::vector<RTC::RTP::RtpStreamSend*>& GetRtpStreams() const                 = 0;
-		virtual void NeedWorstRemoteFractionLost(uint32_t mappedSsrc, uint8_t& worstRemoteFractionLost) = 0;
-		virtual void ReceiveNack(RTC::RTCP::FeedbackRtpNackPacket* nackPacket) = 0;
-		virtual void ReceiveKeyFrameRequest(
-		  RTC::RTCP::FeedbackPs::MessageType messageType, uint32_t ssrc)                          = 0;
-		virtual void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report)                 = 0;
-		virtual void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report) = 0;
-		virtual uint32_t GetTransmissionRate(uint64_t nowMs)                                      = 0;
-		virtual float GetRtt() const                                                              = 0;
+		uint8_t GetBitratePriority() const;
+		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss);
+		void ApplyLayers();
+		uint32_t GetDesiredBitrate() const;
+		void SendRtpPacket(RTC::RTP::Packet* packet, RTC::RTP::SharedPacket& sharedPacket);
+		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs);
+		void NeedWorstRemoteFractionLost(uint32_t mappedSsrc, uint8_t& worstRemoteFractionLost);
+		void ReceiveNack(RTC::RTCP::FeedbackRtpNackPacket* nackPacket);
+		void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType, uint32_t ssrc);
+		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
+		void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report);
+		uint32_t GetTransmissionRate(uint64_t nowMs);
+		float GetRtt() const;
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
 	public:
@@ -165,10 +166,35 @@ namespace RTC
 		void EmitTraceEvent(flatbuffers::Offset<FBS::Consumer::TraceNotification>& notification) const;
 
 	private:
-		virtual void UserOnTransportConnected()    = 0;
-		virtual void UserOnTransportDisconnected() = 0;
-		virtual void UserOnPaused()                = 0;
-		virtual void UserOnResumed()               = 0;
+		void EmitScore() const;
+		void EmitLayersChange() const;
+
+	private:
+		void UserOnTransportConnected();
+		void UserOnTransportDisconnected();
+		void UserOnPaused();
+		void UserOnResumed();
+
+	private:
+		void CreateRtpStreams();
+		static void StorePacketInTargetLayerRetransmissionBuffer(
+		  RetransmissionBuffer& targetLayerRetransmissionBuffer,
+		  RTC::RTP::Packet* packet,
+		  RTC::RTP::SharedPacket& sharedPacket);
+
+		/* Pure virtual methods inherited from RtpStreamSend::Listener. */
+	public:
+		void OnRtpStreamScore(RTC::RTP::RtpStream* rtpStream, uint8_t score, uint8_t previousScore) override;
+		void OnRtpStreamRetransmitRtpPacket(
+		  RTC::RTP::RtpStreamSend* rtpStream, RTC::RTP::Packet* packet) override;
+
+		/* Pure virtual methods inherited from ProducerStreamManager::Listener. */
+	public:
+		void OnProducerStreamManagerKeyFrameRequested(uint32_t mappedSsrc) override;
+		void OnProducerStreamManagerNeedBitrateChange() override;
+		void OnProducerStreamManagerLayersChanged() override;
+		void OnProducerStreamManagerClearRetransmissionBuffer() override;
+		void OnProducerStreamManagerScore() override;
 
 	public:
 		// Passed by argument.
@@ -186,8 +212,6 @@ namespace RTC
 		struct RTC::RTP::HeaderExtensionIds rtpHeaderExtensionIds;
 		const std::vector<uint8_t>* producerRtpStreamScores{ nullptr };
 		// Others.
-		// Whether a payload type is supported or not is represented in the
-		// corresponding position of the bitset.
 		std::bitset<128u> supportedCodecPayloadTypes;
 		uint64_t lastRtcpSentTime{ 0u };
 		uint16_t maxRtcpInterval{ 0u };
@@ -196,13 +220,24 @@ namespace RTC
 		struct TraceEventTypes traceEventTypes;
 
 	private:
+		bool pipe{ false };
 		// Others.
+		std::vector<RTC::RTP::RtpStreamSend*> rtpStreams;
+		ankerl::unordered_dense::map<uint32_t, uint32_t> mapMappedSsrcSsrc;
+		ankerl::unordered_dense::map<uint32_t, RTC::RTP::RtpStreamSend*> mapSsrcRtpStream;
+		ankerl::unordered_dense::map<RTC::RTP::RtpStreamSend*, RTC::SeqManager<uint16_t>> mapRtpStreamRtpSeqManager;
+		// Buffers to store packets that arrive earlier than the first packet of the
+		// video key frame.
+		ankerl::unordered_dense::map<RTC::RTP::RtpStreamSend*, RetransmissionBuffer>
+		  mapRtpStreamTargetLayerRetransmissionBuffer;
 		std::vector<uint32_t> mediaSsrcs;
 		std::vector<uint32_t> rtxSsrcs;
 		bool transportConnected{ false };
 		bool paused{ false };
 		bool producerPaused{ false };
 		bool producerClosed{ false };
+		bool lastSentPacketHasMarker{ false };
+		std::unique_ptr<RTC::ProducerStreamManager> producerStreamManager;
 	};
 } // namespace RTC
 

package/worker/include/RTC/PipeProducerStreamManager.hpp

@@ -0,0 +1,78 @@
+#ifndef MS_RTC_PIPE_PRODUCER_STREAM_MANAGER_HPP
+#define MS_RTC_PIPE_PRODUCER_STREAM_MANAGER_HPP
+
+#include "RTC/ProducerStreamManager.hpp"
+#include <ankerl/unordered_dense.h>
+
+namespace RTC
+{
+	class PipeProducerStreamManager : public ProducerStreamManager
+	{
+	public:
+		PipeProducerStreamManager(
+		  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);
+
+	public:
+		RTC::ConsumerTypes::VideoLayers GetTargetLayers() const override
+		{
+			return {};
+		}
+		int16_t GetCurrentSpatialLayer() const override
+		{
+			return -1;
+		}
+		int16_t GetCurrentTemporalLayer() const override
+		{
+			return -1;
+		}
+		RTC::RTP::RtpStreamRecv* GetProducerCurrentRtpStream() const override
+		{
+			return nullptr;
+		}
+		RTC::RTP::RtpStreamRecv* GetProducerTargetRtpStream() const override
+		{
+			return nullptr;
+		}
+		bool IsPacketForCurrentStream(const RTC::RTP::Packet* /*packet*/) const override
+		{
+			// Pipe has no concept of "current" stream — all packets belong.
+			return true;
+		}
+		bool IsActive() const override;
+		void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerRtpStreamScore(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
+		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
+		uint32_t IncreaseLayer(
+		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
+		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
+		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		RtpPacketProcessResult ProcessRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  bool lastSentPacketHasMarker,
+		  uint32_t clockRate,
+		  uint32_t maxPacketTs) override;
+		void RequestKeyFrame() override;
+		void RequestKeyFrameForTargetSpatialLayer() override;
+		void RequestKeyFrameForCurrentSpatialLayer() override;
+		void UpdateTargetLayers(int16_t spatial, int16_t temporal) override;
+		bool RecalculateTargetLayers(RTC::ConsumerTypes::VideoLayers& newTargetLayers) const override;
+		void OnTransportConnected() override;
+		void OnTransportDisconnected() override;
+		void OnPaused() override;
+		void OnResumed() override;
+
+	private:
+		// Per-stream sync state, keyed by mapped SSRC.
+		ankerl::unordered_dense::map<uint32_t, bool> mapMappedSsrcSyncRequired;
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/ProducerStreamManager.hpp

@@ -0,0 +1,181 @@
+#ifndef MS_RTC_PRODUCER_STREAM_MANAGER_HPP
+#define MS_RTC_PRODUCER_STREAM_MANAGER_HPP
+
+#include "common.hpp"
+#include "RTC/ConsumerTypes.hpp"
+#include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "RTC/RTP/RtpStreamRecv.hpp"
+#include "RTC/RtpDictionaries.hpp"
+#include "SharedInterface.hpp"
+#include <vector>
+
+namespace RTC
+{
+	class ProducerStreamManager
+	{
+	public:
+		class Listener
+		{
+		public:
+			virtual ~Listener() = default;
+
+		public:
+			virtual bool IsActive() const                                              = 0;
+			virtual void OnProducerStreamManagerKeyFrameRequested(uint32_t mappedSsrc) = 0;
+			virtual void OnProducerStreamManagerNeedBitrateChange()                    = 0;
+			virtual void OnProducerStreamManagerLayersChanged()                        = 0;
+			virtual void OnProducerStreamManagerClearRetransmissionBuffer()            = 0;
+			virtual void OnProducerStreamManagerScore()                                = 0;
+		};
+
+		struct RtpPacketProcessResult
+		{
+			enum class Type : uint8_t
+			{
+				FORWARD,
+				DROP,
+				SILENT_DROP,
+				BUFFER
+			};
+
+			Type type{ Type::FORWARD };
+
+			// Valid when type == FORWARD:
+			uint32_t tsOffset{ 0u };
+			bool isSyncPacket{ false };
+			uint16_t syncSeqValue{ 0u };
+			bool shouldSyncEncodingContext{ false };
+			bool spatialLayerSwitched{ false };
+			bool temporalLayerChanged{ false };
+			bool marker{ false };
+			bool sendBufferedPackets{ false };
+		};
+
+	public:
+		ProducerStreamManager(
+		  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)
+		  : listener(listener),
+		    shared(shared),
+		    keyFrameSupported(keyFrameSupported),
+		    kind(kind),
+		    consumableRtpEncodings(consumableRtpEncodings),
+		    encodingContext(std::move(encodingContext)),
+		    preferredLayers(preferredLayers)
+		{
+		}
+		virtual ~ProducerStreamManager() = default;
+
+	public:
+		virtual RTC::ConsumerTypes::VideoLayers GetTargetLayers() const      = 0;
+		virtual int16_t GetCurrentSpatialLayer() const                       = 0;
+		virtual int16_t GetCurrentTemporalLayer() const                      = 0;
+		virtual RTC::RTP::RtpStreamRecv* GetProducerCurrentRtpStream() const = 0;
+		virtual RTC::RTP::RtpStreamRecv* GetProducerTargetRtpStream() const  = 0;
+		// Returns true if the given packet belongs to the stream currently being
+		// forwarded to the consumer. Used by Consumer to decide whether to account
+		// a discarded packet in the RTP sequence manager.
+		virtual bool IsPacketForCurrentStream(const RTC::RTP::Packet* packet) const = 0;
+		RTC::RTP::Codecs::EncodingContext* GetEncodingContext() const
+		{
+			return this->encodingContext.get();
+		}
+		const RTC::ConsumerTypes::VideoLayers& GetPreferredLayers() const
+		{
+			return this->preferredLayers;
+		}
+		void SetPreferredLayers(const RTC::ConsumerTypes::VideoLayers& layers)
+		{
+			this->preferredLayers = layers;
+		}
+
+		virtual void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc)    = 0;
+		virtual void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) = 0;
+		virtual void ProducerRtpStreamScore(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore)           = 0;
+		virtual void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+
+		void SetExternallyManagedBitrate()
+		{
+			this->externallyManagedBitrate = true;
+		}
+
+		virtual uint32_t IncreaseLayer(
+		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) = 0;
+		virtual void ApplyLayers(uint64_t rtpStreamActiveMs)                         = 0;
+		virtual uint32_t GetDesiredBitrate(uint64_t nowMs) const                     = 0;
+
+		virtual RtpPacketProcessResult ProcessRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  bool lastSentPacketHasMarker,
+		  uint32_t clockRate,
+		  uint32_t maxPacketTs) = 0;
+
+		virtual void RequestKeyFrame()                       = 0;
+		virtual void RequestKeyFrameForTargetSpatialLayer()  = 0;
+		virtual void RequestKeyFrameForCurrentSpatialLayer() = 0;
+
+		virtual void UpdateTargetLayers(int16_t newTargetSpatialLayer, int16_t newTargetTemporalLayer) = 0;
+		virtual bool RecalculateTargetLayers(RTC::ConsumerTypes::VideoLayers& newTargetLayers) const = 0;
+
+		void MayChangeLayers(bool force)
+		{
+			RTC::ConsumerTypes::VideoLayers newTargetLayers;
+
+			if (RecalculateTargetLayers(newTargetLayers))
+			{
+				// If bitrate externally managed, don't bother the transport unless
+				// the newTargetSpatialLayer has changed (or force is true).
+				// This is because, if bitrate is externally managed, the target temporal
+				// layer is managed by the available given bitrate so the transport
+				// will let us change it when it considers.
+				if (this->externallyManagedBitrate)
+				{
+					if (newTargetLayers.spatial != GetTargetLayers().spatial || force)
+					{
+						this->listener->OnProducerStreamManagerNeedBitrateChange();
+					}
+				}
+				else
+				{
+					UpdateTargetLayers(newTargetLayers.spatial, newTargetLayers.temporal);
+				}
+			}
+		}
+		virtual void OnTransportConnected()    = 0;
+		virtual void OnTransportDisconnected() = 0;
+		virtual void OnPaused()                = 0;
+		virtual void OnResumed()               = 0;
+
+	protected:
+		virtual bool IsActive() const = 0;
+
+		// Passed by argument.
+		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
+		bool keyFrameSupported{ false };
+		RTC::Media::Kind kind{};
+		std::vector<RTC::RtpEncodingParameters> consumableRtpEncodings;
+
+		// Encoding context.
+		std::unique_ptr<RTC::RTP::Codecs::EncodingContext> encodingContext;
+
+		// Externally managed bitrate.
+		bool externallyManagedBitrate{ false };
+
+		// Layer preferences.
+		RTC::ConsumerTypes::VideoLayers preferredLayers;
+		RTC::ConsumerTypes::VideoLayers provisionalTargetLayers;
+
+		// Sync state.
+		bool syncRequired{ false };
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/association/Association.hpp

@@ -168,6 +168,14 @@ namespace RTC
 				bool usesZeroChecksum{ false };
 			};
 
+		private:
+			/**
+			 * Length of the per-association random secret key used to authenticate the
+			 * State Cookies we generate when `SctpOptions::requireAuthenticatedCookie`
+			 * is enabled.
+			 */
+			static constexpr size_t StateCookieSecretLength{ 32 };
+
 		public:
 			explicit Association(
 			  const SctpOptions& sctpOptions,
@@ -470,6 +478,19 @@ namespace RTC
 			bool HandleReceivedUnknownChunk(
 			  const Packet* receivedPacket, const UnknownChunk* receivedUnknownChunk);
 
+			/**
+			 * Verify the MAC and freshness of an authenticated State Cookie received
+			 * in a COOKIE-ECHO chunk. Only called when
+			 * `SctpOptions::requireAuthenticatedCookie` is enabled.
+			 *
+			 * Returns `true` if the cookie is authentic and not stale, `false`
+			 * otherwise (in which case the COOKIE-ECHO must be discarded). A Stale
+			 * Cookie ERROR chunk is sent to the peer if the cookie is stale.
+			 *
+			 * @see RFC 9260 section 5.1.4.
+			 */
+			bool VerifyReceivedStateCookie(const StateCookie* cookie);
+
 			void OnT1InitTimer(uint64_t& baseTimeoutMs, bool& stop);
 
 			void OnT1CookieTimer(uint64_t& baseTimeoutMs, bool& stop);
@@ -540,6 +561,9 @@ namespace RTC
 			// Whether `MayConnect()` should be called when SCTP data is received.
 			// See the constructor for details.
 			bool mayConnectOnReceivedSctpData;
+			// Per-association random secret key used to authenticate the State Cookies
+			// we generate when `SctpOptions::requireAuthenticatedCookie` is enabled.
+			uint8_t stateCookieSecret[Association::StateCookieSecretLength]{};
 		};
 	} // namespace SCTP
 } // namespace RTC