mediasoup 3.19.21 → 3.20.0

package/worker/fbs/sctpAssociation.fbs

@@ -8,3 +8,7 @@ enum SctpState: uint8 {
     CLOSED,
 }
 
+table SctpNegotiatedCapabilities {
+    negotiated_max_outbound_streams: uint16;
+    negotiated_max_inbound_streams: uint16;
+}

package/worker/fbs/sctpParameters.fbs

@@ -1,18 +1,12 @@
 namespace FBS.SctpParameters;
 
-table NumSctpStreams {
-    os: uint16 = 1024;
-    mis: uint16 = 1024;
-}
-
 table SctpParameters {
-    // Port is always 5000.
-    port: uint16 = 5000;
-    os: uint16;
-    mis: uint16;
-    max_message_size: uint32;
+    port: uint16;
+    max_send_message_size: uint32;
+    max_receive_message_size: uint32;
     send_buffer_size: uint32;
-    sctp_buffered_amount: uint32;
+    per_stream_send_queue_limit: uint32;
+    max_receiver_window_buffer_size: uint32;
     is_data_channel: bool;
 }
 
@@ -22,4 +16,3 @@ table SctpStreamParameters {
     max_packet_life_time: uint16 = null;
     max_retransmits: uint16 = null;
 }
-

package/worker/fbs/transport.fbs

@@ -1,6 +1,7 @@
 include "common.fbs";
 include "consumer.fbs";
 include "dataProducer.fbs";
+include "dataConsumer.fbs";
 include "rtpParameters.fbs";
 include "sctpAssociation.fbs";
 include "sctpParameters.fbs";
@@ -86,7 +87,7 @@ table ProduceDataRequest {
 table ConsumeDataRequest {
     data_consumer_id: string (required);
     data_producer_id: string (required);
-    type: FBS.DataProducer.Type;
+    type: FBS.DataConsumer.Type;
     sctp_stream_parameters: FBS.SctpParameters.SctpStreamParameters;
     label: string;
     protocol: string;
@@ -122,14 +123,13 @@ table RecvRtpHeaderExtensions {
 
 table Options {
     direct: bool = false;
-
-    /// Only needed for DirectTransport. This value is handled by base Transport.
-    max_message_size: uint32 = null;
     initial_available_outgoing_bitrate: uint32 = null;
     enable_sctp: bool = false;
-    num_sctp_streams: FBS.SctpParameters.NumSctpStreams;
-    max_sctp_message_size: uint32;
+    max_send_message_size: uint32;
+    max_receive_message_size: uint32;
     sctp_send_buffer_size: uint32;
+    sctp_per_stream_send_queue_limit: uint32;
+    sctp_max_receiver_window_buffer_size: uint32;
     is_data_channel: bool = false;
 }
 
@@ -149,7 +149,8 @@ table Dump {
     data_consumer_ids: [string] (required);
     recv_rtp_header_extensions: RecvRtpHeaderExtensions (required);
     rtp_listener: RtpListener (required);
-    max_message_size: uint32;
+    max_send_message_size: uint32;
+    max_receive_message_size: uint32;
     sctp_parameters: FBS.SctpParameters.SctpParameters;
     sctp_state: FBS.SctpAssociation.SctpState = null;
     sctp_listener: SctpListener;
@@ -227,6 +228,10 @@ table SctpStateChangeNotification {
     sctp_state: FBS.SctpAssociation.SctpState;
 }
 
+table SctpNegotiatedCapabilitiesNotification {
+    negotiated_capabilities: FBS.SctpAssociation.SctpNegotiatedCapabilities;
+}
+
 union TraceInfo {
     BweTraceInfo,
 }
@@ -253,4 +258,3 @@ table TraceNotification {
     direction: FBS.Common.TraceDirection;
     info: TraceInfo;
 }
-

package/worker/fuzzer/src/RTC/FuzzerDtlsTransport.cpp

@@ -4,17 +4,26 @@
 #include "RTC/FuzzerDtlsTransport.hpp"
 #include "Logger.hpp"
 #include "Utils.hpp"
+#include "mocks/include/MockShared.hpp"
 
 namespace
 {
-	// NOLINTBEGIN(readability-identifier-naming)
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	thread_local mocks::MockShared shared(/*getTimeMs*/
+	                                      []()
+	                                      {
+		                                      return 1000;
+	                                      });
+
 	// DtlsTransport instance. It's reset every time DTLS handshake fails or DTLS
 	// is closed.
+	// NOLINTNEXTLINE(readability-identifier-naming)
 	thread_local RTC::DtlsTransport* dtlsTransportSingleton{ nullptr };
+
 	// DtlsTransport Listener instance. It's reset every time the DtlsTransport
 	// singletonDTLS is reset.
+	// NOLINTNEXTLINE(readability-identifier-naming)
 	thread_local FuzzerRtcDtlsTransport::DtlsTransportListener* dtlsTransportListenerSingleton{ nullptr };
-	// NOLINTEND(readability-identifier-naming)
 } // namespace
 
 void FuzzerRtcDtlsTransport::Fuzz(const uint8_t* data, size_t len)
@@ -31,7 +40,8 @@ void FuzzerRtcDtlsTransport::Fuzz(const uint8_t* data, size_t len)
 		delete dtlsTransportListenerSingleton;
 		dtlsTransportListenerSingleton = new DtlsTransportListener();
 
-		dtlsTransportSingleton = new RTC::DtlsTransport(dtlsTransportListenerSingleton);
+		dtlsTransportSingleton =
+		  new RTC::DtlsTransport(dtlsTransportListenerSingleton, std::addressof(shared));
 
 		RTC::DtlsTransport::Role localRole;
 		RTC::DtlsTransport::Fingerprint dtlsRemoteFingerprint;

package/worker/fuzzer/src/RTC/FuzzerRateCalculator.cpp

@@ -1,8 +1,8 @@
 #include "RTC/FuzzerRateCalculator.hpp"
 #include "DepLibUV.hpp"
-#include "Utils.hpp"
 #include "RTC/Consts.hpp"
 #include "RTC/RateCalculator.hpp"
+#include "Utils.hpp"
 
 namespace
 {
@@ -23,7 +23,7 @@ void FuzzerRtcRateCalculator::Fuzz(const uint8_t* data, size_t len)
 {
 	// Trick to initialize our stuff just once.
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local const int unused = init();
+	static thread_local const int unused = init();
 
 	// Avoid [-Wunused-variable].
 	(void)unused;

package/worker/fuzzer/src/RTC/FuzzerSeqManager.cpp

@@ -1,6 +1,6 @@
 #include "RTC/FuzzerSeqManager.hpp"
-#include "Utils.hpp"
 #include "RTC/SeqManager.hpp"
+#include "Utils.hpp"
 #include <iostream>
 
 void FuzzerRtcSeqManager::Fuzz(const uint8_t* data, size_t len)

package/worker/fuzzer/src/RTC/FuzzerTrendCalculator.cpp

@@ -1,25 +1,25 @@
 #include "RTC/FuzzerTrendCalculator.hpp"
 #include "DepLibUV.hpp"
-#include "Utils.hpp"
 #include "RTC/TrendCalculator.hpp"
+#include "Utils.hpp"
 
 void FuzzerRtcTrendCalculator::Fuzz(const uint8_t* data, size_t len)
 {
 	RTC::TrendCalculator trend;
-	auto now = DepLibUV::GetTimeMs();
+	auto nowMs = DepLibUV::GetTimeMs();
 	size_t offset{ 0u };
 
 	while (len >= 4u)
 	{
 		const auto value = Utils::Byte::Get4Bytes(data, offset);
 
-		trend.Update(value, now);
+		trend.Update(value, nowMs);
 		trend.GetValue();
-		trend.Update(value, now - 1000u);
+		trend.Update(value, nowMs - 1000u);
 		trend.GetValue();
 
 		len -= 4u;
 		offset += 4;
-		now += 500u;
+		nowMs += 500u;
 	}
 }

package/worker/fuzzer/src/RTC/ICE/FuzzerStunPacket.cpp

@@ -2,12 +2,15 @@
 #include "RTC/ICE/StunPacket.hpp"
 #include <string_view>
 
-static constexpr size_t ResponseFactoryBufferLength{ 65536 };
-alignas(4) thread_local uint8_t ResponseFactoryBuffer[ResponseFactoryBufferLength];
-static constexpr size_t SerializeBufferLength{ 65536 };
-alignas(4) thread_local uint8_t SerializeBuffer[SerializeBufferLength];
-static constexpr size_t CloneBufferLength{ 65536 };
-alignas(4) thread_local uint8_t CloneBuffer[CloneBufferLength];
+namespace
+{
+	constexpr size_t ResponseFactoryBufferLength{ 65536 };
+	alignas(4) thread_local uint8_t ResponseFactoryBuffer[ResponseFactoryBufferLength];
+	constexpr size_t SerializeBufferLength{ 65536 };
+	alignas(4) thread_local uint8_t SerializeBuffer[SerializeBufferLength];
+	constexpr size_t CloneBufferLength{ 65536 };
+	alignas(4) thread_local uint8_t CloneBuffer[CloneBufferLength];
+} // namespace
 
 void FuzzerRtcIceStunPacket::Fuzz(const uint8_t* data, size_t len)
 {

package/worker/fuzzer/src/RTC/RTP/FuzzerRetransmissionBuffer.cpp

@@ -1,8 +1,8 @@
 #include "RTC/RTP/FuzzerRetransmissionBuffer.hpp"
-#include "Utils.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RetransmissionBuffer.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
+#include "Utils.hpp"
 
 void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 {

package/worker/fuzzer/src/RTC/RTP/FuzzerRtpStreamSend.cpp

@@ -1,6 +1,17 @@
 #include "RTC/RTP/FuzzerRtpStreamSend.hpp"
-#include "Utils.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
+#include "Utils.hpp"
+#include "mocks/include/MockShared.hpp"
+
+namespace
+{
+	// NOLINTNEXTLINE(readability-identifier-naming)
+	thread_local mocks::MockShared shared(/*getTimeMs*/
+	                                      []()
+	                                      {
+		                                      return 1000;
+	                                      });
+} // namespace
 
 void FuzzerRtcRtpStreamSend::Fuzz(const uint8_t* data, size_t len)
 {
@@ -30,7 +41,8 @@ void FuzzerRtcRtpStreamSend::Fuzz(const uint8_t* data, size_t len)
 	packet->SetSsrc(params.ssrc);
 
 	std::string mid;
-	auto* stream = new RTC::RTP::RtpStreamSend(&testRtpStreamListener, params, mid);
+	auto* stream = new RTC::RTP::RtpStreamSend(
+	  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 	size_t offset{ 0u };
 
 	while (len >= 4u)

package/worker/fuzzer/src/RTC/SCTP/association/FuzzerStateCookie.cpp

@@ -1,6 +1,6 @@
 #include "RTC/SCTP/FuzzerStateCookie.hpp"
-#include "Utils.hpp"
 #include "RTC/SCTP/association/StateCookie.hpp"
+#include "Utils.hpp"
 #include <cstring> // std::memcpy()
 
 namespace

package/worker/fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp

@@ -1,8 +1,11 @@
 #include "RTC/SCTP/packet/FuzzerPacket.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
 
-thread_local uint8_t PacketSerializeBuffer[65536];
-thread_local uint8_t PacketCloneBuffer[65536];
+namespace
+{
+	thread_local uint8_t PacketSerializeBuffer[65536];
+	thread_local uint8_t PacketCloneBuffer[65536];
+} // namespace
 
 void FuzzerRtcSctpPacket::Fuzz(const uint8_t* data, size_t len)
 {

package/worker/fuzzer/src/fuzzer.cpp

@@ -5,11 +5,7 @@
 #include "DepLibUV.hpp"
 #include "DepLibWebRTC.hpp"
 #include "DepOpenSSL.hpp"
-// TODO: Remove once we only use built-in SCTP stack.
-#include "DepUsrSCTP.hpp"
 #include "FuzzerUtils.hpp"
-#include "Settings.hpp"
-#include "Utils.hpp"
 #include "RTC/DtlsTransport.hpp"
 #include "RTC/FuzzerDtlsTransport.hpp"
 #include "RTC/FuzzerRateCalculator.hpp"
@@ -29,6 +25,8 @@
 #include "RTC/RTP/FuzzerRtpStreamSend.hpp"
 #include "RTC/SCTP/FuzzerStateCookie.hpp"
 #include "RTC/SCTP/packet/FuzzerPacket.hpp"
+#include "Settings.hpp"
+#include "Utils.hpp"
 #include <cstdlib> // std::getenv()
 #include <iostream>
 #include <sstream> // std::istringstream()
@@ -146,11 +144,6 @@ namespace
 		DepLibUV::ClassInit();
 		DepOpenSSL::ClassInit();
 		DepLibSRTP::ClassInit();
-		// TODO: Remove once we only use built-in SCTP stack.
-		if (!Settings::configuration.useBuiltInSctpStack)
-		{
-			DepUsrSCTP::ClassInit();
-		}
 		DepLibWebRTC::ClassInit();
 		Utils::Crypto::ClassInit();
 		RTC::DtlsTransport::ClassInit();
@@ -163,7 +156,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t len)
 {
 	// Trick to initialize our stuff just once.
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local const int unused = init();
+	static thread_local const int unused = init();
 
 	// Avoid [-Wunused-variable].
 	(void)unused;

package/worker/include/Channel/ChannelMessageRegistrator.hpp

@@ -0,0 +1,39 @@
+#ifndef MS_CHANNEL_MESSAGE_REGISTRATOR_HPP
+#define MS_CHANNEL_MESSAGE_REGISTRATOR_HPP
+
+#include "Channel/ChannelMessageRegistratorInterface.hpp"
+#include "Channel/ChannelSocket.hpp"
+#include <string>
+#include <unordered_map>
+
+namespace Channel
+{
+	class ChannelMessageRegistrator : public Channel::ChannelMessageRegistratorInterface
+	{
+	public:
+		explicit ChannelMessageRegistrator();
+
+		~ChannelMessageRegistrator() override;
+
+	public:
+		flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> FillBuffer(
+		  flatbuffers::FlatBufferBuilder& builder) override;
+
+		void RegisterHandler(
+		  const std::string& id,
+		  ChannelSocket::RequestHandler* channelRequestHandler,
+		  ChannelSocket::NotificationHandler* channelNotificationHandler) override;
+
+		void UnregisterHandler(const std::string& id) override;
+
+		ChannelSocket::RequestHandler* GetChannelRequestHandler(const std::string& id) override;
+
+		ChannelSocket::NotificationHandler* GetChannelNotificationHandler(const std::string& id) override;
+
+	private:
+		std::unordered_map<std::string, ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
+		std::unordered_map<std::string, ChannelSocket::NotificationHandler*> mapChannelNotificationHandlers;
+	};
+} // namespace Channel
+
+#endif

package/worker/include/Channel/ChannelMessageRegistratorInterface.hpp

@@ -0,0 +1,32 @@
+#ifndef MS_CHANNEL_MESSAGE_REGISTRATOR_INTERFACE_HPP
+#define MS_CHANNEL_MESSAGE_REGISTRATOR_INTERFACE_HPP
+
+// TODO: We should have a ChannelSocketInterface class instead.
+#include "Channel/ChannelSocket.hpp"
+#include <string>
+
+namespace Channel
+{
+	class ChannelMessageRegistratorInterface
+	{
+	public:
+		virtual ~ChannelMessageRegistratorInterface() = default;
+
+	public:
+		virtual flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> FillBuffer(
+		  flatbuffers::FlatBufferBuilder& builder) = 0;
+
+		virtual void RegisterHandler(
+		  const std::string& id,
+		  ChannelSocket::RequestHandler* channelRequestHandler,
+		  ChannelSocket::NotificationHandler* channelNotificationHandler) = 0;
+
+		virtual void UnregisterHandler(const std::string& id) = 0;
+
+		virtual ChannelSocket::RequestHandler* GetChannelRequestHandler(const std::string& id) = 0;
+
+		virtual ChannelSocket::NotificationHandler* GetChannelNotificationHandler(const std::string& id) = 0;
+	};
+} // namespace Channel
+
+#endif

package/worker/include/Channel/ChannelRequest.hpp

@@ -21,7 +21,7 @@ namespace Channel
 		using Method = FBS::Request::Method;
 
 	public:
-		thread_local static flatbuffers::FlatBufferBuilder bufferBuilder;
+		static thread_local flatbuffers::FlatBufferBuilder bufferBuilder;
 		static const absl::flat_hash_map<FBS::Request::Method, const char*> Method2String;
 
 	public:

package/worker/include/Channel/ChannelSocket.hpp

@@ -82,7 +82,7 @@ namespace Channel
 		};
 
 	public:
-#ifdef MS_TEST
+#if defined(MS_TEST) || defined(MS_FUZZER)
 		explicit ChannelSocket();
 #endif
 		explicit ChannelSocket(int consumerFd, int producerFd);

package/worker/include/DepLibUV.hpp

@@ -41,7 +41,7 @@ public:
 	}
 
 private:
-	thread_local static uv_loop_t* loop;
+	static thread_local uv_loop_t* loop;
 };
 
 #endif

package/worker/include/DepLibUring.hpp

@@ -1,8 +1,8 @@
 #ifndef MS_DEP_LIBURING_HPP
 #define MS_DEP_LIBURING_HPP
 
-#include "DepLibUV.hpp"
 #include "FBS/liburing.h"
+#include <uv.h>
 #include <functional>
 #include <liburing.h>
 #include <queue>
@@ -52,8 +52,8 @@ public:
 	class LibUring;
 
 	// Whether liburing is enabled or not after runtime checks.
-	thread_local static bool enabled;
-	thread_local static LibUring* liburing;
+	static thread_local bool enabled;
+	static thread_local LibUring* liburing;
 
 public:
 	// Singleton.

package/worker/include/Logger.hpp

@@ -96,9 +96,9 @@
 #define MS_LOGGER_HPP
 
 #include "common.hpp"
+#include "Channel/ChannelSocket.hpp"
 #include "LogLevel.hpp"
 #include "Settings.hpp"
-#include "Channel/ChannelSocket.hpp"
 #include <cstdio>  // std::snprintf(), std::fprintf(), stdout, stderr
 #include <cstdlib> // std::abort()
 #include <cstring>
@@ -156,10 +156,10 @@ public:
 	static void ClassInit(Channel::ChannelSocket* channel);
 
 public:
-	static const uint64_t pid;
-	thread_local static Channel::ChannelSocket* channel;
+	static const uint64_t Pid;
+	static thread_local Channel::ChannelSocket* channel;
 	static const size_t BufferSize {50000};
-	thread_local static char buffer[];
+	static thread_local char buffer[];
 };
 
 /* Logging macros. */

package/worker/include/MediaSoupErrors.hpp

@@ -14,7 +14,7 @@ public:
 
 public:
 	static const size_t BufferSize{ 2000 };
-	thread_local static char buffer[];
+	static thread_local char buffer[];
 };
 
 class MediaSoupTypeError : public MediaSoupError

package/worker/include/RTC/ActiveSpeakerObserver.hpp

@@ -1,9 +1,9 @@
 #ifndef MS_RTC_ACTIVE_SPEAKER_OBSERVER_HPP
 #define MS_RTC_ACTIVE_SPEAKER_OBSERVER_HPP
 
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/RtpObserver.hpp"
-#include "RTC/Shared.hpp"
-#include "handles/TimerHandle.hpp"
+#include "SharedInterface.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <vector>
 
@@ -14,13 +14,15 @@
 // https://github.com/jitsi/jitsi-utils/blob/master/src/main/java/org/jitsi/utils/dsi/DominantSpeakerIdentification.java
 namespace RTC
 {
-	class ActiveSpeakerObserver : public RTC::RtpObserver, public TimerHandle::Listener
+	class ActiveSpeakerObserver : public RTC::RtpObserver, public TimerHandleInterface::Listener
 	{
 	private:
 		class Speaker
 		{
 		public:
-			Speaker();
+			explicit Speaker(SharedInterface* shared);
+
+		public:
 			void EvalActivityScores();
 			double GetActivityScore(uint8_t interval) const;
 			void LevelChanged(uint32_t level, uint64_t now);
@@ -56,7 +58,7 @@ namespace RTC
 		class ProducerSpeaker
 		{
 		public:
-			explicit ProducerSpeaker(RTC::Producer* producer);
+			ProducerSpeaker(SharedInterface* shared, RTC::Producer* producer);
 			~ProducerSpeaker();
 
 		public:
@@ -69,7 +71,7 @@ namespace RTC
 
 	public:
 		ActiveSpeakerObserver(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::RtpObserver::Listener* listener,
 		  const FBS::ActiveSpeakerObserver::ActiveSpeakerObserverOptions* options);
@@ -89,14 +91,14 @@ namespace RTC
 		bool CalculateActiveSpeaker();
 		void TimeoutIdleLevels(uint64_t now);
 
-		/* Pure virtual methods inherited from TimerHandle. */
+		/* Pure virtual methods inherited from TimerHandleInterface. */
 	protected:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		double relativeSpeachActivities[RelativeSpeachActivitiesLen]{};
 		std::string dominantId;
-		TimerHandle* periodicTimer{ nullptr };
+		TimerHandleInterface* periodicTimer{ nullptr };
 		uint16_t interval{ 300u };
 		// Map of ProducerSpeakers indexed by Producer id.
 		absl::flat_hash_map<std::string, ProducerSpeaker*> mapProducerSpeakers;

package/worker/include/RTC/AudioLevelObserver.hpp

@@ -1,14 +1,14 @@
 #ifndef MS_RTC_AUDIO_LEVEL_OBSERVER_HPP
 #define MS_RTC_AUDIO_LEVEL_OBSERVER_HPP
 
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/RtpObserver.hpp"
-#include "RTC/Shared.hpp"
-#include "handles/TimerHandle.hpp"
+#include "SharedInterface.hpp"
 #include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {
-	class AudioLevelObserver : public RTC::RtpObserver, public TimerHandle::Listener
+	class AudioLevelObserver : public RTC::RtpObserver, public TimerHandleInterface::Listener
 	{
 	private:
 		struct DBovs
@@ -19,7 +19,7 @@ namespace RTC
 
 	public:
 		AudioLevelObserver(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::RtpObserver::Listener* listener,
 		  const FBS::AudioLevelObserver::AudioLevelObserverOptions* options);
@@ -38,9 +38,9 @@ namespace RTC
 		void Update();
 		void ResetMapProducerDBovs();
 
-		/* Pure virtual methods inherited from TimerHandle. */
+		/* Pure virtual methods inherited from TimerHandleInterface. */
 	protected:
-		void OnTimer(TimerHandle* timer) override;
+		void OnTimer(TimerHandleInterface* timer) override;
 
 	private:
 		// Passed by argument.
@@ -48,7 +48,7 @@ namespace RTC
 		int8_t threshold{ -80 };
 		uint16_t interval{ 1000u };
 		// Allocated by this.
-		TimerHandle* periodicTimer{ nullptr };
+		TimerHandleInterface* periodicTimer{ nullptr };
 		// Others.
 		absl::flat_hash_map<RTC::Producer*, DBovs> mapProducerDBovs;
 		bool silence{ true };

package/worker/include/RTC/Consumer.hpp

@@ -16,7 +16,7 @@
 #include "RTC/RTP/RtpStreamSend.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RtpDictionaries.hpp"
-#include "RTC/Shared.hpp"
+#include "SharedInterface.hpp"
 #include <absl/container/flat_hash_set.h>
 #include <string>
 #include <vector>
@@ -52,7 +52,7 @@ namespace RTC
 
 	public:
 		Consumer(
-		  RTC::Shared* shared,
+		  SharedInterface* shared,
 		  const std::string& id,
 		  const std::string& producerId,
 		  RTC::Consumer::Listener* listener,
@@ -177,7 +177,7 @@ namespace RTC
 
 	protected:
 		// Passed by argument.
-		RTC::Shared* shared{ nullptr };
+		SharedInterface* shared{ nullptr };
 		RTC::Consumer::Listener* listener{ nullptr };
 		RTC::Media::Kind kind;
 		RTC::RtpParameters rtpParameters;