mediasoup 3.19.21 → 3.20.0

package/worker/include/RTC/SCTP/tx/StreamScheduler.hpp

@@ -0,0 +1,235 @@
+#ifndef MS_RTC_SCTP_STREAM_SCHEDULER_HPP
+#define MS_RTC_SCTP_STREAM_SCHEDULER_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/chunks/IDataChunk.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
+#include <set>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * A parameterized stream scheduler. Currently, it implements the round robin
+		 *  scheduling algorithm using virtual finish time. It is to be used as a
+		 *  part of a send queue and will track all active streams (streams that have
+		 *  any data that can be sent).
+		 *
+		 * The stream scheduler works with the concept of associating active streams
+		 * with a "virtual finish time", which is the time when a stream is allowed
+		 * to produce data. Streams are ordered by their virtual finish time, and
+		 * the "current virtual time" will advance to the next following virtual
+		 * finish time whenever a chunk is to be produced.
+		 *
+		 * In the round robin scheduling algorithm, a stream's virtual finish time
+		 * will just increment by one (1) after having produced a chunk, which
+		 * results in a round-robin scheduling.
+		 *
+		 * In WFQ scheduling algorithm, a stream's virtual finish time will be
+		 * defined as the number of bytes in the next fragment to be sent, multiplied
+		 * by theinverse of the stream's priority, meaning that a high priority - or
+		 * a smaller fragment - results in a closer virtual finish time, compared to
+		 * a stream with either a lower priority or a larger fragment to be sent.
+		 *
+		 * @remarks
+		 * - When message interleaving is enabled, the WFQ (Weighted Fair Queueing)
+		 * 	 scheduling algorithm will be used. And when it's not, round-robin
+		 * 	 scheduling will be used instead.
+		 */
+		class StreamScheduler
+		{
+		public:
+			class StreamProducer
+			{
+			public:
+				virtual ~StreamProducer() = default;
+
+			public:
+				/**
+				 * Produces a fragment of data to send. The current wall time is specified
+				 * as `nowMs` and should be used to skip chunks with expired limited
+				 * lifetime. The parameter `maxLength` specifies the maximum amount of
+				 * actual payload that may be returned. If these constraints prevents the
+				 * stream from sending some data, `std::nullopt` should be returned.
+				 */
+				virtual std::optional<SendQueueInterface::DataToSend> Produce(
+				  uint64_t nowMs, size_t maxLength) = 0;
+
+				/**
+				 * Returns the number of payload bytes that is scheduled to be sent in the
+				 * next enqueued message, or zero if there are no enqueued messages or if
+				 * the stream has been actively paused.
+				 */
+				virtual size_t GetBytesToSendInNextMessage() const = 0;
+			};
+
+		public:
+			class Stream
+			{
+			private:
+				friend class StreamScheduler;
+
+			private:
+				Stream(StreamScheduler* parent, StreamProducer* producer, uint16_t streamId, uint16_t priority)
+				  : parent(*parent),
+				    producer(*producer),
+				    streamId(streamId),
+				    priority(priority),
+				    inverseWeight(1.0 / std::max(static_cast<double>(priority), 1e-6))
+				{
+				}
+
+			public:
+				uint16_t GetStreamId() const
+				{
+					return this->streamId;
+				}
+
+				uint16_t GetPriority() const
+				{
+					return this->priority;
+				}
+
+				void SetPriority(uint16_t priority);
+
+				/**
+				 * Will activate the stream if it has any data to send. That is, if the
+				 * callback to `GetBytesToSendInNextMessage()` returns non-zero. If the
+				 * callback returns zero, the stream will not be made active.
+				 */
+				void MayMakeActive();
+
+				/**
+				 * Will remove the stream from the list of active streams, and will not
+				 * try to produce data from it. To make it active again, call
+				 * `MayMakeActive()`.
+				 */
+				void MakeInactive();
+
+				/**
+				 * Make the scheduler move to another message, or another stream. This
+				 * is used to abort the scheduler from continuing producing fragments
+				 * for the current message in case it's deleted.
+				 */
+				void ForceReschedule()
+				{
+					this->parent.ForceReschedule();
+				}
+
+			private:
+				/**
+				 * Produces a message from this stream. This will only be called on
+				 * streams that have data.
+				 */
+				std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+
+				void MakeActive(size_t bytesToSendNext);
+
+				void ForceMarkInactive();
+
+				double GetCurrentTime() const
+				{
+					return this->currentVirtualTime;
+				}
+
+				double GetNextFinishTime() const
+				{
+					return this->nextFinishTime;
+				}
+
+				size_t GetBytesToSendInNextMessage() const
+				{
+					return this->producer.GetBytesToSendInNextMessage();
+				}
+
+				double CalculateFinishTime(size_t bytesToSendNext) const;
+
+			private:
+				StreamScheduler& parent;
+				StreamProducer& producer;
+				const uint16_t streamId;
+				uint16_t priority;
+				double inverseWeight;
+				// This outgoing stream's "current" virtual time.
+				double currentVirtualTime{ 0.0 };
+				double nextFinishTime{ 0.0 };
+			};
+
+		private:
+			struct ActiveStreamComparator
+			{
+				// Ordered by virtual finish time (primary), stream-id (secondary).
+				bool operator()(Stream* a, Stream* b) const
+				{
+					const double aVft = a->GetNextFinishTime();
+					const double bVft = b->GetNextFinishTime();
+
+					if (aVft == bVft)
+					{
+						return a->GetStreamId() < b->GetStreamId();
+					}
+
+					return aVft < bVft;
+				}
+			};
+
+		public:
+			explicit StreamScheduler(size_t mtu)
+			  : maxPayloadBytes(mtu - Packet::CommonHeaderLength - IDataChunk::IDataChunkHeaderLength)
+			{
+			}
+
+		public:
+			std::unique_ptr<Stream> CreateStream(StreamProducer* producer, uint16_t streamId, uint16_t priority)
+			{
+				return std::unique_ptr<Stream>(new Stream(this, producer, streamId, priority));
+			}
+
+			void EnableMessageInterleaving(bool enabled)
+			{
+				this->enableMessageInterleaving = enabled;
+			}
+
+			/**
+			 * Makes the scheduler stop producing message from the current stream and
+			 * re-evaluates which stream to produce from.
+			 */
+			void ForceReschedule()
+			{
+				this->currentlySendingAMessage = false;
+			}
+
+			/**
+			 * Produces a fragment of data to send. The current wall time is specified
+			 * as `nowMs` and will be used to skip chunks with expired limited
+			 * lifetime. The parameter `maxLength` specifies the maximum amount of
+			 * actual payload that may be returned. If no data can be produced,
+			 * `std::nullopt` is returned.
+			 */
+			std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+
+			std::set<uint16_t> GetActiveStreamsForTesting() const;
+
+		private:
+			void AssertIsConsistent() const;
+
+		private:
+			const size_t maxPayloadBytes;
+			// The current virtual time, as defined in the WFQ algorithm.
+			double virtualTime{ 0.0 };
+			// The current stream to send chunks from.
+			Stream* currentStream{ nullptr };
+			bool enableMessageInterleaving{ false };
+			// Indicates if the streams is currently sending a message, and should
+			// then (if message interleaving is not enabled) continue sending from
+			// this stream until that message has been sent in full.
+			bool currentlySendingAMessage{ false };
+			// The currently active streams, ordered by virtual finish time.
+			std::set<Stream*, ActiveStreamComparator> activeStreams;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SenderBandwidthEstimator.hpp

@@ -6,6 +6,7 @@
 #include "RTC/RateCalculator.hpp"
 #include "RTC/SeqManager.hpp"
 #include "RTC/TrendCalculator.hpp"
+#include "SharedInterface.hpp"
 #include <map>
 
 namespace RTC
@@ -82,7 +83,9 @@ namespace RTC
 
 	public:
 		SenderBandwidthEstimator(
-		  RTC::SenderBandwidthEstimator::Listener* listener, uint32_t initialAvailableBitrate);
+		  RTC::SenderBandwidthEstimator::Listener* listener,
+		  SharedInterface* shared,
+		  uint32_t initialAvailableBitrate);
 		virtual ~SenderBandwidthEstimator();
 
 	public:
@@ -98,6 +101,7 @@ namespace RTC
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Others.
 		uint32_t initialAvailableBitrate{ 0u };
 		uint32_t availableBitrate{ 0u };

package/worker/include/RTC/Serializable.hpp

@@ -75,6 +75,14 @@ namespace RTC
 			return this->length;
 		}
 
+		/**
+		 * Current available length of the Serializable.
+		 */
+		virtual size_t GetAvailableLength() const final
+		{
+			return this->bufferLength - this->length;
+		}
+
 		/**
 		 * Serialize the Serializable into a new buffer. This method copies the
 		 * bytes of the internal buffer into the new buffer and makes `GetBuffer()`
@@ -205,11 +213,11 @@ namespace RTC
 
 	private:
 		// Buffer holding the Serializable content.
-		uint8_t* buffer{ nullptr };
+		uint8_t* buffer;
 		// Length of the buffer. This is the maximum length the Serializable can
 		// take.
-		size_t bufferLength{ 0u };
-		// Serializable exact length (includes padding bytes).
+		size_t bufferLength;
+		// Serializable current exact length (includes padding bytes).
 		size_t length{ 0u };
 		// Event listener invoked when the current buffer is released (no longer
 		// used by this Serializable)-

package/worker/include/RTC/SimpleConsumer.hpp

@@ -3,7 +3,6 @@
 
 #include "RTC/Consumer.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -12,7 +11,7 @@ namespace RTC
 	{
 	public:
 		SimpleConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/SimulcastConsumer.hpp

@@ -4,7 +4,6 @@
 #include "RTC/Consumer.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -13,7 +12,7 @@ namespace RTC
 	{
 	public:
 		SimulcastConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/SvcConsumer.hpp

@@ -4,7 +4,6 @@
 #include "RTC/Consumer.hpp"
 #include "RTC/RTP/Codecs/PayloadDescriptorHandler.hpp"
 #include "RTC/SeqManager.hpp"
-#include "RTC/Shared.hpp"
 #include <map>
 
 namespace RTC
@@ -13,7 +12,7 @@ namespace RTC
 	{
 	public:
 		SvcConsumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,

package/worker/include/RTC/TcpServer.hpp

@@ -2,10 +2,10 @@
 #define MS_RTC_TCP_SERVER_HPP
 
 #include "common.hpp"
-#include "RTC/TcpConnection.hpp"
-#include "RTC/Transport.hpp"
 #include "handles/TcpConnectionHandle.hpp"
 #include "handles/TcpServerHandle.hpp"
+#include "RTC/TcpConnection.hpp"
+#include "RTC/Transport.hpp"
 #include <string>
 
 namespace RTC

package/worker/include/RTC/Transport.hpp

@@ -1,9 +1,9 @@
 #ifndef MS_RTC_TRANSPORT_HPP
 #define MS_RTC_TRANSPORT_HPP
+
 // #define ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 
 #include "common.hpp"
-#include "DepLibUV.hpp"
 #include "Channel/ChannelNotification.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
@@ -19,19 +19,17 @@
 #include "RTC/RateCalculator.hpp"
 #include "RTC/RtpListener.hpp"
 #include "RTC/SCTP/public/AssociationInterface.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
-// TODO: Remove once we only use built-in SCTP stack.
-#include "RTC/SctpAssociation.hpp"
 #include "RTC/SctpListener.hpp"
-#include "RTC/Shared.hpp"
+#include "SharedInterface.hpp"
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 #include "RTC/SenderBandwidthEstimator.hpp"
 #endif
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/TransportCongestionControlClient.hpp"
 #include "RTC/TransportCongestionControlServer.hpp"
-#include "handles/TimerHandle.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <string>
 #include <vector>
@@ -42,9 +40,7 @@ namespace RTC
 	                  public RTC::Consumer::Listener,
 	                  public RTC::DataProducer::Listener,
 	                  public RTC::DataConsumer::Listener,
-	                  public RTC::SCTP::AssociationListener,
-	                  // TODO: Remove once we only use built-in SCTP stack.
-	                  public RTC::SctpAssociation::Listener,
+	                  public RTC::SCTP::AssociationListenerInterface,
 	                  public RTC::TransportCongestionControlClient::Listener,
 	                  public RTC::TransportCongestionControlServer::Listener,
 	                  public Channel::ChannelSocket::RequestHandler,
@@ -52,7 +48,7 @@ namespace RTC
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 	                  public RTC::SenderBandwidthEstimator::Listener,
 #endif
-	                  public TimerHandle::Listener
+	                  public TimerHandleInterface::Listener
 	{
 	protected:
 		using onSendCallback   = const std::function<void(bool sent)>;
@@ -110,9 +106,7 @@ namespace RTC
 			virtual void OnTransportDataProducerMessageReceived(
 			  RTC::Transport* transport,
 			  RTC::DataProducer* dataProducer,
-			  const uint8_t* msg,
-			  size_t len,
-			  uint32_t ppid,
+			  RTC::SCTP::Message message,
 			  std::vector<uint16_t>& subchannels,
 			  std::optional<uint16_t> requiredSubchannel) = 0;
 			virtual void OnTransportNewDataConsumer(
@@ -157,7 +151,7 @@ namespace RTC
 
 	public:
 		Transport(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
 		  const FBS::Transport::Options* options);
@@ -180,51 +174,51 @@ namespace RTC
 
 	protected:
 		// Must be called from the subclass.
-		void Destroying();
-		void Connected();
-		void Disconnected();
-		void DataReceived(size_t len)
+		virtual void SetDestroying() final;
+		virtual void Connected() final;
+		virtual void Disconnected() final;
+		virtual void DataReceived(size_t len) final
 		{
-			this->recvTransmission.Update(len, DepLibUV::GetTimeMs());
+			this->recvTransmission.Update(len, this->shared->GetTimeMs());
 		}
-		void DataSent(size_t len)
+		virtual void DataSent(size_t len) final
 		{
-			this->sendTransmission.Update(len, DepLibUV::GetTimeMs());
+			this->sendTransmission.Update(len, this->shared->GetTimeMs());
 		}
-		void ReceiveRtpPacket(RTC::RTP::Packet* packet);
-		void ReceiveRtcpPacket(RTC::RTCP::Packet* packet);
-		void ReceiveSctpData(const uint8_t* data, size_t len);
-		RTC::Producer* GetProducerById(const std::string& producerId) const;
-		RTC::Consumer* GetConsumerById(const std::string& consumerId) const;
-		RTC::Consumer* GetConsumerByMediaSsrc(uint32_t ssrc) const;
-		RTC::Consumer* GetConsumerByRtxSsrc(uint32_t ssrc) const;
-		RTC::DataProducer* GetDataProducerById(const std::string& dataProducerId) const;
-		RTC::DataConsumer* GetDataConsumerById(const std::string& dataConsumerId) const;
+		virtual void ReceiveRtpPacket(RTC::RTP::Packet* packet) final;
+		virtual void ReceiveRtcpPacket(RTC::RTCP::Packet* packet) final;
+		virtual void ReceiveSctpData(const uint8_t* data, size_t len) final;
+		virtual void SendSctpMessage(
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) final;
 
 	private:
+		virtual RTC::Producer* AssertAndGetProducerById(const std::string& producerId) const final;
+		virtual RTC::Consumer* AssertAndGetConsumerById(const std::string& consumerId) const final;
+		virtual RTC::Consumer* GetConsumerByMediaSsrc(uint32_t ssrc) const final;
+		virtual RTC::Consumer* GetConsumerByRtxSsrc(uint32_t ssrc) const final;
+		virtual RTC::DataProducer* AssertAndGetDataProducerById(const std::string& dataProducerId) const final;
+		virtual RTC::DataConsumer* AssertAndGetDataConsumerById(const std::string& dataConsumerId) const final;
+		virtual RTC::DataConsumer* GetSctpDataConsumerByStreamId(uint16_t streamId) const final;
 		virtual bool IsConnected() const = 0;
 		virtual void SendRtpPacket(
 		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const onSendCallback* cb = nullptr) = 0;
-		void HandleRtcpPacket(RTC::RTCP::Packet* packet);
-		void SendRtcp(uint64_t nowMs);
+		virtual void HandleRtcpPacket(RTC::RTCP::Packet* packet) final;
+		virtual void SendRtcp(uint64_t nowMs) final;
 		virtual void SendRtcpPacket(RTC::RTCP::Packet* packet)                 = 0;
 		virtual void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) = 0;
 		virtual void SendMessage(
-		  RTC::DataConsumer* dataConsumer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
-		  onQueuedCallback* = nullptr)                             = 0;
-		virtual bool SendSctpData(const uint8_t* data, size_t len) = 0;
-		virtual void RecvStreamClosed(uint32_t ssrc)               = 0;
-		virtual void SendStreamClosed(uint32_t ssrc)               = 0;
-		void DistributeAvailableOutgoingBitrate();
-		void ComputeOutgoingDesiredBitrate(bool forceBitrate = false);
-		void EmitTraceEventProbationType(RTC::RTP::Packet* packet) const;
-		void EmitTraceEventBweType(RTC::TransportCongestionControlClient::Bitrates& bitrates) const;
-		void CheckNoProducer(const std::string& producerId) const;
-		void CheckNoDataProducer(const std::string& dataProducerId) const;
-		void CheckNoDataConsumer(const std::string& dataConsumerId) const;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) = 0;
+		virtual bool SendData(const uint8_t* data, size_t len) = 0;
+		virtual void RecvStreamClosed(uint32_t ssrc)           = 0;
+		virtual void SendStreamClosed(uint32_t ssrc)           = 0;
+		virtual void DistributeAvailableOutgoingBitrate() final;
+		virtual void ComputeOutgoingDesiredBitrate(bool forceBitrate = false) final;
+		virtual void EmitTraceEventProbationType(RTC::RTP::Packet* packet) const final;
+		virtual void EmitTraceEventBweType(
+		  RTC::TransportCongestionControlClient::Bitrates& bitrates) const final;
+		virtual void CheckNoDataProducer(const std::string& dataProducerId) const final;
+		virtual void CheckNoDataConsumer(const std::string& dataConsumerId) const final;
+		virtual void CheckNoSctpDataConsumer(uint16_t streamId) const final;
 
 		/* Pure virtual methods inherited from RTC::Producer::Listener. */
 	public:
@@ -269,9 +263,7 @@ namespace RTC
 		}
 		void OnDataProducerMessageReceived(
 		  RTC::DataProducer* dataProducer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
+		  RTC::SCTP::Message message,
 		  std::vector<uint16_t>& subchannels,
 		  std::optional<uint16_t> requiredSubchannel) override;
 		void OnDataProducerPaused(RTC::DataProducer* dataProducer) override;
@@ -280,16 +272,16 @@ namespace RTC
 		/* Pure virtual methods inherited from RTC::DataConsumer::Listener. */
 	public:
 		void OnDataConsumerSendMessage(
-		  RTC::DataConsumer* dataConsumer,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid,
-		  onQueuedCallback* cb = nullptr) override;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb) override;
 		void OnDataConsumerNeedBufferedAmount(
-		  RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) override;
+		  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const override;
+		void OnDataConsumerNeedBufferedAmountLowThreshold(
+		  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmountLowThreshold) const override;
+		void OnDataConsumerSetBufferedAmountLowThreshold(
+		  const RTC::DataConsumer* dataConsumer, uint32_t bytes) const override;
 		void OnDataConsumerDataProducerClosed(RTC::DataConsumer* dataConsumer) override;
 
-		/* Pure virtual methods inherited from RTC::SCTP::AssociationListener. */
+		/* Pure virtual methods inherited from RTC::SCTP::AssociationListenerInterface. */
 	public:
 		bool OnAssociationSendData(const uint8_t* data, size_t len) override;
 		void OnAssociationConnecting() override;
@@ -306,25 +298,6 @@ namespace RTC
 		void OnAssociationStreamBufferedAmountLow(uint16_t streamId) override;
 		void OnAssociationTotalBufferedAmountLow() override;
 		bool OnAssociationIsTransportReadyForSctp() override;
-		// TODO: SCTP: Add OnAssociationLifecycleMessageXxxxxx() methods.
-
-		/* Pure virtual methods inherited from RTC::SctpAssociation::Listener. */
-		// TODO: Remove once we only use built-in SCTP stack.
-	public:
-		void OnSctpAssociationConnecting(RTC::SctpAssociation* sctpAssociation) override;
-		void OnSctpAssociationConnected(RTC::SctpAssociation* sctpAssociation) override;
-		void OnSctpAssociationFailed(RTC::SctpAssociation* sctpAssociation) override;
-		void OnSctpAssociationClosed(RTC::SctpAssociation* sctpAssociation) override;
-		void OnSctpAssociationSendData(
-		  RTC::SctpAssociation* sctpAssociation, const uint8_t* data, size_t len) override;
-		void OnSctpAssociationMessageReceived(
-		  RTC::SctpAssociation* sctpAssociation,
-		  uint16_t streamId,
-		  const uint8_t* msg,
-		  size_t len,
-		  uint32_t ppid) override;
-		void OnSctpAssociationBufferedAmount(
-		  RTC::SctpAssociation* sctpAssociation, uint32_t bufferedAmount) override;
 
 		/* Pure virtual methods inherited from RTC::TransportCongestionControlClient::Listener. */
 	public:
@@ -350,21 +323,16 @@ namespace RTC
 		  uint32_t previousAvailableBitrate) override;
 #endif
 
-		/* Pure virtual methods inherited from TimerHandle::Listener. */
+		/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 	public:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	public:
 		// Passed by argument.
 		std::string id;
 
 	protected:
-		RTC::Shared* shared{ nullptr };
-		size_t maxMessageSize{ 262144u };
-		// Allocated by this.
-		std::unique_ptr<RTC::SCTP::AssociationInterface> sctpAssociation{ nullptr };
-		// TODO: Remove once we only use built-in SCTP stack.
-		RTC::SctpAssociation* oldSctpAssociation{ nullptr };
+		SharedInterface* shared{ nullptr };
 
 	private:
 		// Passed by argument.
@@ -374,9 +342,12 @@ namespace RTC
 		absl::flat_hash_map<std::string, RTC::Consumer*> mapConsumers;
 		absl::flat_hash_map<std::string, RTC::DataProducer*> mapDataProducers;
 		absl::flat_hash_map<std::string, RTC::DataConsumer*> mapDataConsumers;
+		absl::flat_hash_map<uint16_t, RTC::DataConsumer*> mapSctpStreamIdDataConsumers;
 		absl::flat_hash_map<uint32_t, RTC::Consumer*> mapSsrcConsumer;
 		absl::flat_hash_map<uint32_t, RTC::Consumer*> mapRtxSsrcConsumer;
-		TimerHandle* rtcpTimer{ nullptr };
+		TimerHandleInterface* rtcpTimer{ nullptr };
+		// Allocated by this.
+		std::unique_ptr<RTC::SCTP::AssociationInterface> sctpAssociation{ nullptr };
 		std::shared_ptr<RTC::TransportCongestionControlClient> tccClient{ nullptr };
 		std::shared_ptr<RTC::TransportCongestionControlServer> tccServer{ nullptr };
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
@@ -384,7 +355,7 @@ namespace RTC
 #endif
 		// Others.
 		bool direct{ false }; // Whether this Transport allows direct communication.
-		bool destroying{ false };
+		bool isDestroying{ false };
 		struct RTC::RTP::HeaderExtensionIds recvRtpHeaderExtensionIds;
 		RTC::RtpListener rtpListener;
 		RTC::SctpListener sctpListener;
@@ -400,6 +371,14 @@ namespace RTC
 		uint32_t maxIncomingBitrate{ 0u };
 		uint32_t maxOutgoingBitrate{ 0u };
 		uint32_t minOutgoingBitrate{ 0u };
+		// For SCTP capable transports and for direct transport.
+		size_t maxSendMessageSize{ 0u };
+		size_t maxReceiveMessageSize{ 0u };
+		// For SCTP capable transports.
+		size_t sctpSendBufferSize{ 0u };
+		size_t sctpPerStreamSendQueueLimit{ 0u };
+		size_t sctpMaxReceiverWindowBufferSize{ 0u };
+
 		struct TraceEventTypes traceEventTypes;
 	};
 } // namespace RTC