mediasoup 3.19.21 → 3.20.0

package/worker/mocks/src/Channel/MockChannelMessageRegistrator.cpp

@@ -0,0 +1,128 @@
+#define MS_CLASS "ChannelMessageRegistrator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <vector>
+
+namespace mocks
+{
+	namespace Channel
+	{
+		MockChannelMessageRegistrator::MockChannelMessageRegistrator()
+		{
+			MS_TRACE();
+		}
+
+		MockChannelMessageRegistrator::~MockChannelMessageRegistrator()
+		{
+			MS_TRACE();
+
+			this->mapChannelRequestHandlers.clear();
+			this->mapChannelNotificationHandlers.clear();
+		}
+
+		flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> MockChannelMessageRegistrator::FillBuffer(
+		  flatbuffers::FlatBufferBuilder& builder)
+		{
+			// Add channelRequestHandlerIds.
+			std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
+
+			for (const auto& kv : this->mapChannelRequestHandlers)
+			{
+				const auto& handlerId = kv.first;
+
+				channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
+			}
+
+			// Add channelNotificationHandlerIds.
+			std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
+
+			for (const auto& kv : this->mapChannelNotificationHandlers)
+			{
+				const auto& handlerId = kv.first;
+
+				channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
+			}
+
+			return FBS::Worker::CreateChannelMessageHandlersDirect(
+			  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
+		}
+
+		void MockChannelMessageRegistrator::RegisterHandler(
+		  const std::string& id,
+		  ::Channel::ChannelSocket::RequestHandler* channelRequestHandler,
+		  ::Channel::ChannelSocket::NotificationHandler* channelNotificationHandler)
+		{
+			MS_TRACE();
+
+			if (channelRequestHandler)
+			{
+				if (this->mapChannelRequestHandlers.contains(id))
+				{
+					MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
+				}
+
+				this->mapChannelRequestHandlers[id] = channelRequestHandler;
+			}
+
+			if (channelNotificationHandler)
+			{
+				if (this->mapChannelNotificationHandlers.contains(id))
+				{
+					if (channelRequestHandler)
+					{
+						this->mapChannelRequestHandlers.erase(id);
+					}
+
+					MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
+				}
+
+				this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
+			}
+		}
+
+		void MockChannelMessageRegistrator::UnregisterHandler(const std::string& id)
+		{
+			MS_TRACE();
+
+			this->mapChannelRequestHandlers.erase(id);
+			this->mapChannelNotificationHandlers.erase(id);
+		}
+
+		::Channel::ChannelSocket::RequestHandler* MockChannelMessageRegistrator::GetChannelRequestHandler(
+		  const std::string& id)
+		{
+			MS_TRACE();
+
+			auto it = this->mapChannelRequestHandlers.find(id);
+
+			if (it != this->mapChannelRequestHandlers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+
+		::Channel::ChannelSocket::NotificationHandler* MockChannelMessageRegistrator::GetChannelNotificationHandler(
+		  const std::string& id)
+		{
+			MS_TRACE();
+
+			auto it = this->mapChannelNotificationHandlers.find(id);
+
+			if (it != this->mapChannelNotificationHandlers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+	} // namespace Channel
+} // namespace mocks

package/worker/mocks/src/MockShared.cpp

@@ -0,0 +1,46 @@
+#define MS_CLASS "mocks::MockShared"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/MockShared.hpp"
+#include "Logger.hpp"
+#include "mocks/include/handles/MockTimerHandle.hpp"
+
+namespace mocks
+{
+	MockShared::MockShared(std::function<uint64_t()> getTimeMs)
+	  : getTimeMs(std::move(getTimeMs)),
+	    channelSocket(new ::Channel::ChannelSocket()),
+	    channelMessageRegistrator(new mocks::Channel::MockChannelMessageRegistrator()),
+	    channelNotifier(new ::Channel::ChannelNotifier(this->channelSocket.get()))
+	{
+		MS_TRACE();
+	}
+
+	TimerHandleInterface* MockShared::CreateTimer(TimerHandleInterface::Listener* /*listener*/)
+	{
+		MS_TRACE();
+
+		return new MockTimerHandle();
+	}
+
+	BackoffTimerHandleInterface* MockShared::CreateBackoffTimer(
+	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options)
+	{
+		MS_TRACE();
+
+		const auto& label = options.label;
+
+		auto* backoffTimer = new MockBackoffTimerHandle(
+		  options,
+		  /*getTimeMs*/ this->getTimeMs,
+		  /*onDelete*/
+		  [this, label]()
+		  {
+			  this->backoffTimers.erase(label);
+		  });
+
+		this->backoffTimers[options.label] = backoffTimer;
+
+		return backoffTimer;
+	}
+} // namespace mocks

package/worker/mocks/src/RTC/SCTP/association/MockTransmissionControlBlockContext.cpp

@@ -0,0 +1,39 @@
+#define MS_CLASS "mocks::RTC::SCTP::MockTransmissionControlBlockContext"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/RTC/SCTP/association/MockTransmissionControlBlockContext.hpp"
+#include "Logger.hpp"
+
+alignas(4) static thread_local uint8_t FactoryBuffer[65536];
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			std::unique_ptr<::RTC::SCTP::Packet> MockTransmissionControlBlockContext::CreatePacket() const
+			{
+				MS_TRACE();
+
+				auto packet = std::unique_ptr<::RTC::SCTP::Packet>{ ::RTC::SCTP::Packet::Factory(
+					FactoryBuffer, this->sctpOptions.mtu) };
+
+				packet->SetSourcePort(this->sctpOptions.sourcePort);
+				packet->SetDestinationPort(this->sctpOptions.destinationPort);
+
+				return packet;
+			}
+
+			bool MockTransmissionControlBlockContext::SendPacket(::RTC::SCTP::Packet* packet)
+			{
+				MS_TRACE();
+
+				const bool sent =
+				  this->associationListener.OnAssociationSendData(packet->GetBuffer(), packet->GetLength());
+
+				return sent;
+			}
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks

package/worker/mocks/src/handles/MockBackoffTimerHandle.cpp

@@ -0,0 +1,127 @@
+#define MS_CLASS "mocks::MockBackoffTimerHandle"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/handles/MockBackoffTimerHandle.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <string>
+
+namespace mocks
+{
+	MockBackoffTimerHandle::MockBackoffTimerHandle(
+	  BackoffTimerHandleOptions options,
+	  std::function<uint64_t()> getTimeMs,
+	  std::function<void()> onDelete)
+	  : listener(options.listener),
+	    label(std::move(options.label)),
+	    baseTimeoutMs(options.baseTimeoutMs),
+	    backoffAlgorithm(options.backoffAlgorithm),
+	    maxBackoffTimeoutMs(options.maxBackoffTimeoutMs),
+	    maxRestarts(options.maxRestarts),
+	    getTimeMs(std::move(getTimeMs)),
+	    onDelete(std::move(onDelete))
+	{
+		MS_TRACE();
+
+		if (!this->listener)
+		{
+			MS_THROW_TYPE_ERROR("options.listener must be given");
+		}
+
+		if (this->label.empty())
+		{
+			MS_THROW_TYPE_ERROR("options.label must be given");
+		}
+
+		if (this->baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
+		{
+			MS_THROW_ERROR(
+			  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+			  this->label.c_str(),
+			  this->baseTimeoutMs,
+			  BackoffTimerHandleInterface::MaxTimeoutMs);
+		}
+	}
+
+	void MockBackoffTimerHandle::Dump(int indentation) const
+	{
+		MS_TRACE();
+
+		const uint64_t nowMs = this->getTimeMs();
+
+		MS_DUMP_CLEAN(indentation, "<mocks::MockBackoffTimerHandle>");
+
+		MS_DUMP_CLEAN(indentation, "  label: %s", this->label.c_str());
+		MS_DUMP_CLEAN(indentation, "  base timeout (ms): %" PRIu64, this->baseTimeoutMs);
+		MS_DUMP_CLEAN(
+		  indentation,
+		  "  max backoff timeout (ms): %s",
+		  this->maxBackoffTimeoutMs.has_value()
+		    ? std::to_string(this->maxBackoffTimeoutMs.value()).c_str()
+		    : "(unset)");
+		MS_DUMP_CLEAN(
+		  indentation,
+		  "  max restarts (ms): %s",
+		  this->maxRestarts.has_value() ? std::to_string(this->maxRestarts.value()).c_str() : "(unset)");
+		MS_DUMP_CLEAN(indentation, "  running: %s", this->running ? "yes" : "no");
+		MS_DUMP_CLEAN(indentation, "  expiration count: %zu", this->expirationCount);
+		MS_DUMP_CLEAN(indentation, "  now (ms): %" PRIu64, nowMs);
+		MS_DUMP_CLEAN(indentation, "  expires at (ms): %" PRIu64, this->expiresAtMs);
+		MS_DUMP_CLEAN(indentation, "  expires in (ms): %" PRIu64, this->expiresAtMs - nowMs);
+
+		MS_DUMP_CLEAN(indentation, "</mocks::MockBackoffTimerHandle>");
+	}
+
+	void MockBackoffTimerHandle::SetBaseTimeoutMs(uint64_t baseTimeoutMs)
+	{
+		MS_TRACE();
+
+		if (baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
+		{
+			MS_THROW_ERROR(
+			  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+			  this->label.c_str(),
+			  baseTimeoutMs,
+			  BackoffTimerHandleInterface::MaxTimeoutMs);
+		}
+
+		this->baseTimeoutMs = baseTimeoutMs;
+	}
+
+	void MockBackoffTimerHandle::TriggerExpire()
+	{
+		MS_TRACE();
+
+		this->expirationCount++;
+
+		// Compute whether the BackoffTimer should still be running after this timeout
+		// expiration so the parent can check IsRunning() within the `OnBackoffTimer()`
+		// callback.
+		this->running =
+		  !this->maxRestarts.has_value() || this->expirationCount <= this->maxRestarts.value();
+
+		uint64_t baseTimeoutMs{ this->baseTimeoutMs };
+		bool stop{ false };
+
+		// Call the listener by passing base timeout as reference so the parent has
+		// a chance to change it and affect the next timeout.
+		this->listener->OnBackoffTimer(this, baseTimeoutMs, stop);
+
+		// If the parent has set `stop` to true it means that it has deleted the
+		// instance, so stop here.
+		if (stop)
+		{
+			return;
+		}
+
+		// NOTE: This may throw.
+		SetBaseTimeoutMs(baseTimeoutMs);
+
+		// The caller may have called Stop() within the callback so we must check
+		// the `running` flag.
+		if (this->running)
+		{
+			this->expiresAtMs = this->getTimeMs() + ComputeNextTimeoutMs();
+		}
+	}
+} // namespace mocks

package/worker/scripts/clang-scripts.mjs

@@ -19,12 +19,16 @@ const CLANG_FORMAT_PATHS = [
 	'../test/include/**/**.hpp',
 	'../fuzzer/src/**/*.cpp',
 	'../fuzzer/include/**/*.hpp',
+	'../mocks/src/**/*.cpp',
+	'../mocks/include/**/*.hpp',
+	'../deps/libwebrtc/libwebrtc/mediasoup_helpers.h',
 ];
 
 const CLANG_TIDY_PATHS = [
 	'../src/**/*.cpp',
 	'../test/src/**/*.cpp',
 	'../fuzzer/src/**/*.cpp',
+	'../mocks/src/**/*.cpp',
 ];
 
 const task = process.argv.slice(2).join(' ');
@@ -287,7 +291,7 @@ function getRootDir() {
 }
 
 function getBuildDir() {
-	const workerDir = path.join(ROOT_DIR, 'worker/');
+	const workerDir = path.join(ROOT_DIR, 'worker');
 	const workerOutDir = process.env.MEDIASOUP_OUT_DIR ?? `${workerDir}/out`;
 	const mediasoupBuildtype = process.env.MEDIASOUP_BUILDTYPE ?? 'Release';
 	const workerInstallDir =

package/worker/scripts/package-lock.json

@@ -21,10 +21,9 @@
 			}
 		},
 		"node_modules/brace-expansion": {
-			"version": "5.0.5",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-			"integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
-			"license": "MIT",
+			"version": "5.0.6",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+			"integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
 			"dependencies": {
 				"balanced-match": "^4.0.2"
 			},
@@ -105,9 +104,9 @@
 			"integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="
 		},
 		"brace-expansion": {
-			"version": "5.0.5",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-			"integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+			"version": "5.0.6",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+			"integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
 			"requires": {
 				"balanced-match": "^4.0.2"
 			}

package/worker/src/Channel/ChannelMessageRegistrator.cpp

@@ -0,0 +1,125 @@
+#define MS_CLASS "ChannelMessageRegistrator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "Channel/ChannelMessageRegistrator.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <vector>
+
+namespace Channel
+{
+	ChannelMessageRegistrator::ChannelMessageRegistrator()
+	{
+		MS_TRACE();
+	}
+
+	ChannelMessageRegistrator::~ChannelMessageRegistrator()
+	{
+		MS_TRACE();
+
+		this->mapChannelRequestHandlers.clear();
+		this->mapChannelNotificationHandlers.clear();
+	}
+
+	flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> ChannelMessageRegistrator::FillBuffer(
+	  flatbuffers::FlatBufferBuilder& builder)
+	{
+		// Add channelRequestHandlerIds.
+		std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
+
+		for (const auto& kv : this->mapChannelRequestHandlers)
+		{
+			const auto& handlerId = kv.first;
+
+			channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
+		}
+
+		// Add channelNotificationHandlerIds.
+		std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
+
+		for (const auto& kv : this->mapChannelNotificationHandlers)
+		{
+			const auto& handlerId = kv.first;
+
+			channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
+		}
+
+		return FBS::Worker::CreateChannelMessageHandlersDirect(
+		  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
+	}
+
+	void ChannelMessageRegistrator::RegisterHandler(
+	  const std::string& id,
+	  ChannelSocket::RequestHandler* channelRequestHandler,
+	  ChannelSocket::NotificationHandler* channelNotificationHandler)
+	{
+		MS_TRACE();
+
+		if (channelRequestHandler)
+		{
+			if (this->mapChannelRequestHandlers.contains(id))
+			{
+				MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
+			}
+
+			this->mapChannelRequestHandlers[id] = channelRequestHandler;
+		}
+
+		if (channelNotificationHandler)
+		{
+			if (this->mapChannelNotificationHandlers.contains(id))
+			{
+				if (channelRequestHandler)
+				{
+					this->mapChannelRequestHandlers.erase(id);
+				}
+
+				MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
+			}
+
+			this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
+		}
+	}
+
+	void ChannelMessageRegistrator::UnregisterHandler(const std::string& id)
+	{
+		MS_TRACE();
+
+		this->mapChannelRequestHandlers.erase(id);
+		this->mapChannelNotificationHandlers.erase(id);
+	}
+
+	ChannelSocket::RequestHandler* ChannelMessageRegistrator::GetChannelRequestHandler(
+	  const std::string& id)
+	{
+		MS_TRACE();
+
+		auto it = this->mapChannelRequestHandlers.find(id);
+
+		if (it != this->mapChannelRequestHandlers.end())
+		{
+			return it->second;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+
+	ChannelSocket::NotificationHandler* ChannelMessageRegistrator::GetChannelNotificationHandler(
+	  const std::string& id)
+	{
+		MS_TRACE();
+
+		auto it = this->mapChannelNotificationHandlers.find(id);
+
+		if (it != this->mapChannelNotificationHandlers.end())
+		{
+			return it->second;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+} // namespace Channel

package/worker/src/Channel/ChannelSocket.cpp

@@ -9,9 +9,8 @@
 
 namespace Channel
 {
-	// Binary length for a 4194304 bytes payload.
-	static constexpr size_t MessageMaxLen{ 4194308 };
-	static constexpr size_t PayloadMaxLen{ 4194304 };
+	static constexpr size_t MessageMaxLen{ 8388608 };
+	static constexpr size_t PayloadMaxLen{ MessageMaxLen - 4 };
 
 	/* Static methods for UV callbacks. */
 
@@ -30,7 +29,7 @@ namespace Channel
 
 	/* Instance methods. */
 
-#ifdef MS_TEST
+#if defined(MS_TEST) || defined(MS_FUZZER)
 	ChannelSocket::ChannelSocket()
 	{
 		MS_TRACE_STD();

package/worker/src/DepLibUV.cpp

@@ -4,7 +4,7 @@
 #include "DepLibUV.hpp"
 #include "Logger.hpp"
 
-/* Static variables. */
+/* Class variables. */
 
 thread_local uv_loop_t* DepLibUV::loop{ nullptr };
 

package/worker/src/DepLibUring.cpp

@@ -2,6 +2,7 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "DepLibUring.hpp"
+#include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include "Settings.hpp"
@@ -11,7 +12,8 @@
 #include <sys/resource.h>
 #include <sys/utsname.h>
 
-/* Static variables. */
+/* Class variables. */
+
 thread_local bool DepLibUring::enabled{ false };
 // liburing instance per thread.
 thread_local DepLibUring::LibUring* DepLibUring::liburing{ nullptr };

package/worker/src/Logger.cpp

@@ -6,7 +6,7 @@
 
 /* Class variables. */
 
-const uint64_t Logger::pid{ static_cast<uint64_t>(uv_os_getpid()) };
+const uint64_t Logger::Pid{ static_cast<uint64_t>(uv_os_getpid()) };
 thread_local Channel::ChannelSocket* Logger::channel{ nullptr };
 thread_local char Logger::buffer[Logger::BufferSize];
 

package/worker/src/MediaSoupErrors.cpp

@@ -2,4 +2,6 @@
 
 #include "MediaSoupErrors.hpp"
 
+/* Class variables. */
+
 thread_local char MediaSoupError::buffer[MediaSoupError::BufferSize];

package/worker/src/RTC/ActiveSpeakerObserver.cpp

@@ -88,7 +88,7 @@ namespace RTC
 	}
 
 	ActiveSpeakerObserver::ActiveSpeakerObserver(
-	  RTC::Shared* shared,
+	  SharedInterface* shared,
 	  const std::string& id,
 	  RTC::RtpObserver::Listener* listener,
 	  const FBS::ActiveSpeakerObserver::ActiveSpeakerObserverOptions* options)
@@ -105,12 +105,12 @@ namespace RTC
 			this->interval = 5000;
 		}
 
-		this->periodicTimer = new TimerHandle(this);
+		this->periodicTimer = this->shared->CreateTimer(this);
 
 		this->periodicTimer->Start(interval, interval);
 
 		// NOTE: This may throw.
-		this->shared->channelMessageRegistrator->RegisterHandler(
+		this->shared->GetChannelMessageRegistrator()->RegisterHandler(
 		  this->id,
 		  /*channelRequestHandler*/ this,
 		  /*channelNotificationHandler*/ nullptr);
@@ -120,7 +120,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		this->shared->channelMessageRegistrator->UnregisterHandler(this->id);
+		this->shared->GetChannelMessageRegistrator()->UnregisterHandler(this->id);
 
 		delete this->periodicTimer;
 
@@ -149,7 +149,7 @@ namespace RTC
 			MS_THROW_ERROR("Producer already in map");
 		}
 
-		this->mapProducerSpeakers[producer->id] = new ProducerSpeaker(producer);
+		this->mapProducerSpeakers[producer->id] = new ProducerSpeaker(this->shared, producer);
 	}
 
 	void ActiveSpeakerObserver::RemoveProducer(RTC::Producer* producer)
@@ -229,7 +229,7 @@ namespace RTC
 		if (it != this->mapProducerSpeakers.end())
 		{
 			auto* producerSpeaker = it->second;
-			const uint64_t now    = DepLibUV::GetTimeMs();
+			const uint64_t now    = this->shared->GetTimeMs();
 
 			producerSpeaker->speaker->LevelChanged(volume, now);
 		}
@@ -249,7 +249,7 @@ namespace RTC
 		this->periodicTimer->Restart();
 	}
 
-	void ActiveSpeakerObserver::OnTimer(TimerHandle* /*timer*/)
+	void ActiveSpeakerObserver::OnTimer(TimerHandleInterface* /*timer*/)
 	{
 		MS_TRACE();
 
@@ -260,7 +260,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		const uint64_t now = DepLibUV::GetTimeMs();
+		const uint64_t now = this->shared->GetTimeMs();
 
 		if (now - this->lastLevelIdleTime >= LevelIdleTimeout)
 		{
@@ -275,9 +275,9 @@ namespace RTC
 		if (!this->mapProducerSpeakers.empty() && CalculateActiveSpeaker())
 		{
 			auto notification = FBS::ActiveSpeakerObserver::CreateDominantSpeakerNotificationDirect(
-			  this->shared->channelNotifier->GetBufferBuilder(), this->dominantId.c_str());
+			  this->shared->GetChannelNotifier()->GetBufferBuilder(), this->dominantId.c_str());
 
-			this->shared->channelNotifier->Emit(
+			this->shared->GetChannelNotifier()->Emit(
 			  this->id,
 			  FBS::Notification::Event::ACTIVESPEAKEROBSERVER_DOMINANT_SPEAKER,
 			  FBS::Notification::Body::ActiveSpeakerObserver_DominantSpeakerNotification,
@@ -387,8 +387,8 @@ namespace RTC
 		}
 	}
 
-	ActiveSpeakerObserver::ProducerSpeaker::ProducerSpeaker(RTC::Producer* producer)
-	  : producer(producer), speaker(new Speaker())
+	ActiveSpeakerObserver::ProducerSpeaker::ProducerSpeaker(SharedInterface* shared, RTC::Producer* producer)
+	  : producer(producer), speaker(new Speaker(shared))
 	{
 		MS_TRACE();
 
@@ -402,11 +402,11 @@ namespace RTC
 		delete this->speaker;
 	}
 
-	ActiveSpeakerObserver::Speaker::Speaker()
+	ActiveSpeakerObserver::Speaker::Speaker(SharedInterface* shared)
 	  : immediateActivityScore(MinActivityScore),
 	    mediumActivityScore(MinActivityScore),
 	    longActivityScore(MinActivityScore),
-	    lastLevelChangeTime(DepLibUV::GetTimeMs()),
+	    lastLevelChangeTime(shared->GetTimeMs()),
 	    minLevel(MinLevel),
 	    nextMinLevel(MinLevel),
 	    immediates(ImmediateBuffLen, 0),