mediasoup 3.26.0 → 3.27.0

package/worker/mocks/include/handles/MockTimerHandle.hpp

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "handles/TimerHandleInterface.hpp"
+#include <limits>
 
 namespace mocks
 {
@@ -15,48 +16,49 @@ namespace mocks
 		friend class mocks::MockShared;
 
 	private:
-		explicit MockTimerHandle() = default;
+		explicit MockTimerHandle(
+		  TimerHandleInterface::Listener* listener,
+		  std::string label,
+		  std::function<int64_t()> getTimeMs,
+		  std::function<void()> onDelete);
 
 	public:
 		MockTimerHandle& operator=(const MockTimerHandle&) = delete;
 
 		MockTimerHandle(const MockTimerHandle&) = delete;
 
-		~MockTimerHandle() override = default;
-
-	public:
-		void Start(uint64_t timeout, uint64_t repeat = 0) override
+		~MockTimerHandle() override
 		{
-			this->running = true;
-			this->timeout = timeout;
-			this->repeat  = repeat;
+			this->onDelete();
 		}
 
+	public:
+		void Dump(int indentation = 0) const;
+
+		void Start(int64_t timeoutMs, int64_t repeatMs = 0) override;
+
 		void Stop() override
 		{
-			this->running = false;
+			this->running     = false;
+			this->expiresAtMs = std::numeric_limits<int64_t>::max();
 		}
 
 		void Restart() override
 		{
-			this->running = true;
+			this->running     = true;
+			this->expiresAtMs = this->getTimeMs() + this->timeoutMs;
 		}
 
-		void Restart(uint64_t timeout, uint64_t repeat = 0) override
-		{
-			this->running = true;
-			this->timeout = timeout;
-			this->repeat  = repeat;
-		}
+		void Restart(int64_t timeoutMs, int64_t repeatMs = 0) override;
 
-		uint64_t GetTimeout() const override
+		int64_t GetTimeoutMs() const override
 		{
-			return this->timeout;
+			return this->timeoutMs;
 		}
 
-		uint64_t GetRepeat() const override
+		int64_t GetRepeatMs() const override
 		{
-			return this->repeat;
+			return this->repeatMs;
 		}
 
 		bool IsActive() const override
@@ -64,10 +66,46 @@ namespace mocks
 			return this->running;
 		}
 
+		const std::string GetLabel() const override
+		{
+			return this->label;
+		}
+
+		// Methods for testing.
+	public:
+		int64_t GetExpiresAtMs() const
+		{
+			return this->expiresAtMs;
+		}
+
+		bool EvaluateHasExpired()
+		{
+			if (this->getTimeMs() >= this->expiresAtMs)
+			{
+				TriggerExpire();
+
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+	private:
+		void TriggerExpire();
+
 	private:
+		// Passed by argument.
+		TimerHandleInterface::Listener* listener{ nullptr };
+		const std::string label;
+		std::function<int64_t()> getTimeMs;
+		const std::function<void()> onDelete;
+		// Others.
 		bool running{ false };
-		uint64_t timeout{ 0u };
-		uint64_t repeat{ 0u };
+		int64_t timeoutMs{ 0 };
+		int64_t repeatMs{ 0 };
+		int64_t expiresAtMs{ std::numeric_limits<int64_t>::max() };
 	};
 } // namespace mocks
 

package/worker/mocks/src/MockShared.cpp

@@ -3,24 +3,56 @@
 
 #include "mocks/include/MockShared.hpp"
 #include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
 #include "mocks/include/handles/MockTimerHandle.hpp"
 
 namespace mocks
 {
-	MockShared::MockShared(std::function<uint64_t()> getTimeMs)
-	  : getTimeMs(std::move(getTimeMs)),
+	MockShared::MockShared(std::function<int64_t()> getTimeUs)
+	  : getTimeUs(std::move(getTimeUs)),
 	    channelSocket(new ::Channel::ChannelSocket()),
 	    channelMessageRegistrator(new mocks::Channel::MockChannelMessageRegistrator()),
 	    channelNotifier(new ::Channel::ChannelNotifier(this->channelSocket.get()))
 	{
 		MS_TRACE();
+
+		// Give the Channel the Shared instance, which it needs to take the arrival
+		// time of received notifications.
+		this->channelSocket->SetShared(this);
 	}
 
-	TimerHandleInterface* MockShared::CreateTimer(TimerHandleInterface::Listener* /*listener*/)
+	TimerHandleInterface* MockShared::CreateTimer(
+	  TimerHandleInterface::Listener* listener, std::string label)
 	{
 		MS_TRACE();
 
-		return new MockTimerHandle();
+		// NOTE: Timers are indexed by label so that tests can retrieve them via
+		// GetTimer(). Two alive timers sharing a label would make that lookup
+		// ambiguous.
+		if (this->timers.find(label) != this->timers.end())
+		{
+			MS_THROW_ERROR("a timer with same label already exists [label:%s]", label.c_str());
+		}
+
+		auto* timer = new MockTimerHandle(
+		  listener,
+		  label,
+		  // NOTE: The timer mocks take a milliseconds callback, being that the
+		  // resolution of the libuv handles they mimic.
+		  /*getTimeMs*/
+		  [getTimeUs = this->getTimeUs]() -> int64_t
+		  {
+			  return getTimeUs() / 1000;
+		  },
+		  /*onDelete*/
+		  [this, label]()
+		  {
+			  this->timers.erase(label);
+		  });
+
+		this->timers[label] = timer;
+
+		return timer;
 	}
 
 	BackoffTimerHandleInterface* MockShared::CreateBackoffTimer(
@@ -30,9 +62,23 @@ namespace mocks
 
 		const auto& label = options.label;
 
+		// NOTE: Backoff timers are indexed by label so that tests can retrieve them
+		// via GetBackoffTimer(). Two alive timers sharing a label would make that
+		// lookup ambiguous.
+		if (this->backoffTimers.find(label) != this->backoffTimers.end())
+		{
+			MS_THROW_ERROR("a backoff timer with same label already exists [label:%s]", label.c_str());
+		}
+
 		auto* backoffTimer = new MockBackoffTimerHandle(
 		  options,
-		  /*getTimeMs*/ this->getTimeMs,
+		  // NOTE: The timer mocks take a milliseconds callback, being that the
+		  // resolution of the libuv handles they mimic.
+		  /*getTimeMs*/
+		  [getTimeUs = this->getTimeUs]() -> int64_t
+		  {
+			  return getTimeUs() / 1000;
+		  },
 		  /*onDelete*/
 		  [this, label]()
 		  {

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

@@ -10,7 +10,7 @@ namespace mocks
 {
 	MockBackoffTimerHandle::MockBackoffTimerHandle(
 	  BackoffTimerHandleOptions options,
-	  std::function<uint64_t()> getTimeMs,
+	  std::function<int64_t()> getTimeMs,
 	  std::function<void()> onDelete)
 	  : listener(options.listener),
 	    label(std::move(options.label)),
@@ -25,7 +25,7 @@ namespace mocks
 
 		if (!this->listener)
 		{
-			MS_THROW_TYPE_ERROR("options.listener must be given");
+			MS_THROW_TYPE_ERROR("[%s] options.listener must be given", this->label.c_str());
 		}
 
 		if (this->label.empty())
@@ -33,10 +33,18 @@ namespace mocks
 			MS_THROW_TYPE_ERROR("options.label must be given");
 		}
 
+		if (this->baseTimeoutMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] options.baseTimeoutMs (%" PRIi64 " ms) cannot be negative",
+			  this->label.c_str(),
+			  this->baseTimeoutMs);
+		}
+
 		if (this->baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
 		{
-			MS_THROW_ERROR(
-			  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+			MS_THROW_TYPE_ERROR(
+			  "[%s] options.baseTimeoutMs (%" PRIi64 " ms) cannot be greater than %" PRIi64 " ms",
 			  this->label.c_str(),
 			  this->baseTimeoutMs,
 			  BackoffTimerHandleInterface::MaxTimeoutMs);
@@ -47,39 +55,45 @@ namespace mocks
 	{
 		MS_TRACE();
 
-		const uint64_t nowMs = this->getTimeMs();
+		const int64_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, "  base timeout (ms): %" PRIi64, this->baseTimeoutMs);
 		MS_DUMP_CLEAN(
 		  indentation,
 		  "  max backoff timeout (ms): %s",
 		  this->maxBackoffTimeoutMs.has_value()
 		    ? std::to_string(this->maxBackoffTimeoutMs.value()).c_str()
-		    : "(unset)");
+				: "(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, "  now (ms): %" PRIi64, nowMs);
+		MS_DUMP_CLEAN(indentation, "  expires at (ms): %" PRIi64, this->expiresAtMs);
+		MS_DUMP_CLEAN(indentation, "  expires in (ms): %" PRIi64, this->expiresAtMs - nowMs);
 
 		MS_DUMP_CLEAN(indentation, "</mocks::MockBackoffTimerHandle>");
 	}
 
-	void MockBackoffTimerHandle::SetBaseTimeoutMs(uint64_t baseTimeoutMs)
+	void MockBackoffTimerHandle::SetBaseTimeoutMs(int64_t baseTimeoutMs)
 	{
 		MS_TRACE();
 
+		if (baseTimeoutMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] baseTimeoutMs (%" PRIi64 " ms) cannot be negative", this->label.c_str(), baseTimeoutMs);
+		}
+
 		if (baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
 		{
-			MS_THROW_ERROR(
-			  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+			MS_THROW_TYPE_ERROR(
+			  "[%s] baseTimeoutMs (%" PRIi64 " ms) cannot be greater than %" PRIi64 " ms",
 			  this->label.c_str(),
 			  baseTimeoutMs,
 			  BackoffTimerHandleInterface::MaxTimeoutMs);
@@ -100,7 +114,7 @@ namespace mocks
 		this->running =
 		  !this->maxRestarts.has_value() || this->expirationCount <= this->maxRestarts.value();
 
-		uint64_t baseTimeoutMs{ this->baseTimeoutMs };
+		int64_t baseTimeoutMs{ this->baseTimeoutMs };
 		bool stop{ false };
 
 		// Call the listener by passing base timeout as reference so the parent has
@@ -128,7 +142,7 @@ namespace mocks
 		// again. Mirror that here so a stopped timer doesn't keep expiring.
 		else
 		{
-			this->expiresAtMs = std::numeric_limits<uint64_t>::max();
+			this->expiresAtMs = std::numeric_limits<int64_t>::max();
 		}
 	}
 } // namespace mocks

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

@@ -0,0 +1,117 @@
+#define MS_CLASS "mocks::MockTimerHandle"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/handles/MockTimerHandle.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+
+namespace mocks
+{
+	MockTimerHandle::MockTimerHandle(
+	  TimerHandleInterface::Listener* listener,
+	  std::string label,
+	  std::function<int64_t()> getTimeMs,
+	  std::function<void()> onDelete)
+	  : listener(listener),
+	    label(std::move(label)),
+	    getTimeMs(std::move(getTimeMs)),
+	    onDelete(std::move(onDelete))
+	{
+		MS_TRACE();
+
+		if (!this->listener)
+		{
+			MS_THROW_TYPE_ERROR("[%s] listener must be given", this->label.c_str());
+		}
+
+		if (this->label.empty())
+		{
+			MS_THROW_TYPE_ERROR("label must be given");
+		}
+	}
+
+	void MockTimerHandle::Dump(int indentation) const
+	{
+		MS_TRACE();
+
+		const int64_t nowMs = this->getTimeMs();
+
+		MS_DUMP_CLEAN(indentation, "<mocks::MockTimerHandle>");
+
+		MS_DUMP_CLEAN(indentation, "  label: %s", this->label.c_str());
+		MS_DUMP_CLEAN(indentation, "  timeout (ms): %" PRIi64, this->timeoutMs);
+		MS_DUMP_CLEAN(indentation, "  repeat (ms): %" PRIi64, this->repeatMs);
+		MS_DUMP_CLEAN(indentation, "  running: %s", this->running ? "yes" : "no");
+		MS_DUMP_CLEAN(indentation, "  now (ms): %" PRIi64, nowMs);
+		MS_DUMP_CLEAN(indentation, "  expires at (ms): %" PRIi64, this->expiresAtMs);
+		MS_DUMP_CLEAN(indentation, "  expires in (ms): %" PRIi64, this->expiresAtMs - nowMs);
+
+		MS_DUMP_CLEAN(indentation, "</mocks::MockTimerHandle>");
+	}
+
+	void MockTimerHandle::Start(int64_t timeoutMs, int64_t repeatMs)
+	{
+		MS_TRACE();
+
+		if (timeoutMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] timeoutMs (%" PRIi64 " ms) cannot be negative", this->label.c_str(), timeoutMs);
+		}
+
+		if (repeatMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] repeatMs (%" PRIi64 " ms) cannot be negative", this->label.c_str(), repeatMs);
+		}
+
+		this->timeoutMs = timeoutMs;
+		this->repeatMs  = repeatMs;
+
+		this->running     = true;
+		this->expiresAtMs = this->getTimeMs() + this->timeoutMs;
+	}
+
+	void MockTimerHandle::Restart(int64_t timeoutMs, int64_t repeatMs)
+	{
+		MS_TRACE();
+
+		if (timeoutMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] timeoutMs (%" PRIi64 " ms) cannot be negative", this->label.c_str(), timeoutMs);
+		}
+
+		if (repeatMs < 0)
+		{
+			MS_THROW_TYPE_ERROR(
+			  "[%s] repeatMs (%" PRIi64 " ms) cannot be negative", this->label.c_str(), repeatMs);
+		}
+
+		Start(timeoutMs, repeatMs);
+	}
+
+	void MockTimerHandle::TriggerExpire()
+	{
+		MS_TRACE();
+
+		// Schedule the next expiration, or deactivate the timer if it doesn't
+		// repeat, just like the real TimerHandle does. This is done before invoking
+		// the callback for two reasons: the listener may call Start(), Restart() or
+		// Stop() within it, which must win over this, and the listener may delete
+		// this instance within it, so nothing can be accessed afterwards.
+		if (this->repeatMs != 0)
+		{
+			this->running     = true;
+			this->expiresAtMs = this->getTimeMs() + this->repeatMs;
+		}
+		else
+		{
+			this->running     = false;
+			this->expiresAtMs = std::numeric_limits<int64_t>::max();
+		}
+
+		// Notify the listener.
+		this->listener->OnTimer(this);
+	}
+} // namespace mocks

package/worker/scripts/clang-scripts.mjs

@@ -9,7 +9,7 @@ const PYTHON = getPython();
 const ROOT_DIR = getRootDir();
 const BUILD_DIR = getBuildDir();
 const NUM_CORES = getNumCores();
-const CLANG_FORMAT_VERSION = 22;
+const CLANG_FORMAT_VERSION = 23;
 const CLANG_TIDY_VERSION = 21;
 
 const CLANG_FORMAT_PATHS = [
@@ -351,7 +351,7 @@ function getBuildDir() {
 	const workerInstallDir =
 		process.env.MEDIASOUP_INSTALL_DIR ??
 		`${workerOutDir}/${mediasoupBuildtype}`;
-	const buildDir = process.envBUILD_DIR ?? `${workerInstallDir}/build`;
+	const buildDir = process.env.BUILD_DIR ?? `${workerInstallDir}/build`;
 
 	return buildDir;
 }

package/worker/src/Channel/ChannelNotification.cpp

@@ -22,18 +22,17 @@ namespace Channel
 
 	/* Instance methods. */
 
-	ChannelNotification::ChannelNotification(const FBS::Notification::Notification* notification)
+	ChannelNotification::ChannelNotification(
+	  const FBS::Notification::Notification* notification, int64_t receivedAtUs)
+	  : data(notification), receivedAtUs(receivedAtUs)
 	{
 		MS_TRACE();
 
-		this->data  = notification;
-		this->event = notification->event();
-
-		auto eventCStrIt = Event2String.find(this->event);
+		auto eventCStrIt = Event2String.find(this->data->event());
 
 		if (eventCStrIt == Event2String.end())
 		{
-			MS_THROW_ERROR("unknown event '%" PRIu8 "'", static_cast<uint8_t>(this->event));
+			MS_THROW_ERROR("unknown event '%" PRIu8 "'", static_cast<uint8_t>(this->data->event()));
 		}
 
 		this->eventCStr = eventCStrIt->second;

package/worker/src/Channel/ChannelSocket.cpp

@@ -5,6 +5,7 @@
 #include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include "SharedInterface.hpp"
 #include <cstring> // std::memcpy(), std::memmove()
 
 namespace Channel
@@ -134,6 +135,13 @@ namespace Channel
 		this->listener = listener;
 	}
 
+	void ChannelSocket::SetShared(SharedInterface* shared)
+	{
+		MS_TRACE_STD();
+
+		this->shared = shared;
+	}
+
 	void ChannelSocket::Send(const uint8_t* data, uint32_t dataLen)
 	{
 		MS_TRACE_STD();
@@ -204,6 +212,10 @@ namespace Channel
 		// and will need to be freed later.
 		if (free)
 		{
+			// NOTE: Take the arrival time before the message is parsed, so that it
+			// doesn't include the cost of processing it.
+			const int64_t receivedAtUs = this->shared->GetTimeUs();
+
 			const auto* message = FBS::Message::GetMessage(msg);
 
 #if MS_LOG_DEV_LEVEL == 3
@@ -244,7 +256,8 @@ namespace Channel
 
 				try
 				{
-					notification = new ChannelNotification(message->data_as<FBS::Notification::Notification>());
+					notification = new ChannelNotification(
+					  message->data_as<FBS::Notification::Notification>(), receivedAtUs);
 
 					// Notify the listener.
 					this->listener->HandleNotification(notification);
@@ -289,6 +302,10 @@ namespace Channel
 	{
 		MS_TRACE();
 
+		// NOTE: Take the arrival time before the message is parsed, so that it
+		// doesn't include the cost of processing it.
+		const int64_t receivedAtUs = this->shared->GetTimeUs();
+
 		const auto* message = FBS::Message::GetMessage(msg);
 
 #if MS_LOG_DEV_LEVEL == 3
@@ -329,7 +346,8 @@ namespace Channel
 
 			try
 			{
-				notification = new ChannelNotification(message->data_as<FBS::Notification::Notification>());
+				notification =
+				  new ChannelNotification(message->data_as<FBS::Notification::Notification>(), receivedAtUs);
 
 				// Notify the listener.
 				this->listener->HandleNotification(notification);

package/worker/src/DepLibUV.cpp

@@ -8,7 +8,7 @@
 /* Class variables. */
 
 thread_local uv_loop_t* DepLibUV::loop{ nullptr };
-thread_local uint64_t DepLibUV::ntpOffsetMs{ 0 };
+thread_local int64_t DepLibUV::ntpOffsetUs{ 0 };
 
 /* Static methods for UV callbacks. */
 
@@ -60,11 +60,10 @@ void DepLibUV::ClassInit()
 		MS_ABORT("uv_gettimeofday() failed");
 	}
 
-	const auto unixSec = static_cast<uint64_t>(timeval.tv_sec);
-	const auto unixMs  = (unixSec * 1000) + (static_cast<uint64_t>(timeval.tv_usec) / 1000);
-	const auto ntpMs   = unixMs + (static_cast<uint64_t>(Utils::Time::UnixNtpOffsetSec) * 1000);
+	const auto unixUs = (timeval.tv_sec * 1000000) + static_cast<int64_t>(timeval.tv_usec);
+	const auto ntpUs  = unixUs + (static_cast<int64_t>(Utils::Time::UnixNtpOffsetSec) * 1000000);
 
-	DepLibUV::ntpOffsetMs = ntpMs - DepLibUV::GetTimeMs();
+	DepLibUV::ntpOffsetUs = ntpUs - DepLibUV::GetTimeUs();
 }
 
 void DepLibUV::ClassDestroy()