mediasoup 3.27.0 → 3.28.0

package/worker/src/Utils/BitStream.cpp

@@ -11,6 +11,15 @@ namespace Utils
 	{
 		MS_TRACE();
 
+		// NOTE: Whatever comes from the network is the value of an RTP header
+		// extension, whose length field is a single byte, so it always fits. This
+		// only catches a caller handing over a longer buffer.
+		MS_ASSERT(
+		  len <= sizeof(this->data),
+		  "given length exceeds the buffer [len:%zu, buffer:%zu]",
+		  len,
+		  sizeof(this->data));
+
 		std::memcpy(this->data, data, len);
 	}
 
@@ -49,6 +58,15 @@ namespace Utils
 	{
 		MS_TRACE();
 
+		// There is nothing left to read, so stay where the data ended rather than
+		// read past it. Callers are expected to check GetLeftBits() themselves, and
+		// a zero cannot be told apart from a real one, so this is the last resort
+		// and not the way to know that the data is over.
+		if (GetLeftBits() == 0)
+		{
+			return 0;
+		}
+
 		auto bit = ((*(data + (this->offset >> 0x3))) >> (0x7 - (this->offset & 0x7))) & 0x1;
 
 		this->offset++;
@@ -178,6 +196,12 @@ namespace Utils
 		// Retrieve the current byte position.
 		const size_t byteOffset = offset >> 0x3;
 
+		MS_ASSERT(
+		  byteOffset < sizeof(this->data),
+		  "given offset is past the buffer [offset:%" PRIu32 ", buffer:%zu]",
+		  offset,
+		  sizeof(this->data));
+
 		// Calculate the bitmask for the target bit within the current byte.
 		const auto bitmask = (1u << (0x7 - (offset & 0x7)));
 

package/worker/src/handles/BackoffTimerHandle.cpp

@@ -128,7 +128,7 @@ int64_t BackoffTimerHandle::ComputeNextTimeoutMs() const
 			return std::min<int64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
 		}
 
-			NO_DEFAULT_GCC();
+			NO_DEFAULT();
 	}
 }
 

package/worker/src/handles/TcpConnectionHandle.cpp

@@ -41,14 +41,13 @@ inline static void onWrite(uv_write_t* req, int status)
 	auto* writeData  = static_cast<TcpConnectionHandle::UvWriteData*>(req->data);
 	auto* handle     = req->handle;
 	auto* connection = static_cast<TcpConnectionHandle*>(handle->data);
-	const auto* cb   = writeData->cb;
 
 	if (connection)
 	{
-		connection->OnUvWrite(status, cb);
+		connection->OnUvWrite(status, writeData->cb);
 	}
 
-	// Delete the UvWriteData struct and the cb.
+	// Delete the UvWriteData struct (it will delete the store too).
 	delete writeData;
 }
 
@@ -182,11 +181,7 @@ bool TcpConnectionHandle::Start() noexcept
 }
 
 void TcpConnectionHandle::Write(
-  const uint8_t* data1,
-  size_t len1,
-  const uint8_t* data2,
-  size_t len2,
-  TcpConnectionHandle::onSendCallback* cb)
+  const uint8_t* data1, size_t len1, const uint8_t* data2, size_t len2, onSendCallback cb)
 {
 	MS_TRACE();
 
@@ -194,8 +189,7 @@ void TcpConnectionHandle::Write(
 	{
 		if (cb)
 		{
-			(*cb)(false);
-			delete cb;
+			cb(false);
 		}
 
 		return;
@@ -205,8 +199,7 @@ void TcpConnectionHandle::Write(
 	{
 		if (cb)
 		{
-			(*cb)(false);
-			delete cb;
+			cb(false);
 		}
 
 		return;
@@ -232,8 +225,7 @@ void TcpConnectionHandle::Write(
 
 		if (cb)
 		{
-			(*cb)(true);
-			delete cb;
+			cb(true);
 		}
 
 		return;
@@ -274,7 +266,7 @@ void TcpConnectionHandle::Write(
 		  len2 - (static_cast<size_t>(written) - len1));
 	}
 
-	writeData->cb = cb;
+	writeData->cb = std::move(cb);
 
 	const uv_buf_t buffer = uv_buf_init(reinterpret_cast<char*>(writeData->store), pendingLen);
 
@@ -289,12 +281,12 @@ void TcpConnectionHandle::Write(
 	{
 		MS_WARN_DEV("uv_write() failed: %s", uv_strerror(err));
 
-		if (cb)
+		if (writeData->cb)
 		{
-			(*cb)(false);
+			writeData->cb(false);
 		}
 
-		// Delete the UvWriteData struct (it will delete the store and cb too).
+		// Delete the UvWriteData struct (it will delete the store too).
 		delete writeData;
 	}
 	else
@@ -483,17 +475,15 @@ inline void TcpConnectionHandle::OnUvRead(ssize_t nread, const uv_buf_t* /*buf*/
 	}
 }
 
-inline void TcpConnectionHandle::OnUvWrite(int status, TcpConnectionHandle::onSendCallback* cb)
+inline void TcpConnectionHandle::OnUvWrite(int status, const onSendCallback& cb)
 {
 	MS_TRACE();
 
-	// NOTE: Do not delete cb here since it will be delete in onWrite() above.
-
 	if (status == 0)
 	{
 		if (cb)
 		{
-			(*cb)(true);
+			cb(true);
 		}
 	}
 	else
@@ -507,7 +497,7 @@ inline void TcpConnectionHandle::OnUvWrite(int status, TcpConnectionHandle::onSe
 
 		if (cb)
 		{
-			(*cb)(false);
+			cb(false);
 		}
 
 		InternalClose();

package/worker/src/handles/UdpSocketHandle.cpp

@@ -50,14 +50,13 @@ inline static void onSend(uv_udp_send_t* req, int status)
 	auto* sendData = static_cast<UdpSocketHandle::UvSendData*>(req->data);
 	auto* handle   = req->handle;
 	auto* socket   = static_cast<UdpSocketHandle*>(handle->data);
-	const auto* cb = sendData->cb;
 
 	if (socket)
 	{
-		socket->OnUvSend(status, cb);
+		socket->OnUvSend(status, sendData->cb);
 	}
 
-	// Delete the UvSendData struct (it will delete the store and cb too).
+	// Delete the UvSendData struct (it will delete the store too).
 	delete sendData;
 }
 
@@ -126,7 +125,7 @@ void UdpSocketHandle::Dump(int indentation) const
 }
 
 void UdpSocketHandle::Send(
-  const uint8_t* data, size_t len, const struct sockaddr* addr, UdpSocketHandle::onSendCallback* cb)
+  const uint8_t* data, size_t len, const struct sockaddr* addr, onSendCallback cb)
 {
 	MS_TRACE();
 
@@ -134,8 +133,7 @@ void UdpSocketHandle::Send(
 	{
 		if (cb)
 		{
-			(*cb)(false);
-			delete cb;
+			cb(false);
 		}
 
 		return;
@@ -145,8 +143,7 @@ void UdpSocketHandle::Send(
 	{
 		if (cb)
 		{
-			(*cb)(false);
-			delete cb;
+			cb(false);
 		}
 
 		return;
@@ -166,8 +163,7 @@ void UdpSocketHandle::Send(
 
 		if (cb)
 		{
-			(*cb)(true);
-			delete cb;
+			cb(true);
 		}
 
 		return;
@@ -181,8 +177,7 @@ void UdpSocketHandle::Send(
 
 		if (cb)
 		{
-			(*cb)(false);
-			delete cb;
+			cb(false);
 		}
 
 		return;
@@ -197,7 +192,7 @@ void UdpSocketHandle::Send(
 
 	sendData->req.data = static_cast<void*>(sendData);
 	std::memcpy(sendData->store, data, len);
-	sendData->cb = cb;
+	sendData->cb = std::move(cb);
 
 	buffer = uv_buf_init(reinterpret_cast<char*>(sendData->store), len);
 
@@ -215,12 +210,12 @@ void UdpSocketHandle::Send(
 		// (IPv6 destination on a IPv4 binded socket), so be ready.
 		MS_WARN_DEV("uv_udp_send() failed: %s", uv_strerror(err));
 
-		if (cb)
+		if (sendData->cb)
 		{
-			(*cb)(false);
+			sendData->cb(false);
 		}
 
-		// Delete the UvSendData struct (it will delete the store and cb too).
+		// Delete the UvSendData struct (it will delete the store too).
 		delete sendData;
 	}
 	else
@@ -402,17 +397,15 @@ inline void UdpSocketHandle::OnUvRecv(
 	}
 }
 
-inline void UdpSocketHandle::OnUvSend(int status, UdpSocketHandle::onSendCallback* cb)
+inline void UdpSocketHandle::OnUvSend(int status, const onSendCallback& cb)
 {
 	MS_TRACE();
 
-	// NOTE: Do not delete cb here since it will be delete in onSend() above.
-
 	if (status == 0)
 	{
 		if (cb)
 		{
-			(*cb)(true);
+			cb(true);
 		}
 	}
 	else
@@ -423,7 +416,7 @@ inline void UdpSocketHandle::OnUvSend(int status, UdpSocketHandle::onSendCallbac
 
 		if (cb)
 		{
-			(*cb)(false);
+			cb(false);
 		}
 	}
 }

package/worker/tasks.py

@@ -10,6 +10,7 @@ Usage:
 
 import glob
 import inspect
+import json
 import os
 import re
 import shutil
@@ -172,21 +173,33 @@ def meson_ninja(ctx):
 
 def default_meson_options():
     """
-    Return every option in meson_options.txt set to its default value
+    Return every option in meson_options.txt mapped to its default value
     """
 
-    options = []
+    options = {}
 
     with open(f"{WORKER_DIR}/meson_options.txt", encoding="utf-8") as options_file:
         for line in options_file:
             match = re.match(r"\s*option\('([^']+)'.*value:\s*([^,)]+)", line)
 
             if match:
-                options.append(
-                    f"-D{match.group(1)}={match.group(2).strip().strip(chr(39))}"
-                )
+                options[match.group(1)] = match.group(2).strip().strip(chr(39))
 
-    return " ".join(options)
+    return options
+
+
+def configured_meson_options(build_dir):
+    """
+    Return the name of every option the given build directory is configured with
+    """
+
+    try:
+        with open(
+            f"{build_dir}/meson-info/intro-buildoptions.json", encoding="utf-8"
+        ) as options_file:
+            return {option["name"] for option in json.load(options_file)}
+    except (OSError, ValueError):
+        return set()
 
 
 @task(pre=[meson_ninja])
@@ -195,23 +208,36 @@ def setup(ctx, meson_args=MESON_ARGS, build_dir=BUILD_DIR):
     Run meson setup
     """
 
+    # NOTE: Meson keeps every option of an already configured build directory
+    # that is not given again, so all of them are passed with their default
+    # value before meson_args, which comes later and hence wins. Without this,
+    # removing an option from MESON_ARGS would silently keep the value it was
+    # given the previous time.
+    default_options = default_meson_options()
+    default_options_args = " ".join(
+        f"-D{name}={value}" for name, value in default_options.items()
+    )
+
     # NOTE: Given an already configured build directory, "meson setup" just
     # prints "Directory already configured" and exits successfully, silently
     # ignoring the given options. So it must be told to reconfigure it or
     # changing MESON_ARGS would have no effect until the directory is removed.
-    reconfigure = "--reconfigure" if os.path.isdir(f"{build_dir}/meson-info") else ""
-
-    # NOTE: Meson also keeps every option of an already configured build
-    # directory that is not given again, so all of them are passed with their
-    # default value before meson_args, which comes later and hence wins. Without
-    # this, removing an option from MESON_ARGS would silently keep the value it
-    # was given the previous time.
-    default_options = default_meson_options()
+    reconfigure = ""
+
+    if os.path.isdir(f"{build_dir}/meson-info"):
+        # NOTE: Meson validates the given options against the ones it has cached
+        # before reading meson_options.txt again, so a build directory configured
+        # back when an option didn't exist yet cannot be reconfigured with it.
+        # There is nothing to preserve in that case, so it's built from scratch.
+        if default_options.keys() <= configured_meson_options(build_dir):
+            reconfigure = "--reconfigure"
+        else:
+            shutil.rmtree(build_dir, ignore_errors=True)
 
     if MEDIASOUP_BUILDTYPE == "Release":
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype release -Db_ndebug=true {default_options} {meson_args} "{build_dir}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype release -Db_ndebug=true {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -219,7 +245,7 @@ def setup(ctx, meson_args=MESON_ARGS, build_dir=BUILD_DIR):
     elif MEDIASOUP_BUILDTYPE == "Debug":
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype debug {default_options} {meson_args} "{build_dir}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype debug {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -227,7 +253,7 @@ def setup(ctx, meson_args=MESON_ARGS, build_dir=BUILD_DIR):
     else:
         with cd_worker():
             ctx.run(
-                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype {MEDIASOUP_BUILDTYPE} -Db_ndebug=if-release {default_options} {meson_args} "{build_dir}"',
+                f'"{MESON}" setup {reconfigure} --prefix "{MEDIASOUP_INSTALL_DIR}" --bindir "" --libdir "" --buildtype {MEDIASOUP_BUILDTYPE} -Db_ndebug=if-release {default_options_args} {meson_args} "{build_dir}"',
                 echo=True,
                 pty=PTY_SUPPORTED,
                 shell=SHELL,
@@ -310,7 +336,6 @@ def clean_all(ctx):
             )
 
         shutil.rmtree(MEDIASOUP_OUT_DIR, ignore_errors=True)
-        shutil.rmtree("include/FBS", ignore_errors=True)
 
 
 @task(pre=[meson_ninja])

package/worker/test/include/RTC/BWE/helpers/LinkSimulator.hpp

@@ -3,9 +3,26 @@
 
 #include "common.hpp"
 #include "RTC/BWE/BweTypes.hpp"
+#include <vector>
 
 namespace bweHelpers
 {
+	// Largest packet a frame is split into (bytes).
+	constexpr size_t Mtu{ 1200 };
+
+	/**
+	 * A packet as it left a stream and as it arrived, for whoever needs to know
+	 * which stream it belongs to rather than just its feedback.
+	 */
+	struct Packet
+	{
+		uint32_t ssrc;
+		uint32_t rtpTimestamp;
+		int64_t sendTimeUs;
+		int64_t arrivalTimeUs;
+		size_t size;
+	};
+
 	/**
 	 * A stream that produces frames at a given frame rate and bitrate, split into
 	 * packets of at most one MTU.
@@ -13,19 +30,27 @@ namespace bweHelpers
 	class RtpStream
 	{
 	public:
-		/**
-		 * Offset added to the send times so that they don't share the origin with
-		 * the arrival ones, which would hide a mistake mixing both references.
-		 */
-		static constexpr int64_t SendSideOffsetUs{ 1000 * 1000 };
-
-	public:
-		RtpStream(int fps, int64_t bitrateBps);
+		RtpStream(
+		  int fps,
+		  int64_t bitrateBps,
+		  uint32_t ssrc               = 0,
+		  uint32_t frequency          = 90000,
+		  uint32_t rtpTimestampOffset = 0);
 
 		RtpStream& operator=(const RtpStream&) = delete;
 
 		RtpStream(const RtpStream&) = delete;
 
+		uint32_t GetSsrc() const
+		{
+			return this->ssrc;
+		}
+
+		void SetRtpTimestampOffset(uint32_t rtpTimestampOffset)
+		{
+			this->rtpTimestampOffset = rtpTimestampOffset;
+		}
+
 		/**
 		 * Generate a frame and split it into packets, appending them to
 		 * `packetResults`. Nothing is generated if it's called before the next frame
@@ -38,6 +63,13 @@ namespace bweHelpers
 		  int64_t& nextSequenceNumber,
 		  std::vector<RTC::BWE::Types::PacketResult>& packetResults);
 
+		int64_t GetBitrateBps() const
+		{
+			return this->bitrateBps;
+		}
+
+		void SetBitrateBps(int64_t bitrateBps);
+
 		/**
 		 * Send time at which the next frame can be generated.
 		 */
@@ -46,12 +78,12 @@ namespace bweHelpers
 			return this->nextRtpTimeUs;
 		}
 
-		int64_t GetBitrateBps() const
-		{
-			return this->bitrateBps;
-		}
-
-		void SetBitrateBps(int64_t bitrateBps);
+		/**
+		 * Generate a frame as the other overload does, for whoever needs the packets
+		 * themselves rather than the feedback they would produce. The arrival time
+		 * is left for the link to fill in.
+		 */
+		int64_t GenerateFrame(int64_t timeNowUs, std::vector<Packet>& packets);
 
 		/**
 		 * Orders streams by which one is due to produce a frame first.
@@ -60,6 +92,9 @@ namespace bweHelpers
 
 	private:
 		const int fps;
+		const uint32_t ssrc;
+		const uint32_t frequency;
+		uint32_t rtpTimestampOffset;
 		int64_t bitrateBps;
 		int64_t nextRtpTimeUs{ 0 };
 	};
@@ -88,6 +123,12 @@ namespace bweHelpers
 
 		void SetCapacityBps(int64_t capacityBps);
 
+		/**
+		 * Set the RTP timestamp offset of the stream with the given SSRC, which
+		 * does nothing if no stream has it.
+		 */
+		void SetRtpTimestampOffset(uint32_t ssrc, uint32_t rtpTimestampOffset);
+
 		/**
 		 * Divide `bitrateBps` among the streams, keeping the ratios they had.
 		 */
@@ -105,6 +146,19 @@ namespace bweHelpers
 		  int64_t& nextSequenceNumber,
 		  std::vector<RTC::BWE::Types::PacketResult>& packetResults);
 
+		/**
+		 * Generate a frame as the other overload does, for whoever needs the packets
+		 * themselves rather than the feedback they would produce.
+		 */
+		int64_t GenerateFrame(int64_t timeNowUs, std::vector<Packet>& packets);
+
+	private:
+		/**
+		 * Time the link needs to put a packet of the given size on the wire, which
+		 * is also how long the next one waits behind it.
+		 */
+		int64_t GetRequiredNetworkTimeUs(size_t size) const;
+
 	private:
 		// Capacity of the simulated link (bps).
 		int64_t capacityBps;

package/worker/test/include/RTC/BWE/helpers/RemoteBitrateEstimatorAbsSendTimeTestHelper.hpp

@@ -0,0 +1,125 @@
+#ifndef MS_TEST_RTC_BWE_REMOTE_BITRATE_ESTIMATOR_ABS_SEND_TIME_TEST_HELPER_HPP
+#define MS_TEST_RTC_BWE_REMOTE_BITRATE_ESTIMATOR_ABS_SEND_TIME_TEST_HELPER_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/RemoteBitrateEstimatorAbsSendTime.hpp"
+#include "test/include/RTC/BWE/helpers/LinkSimulator.hpp"
+#include <vector>
+
+namespace bweHelpers
+{
+	/**
+	 * Drives a `RTC::BWE::RemoteBitrateEstimatorAbsSendTime` through the scenarios
+	 * its tests are written around: it owns the estimator, feeds it the packets a
+	 * simulated link delivers, and keeps the latest estimation it reported.
+	 */
+	class RemoteBitrateEstimatorAbsSendTimeTestHelper
+	  : public RTC::BWE::RemoteBitrateEstimatorAbsSendTime::Listener
+	{
+	public:
+		/**
+		 * SSRC of the stream `AddDefaultStream()` adds.
+		 */
+		static constexpr uint32_t DefaultSsrc{ 1 };
+
+	public:
+		RemoteBitrateEstimatorAbsSendTimeTestHelper();
+
+		~RemoteBitrateEstimatorAbsSendTimeTestHelper() override = default;
+
+		RemoteBitrateEstimatorAbsSendTimeTestHelper(const RemoteBitrateEstimatorAbsSendTimeTestHelper&) =
+		  delete;
+		RemoteBitrateEstimatorAbsSendTimeTestHelper& operator=(
+		  const RemoteBitrateEstimatorAbsSendTimeTestHelper&) = delete;
+
+		/**
+		 * Turn an instant into the 24 bits of the 'abs-send-time' extension,
+		 * rounded upwards.
+		 *
+		 * @param denom - What to divide the instant by to get whole seconds, so
+		 *   1000 for milliseconds.
+		 */
+		static uint32_t AbsSendTime(int64_t t, int64_t denom);
+
+		/**
+		 * Add two of those values together, keeping the result within 24 bits.
+		 */
+		static uint32_t AddAbsSendTime(uint32_t t1, uint32_t t2);
+
+		void AddDefaultStream();
+
+		/**
+		 * Build a packet with the given 'abs-send-time' and feed it to the
+		 * estimator as having arrived at `arrivalTimeMs`.
+		 */
+		void IncomingPacket(
+		  uint32_t ssrc,
+		  size_t payloadSize,
+		  int64_t arrivalTimeMs,
+		  uint32_t rtpTimestamp,
+		  uint32_t absSendTime);
+
+		/**
+		 * Generate a frame at the given bitrate, push it through the link and give
+		 * every packet to the estimator.
+		 *
+		 * @returns Whether the estimation came out below what was being sent, which
+		 *   is what an overuse looks like from here.
+		 */
+		bool GenerateAndProcessFrame(uint32_t ssrc, int64_t bitrateBps);
+
+		/**
+		 * Feed frames until the estimation settles above `targetBitrate` or until
+		 * `maxNumberOfFrames` have gone by, which is how a scenario gets the
+		 * estimator into a steady state before doing anything to it.
+		 *
+		 * @returns The bitrate reached.
+		 */
+		int64_t SteadyStateRun(
+		  uint32_t ssrc,
+		  int maxNumberOfFrames,
+		  int64_t startBitrate,
+		  int64_t minBitrate,
+		  int64_t maxBitrate,
+		  int64_t targetBitrate);
+
+		void InitialBehaviorTestHelper(int64_t expectedConvergeBitrate);
+
+		void RateIncreaseReorderingTestHelper(int64_t expectedBitrate);
+
+		void RateIncreaseRtpTimestampsTestHelper(int expectedIterations);
+
+		void CapacityDropTestHelper(
+		  int numberOfStreams,
+		  bool wrapTimestamp,
+		  int64_t expectedBitrateDropDeltaMs,
+		  int64_t receiverClockOffsetChangeMs);
+
+		void TestTimestampGroupingTestHelper();
+
+		void TestWrappingHelper(int silenceTimeS);
+
+		/* Pure virtual methods inherited from RemoteBitrateEstimatorAbsSendTime::Listener. */
+	public:
+		void OnRemoteBitrateEstimatorAbsSendTimeBitrateChanged(
+		  RTC::BWE::RemoteBitrateEstimatorAbsSendTime* remoteBitrateEstimator,
+		  const std::vector<uint32_t>& ssrcs,
+		  int64_t bitrate) override;
+
+	private:
+		// Current instant, which the scenarios move forward themselves since no
+		// class of the module reads a clock.
+		int64_t nowUs;
+		// Added to the arrival time of every packet, so that a scenario can move
+		// the receiver's clock mid-run.
+		int64_t arrivalTimeOffsetMs{ 0 };
+		// Whether the estimation was reported since the latest reset.
+		bool updated{ false };
+		// Latest estimation reported (bps).
+		int64_t latestBitrate{ 0 };
+		LinkSimulator linkSimulator;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator;
+	};
+} // namespace bweHelpers
+
+#endif