mediasoup 3.27.1 → 3.28.0

package/worker/src/RTC/WebRtcTransport.cpp

@@ -8,7 +8,6 @@
 #include "RTC/PortManager.hpp"
 #include "Settings.hpp"
 #include "Utils.hpp"
-#include <cmath> // std::pow()
 
 namespace RTC
 {
@@ -24,8 +23,10 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		return (std::pow(2, 24) * IceTypePreference) + (std::pow(2, 8) * localPreference) +
-		       (std::pow(2, 0) * (256 - IceComponent));
+		// Recommended formula in RFC 8445 section 5.1.2.1:
+		//   (2^24) * type preference + (2^8) * local preference + (2^0) * (256 - component ID).
+		return (static_cast<uint32_t>(IceTypePreference) << 24) +
+		       (static_cast<uint32_t>(localPreference) << 8) + (256 - IceComponent);
 	}
 
 	/* Instance methods. */
@@ -679,6 +680,15 @@ namespace RTC
 		  this->dtlsTransport->GetState() == RTC::DtlsTransport::DtlsState::CONNECTED);
 	}
 
+	inline size_t WebRtcTransport::GetPacketOverhead() const
+	{
+		MS_TRACE();
+
+		const auto* tuple = this->iceServer->GetSelectedTuple();
+
+		return tuple ? tuple->GetPacketOverhead() : 0;
+	}
+
 	void WebRtcTransport::MayRunDtlsTransport()
 	{
 		MS_TRACE();
@@ -757,7 +767,7 @@ namespace RTC
 	}
 
 	void WebRtcTransport::SendRtpPacket(
-	  RTC::Consumer* /*consumer*/, RTC::RTP::Packet* packet, const RTC::Transport::onSendCallback* cb)
+	  RTC::Consumer* /*consumer*/, RTC::RTP::Packet* packet, onSendCallback cb)
 	{
 		MS_TRACE();
 
@@ -765,8 +775,7 @@ namespace RTC
 		{
 			if (cb)
 			{
-				(*cb)(false);
-				delete cb;
+				cb(false);
 			}
 
 			return;
@@ -779,8 +788,7 @@ namespace RTC
 
 			if (cb)
 			{
-				(*cb)(false);
-				delete cb;
+				cb(false);
 			}
 
 			return;
@@ -793,14 +801,13 @@ namespace RTC
 		{
 			if (cb)
 			{
-				(*cb)(false);
-				delete cb;
+				cb(false);
 			}
 
 			return;
 		}
 
-		this->iceServer->GetSelectedTuple()->Send(data, len, cb);
+		this->iceServer->GetSelectedTuple()->Send(data, len, std::move(cb));
 
 		// Increase send transmission.
 		RTC::Transport::DataSent(len);
@@ -871,11 +878,11 @@ namespace RTC
 	}
 
 	void WebRtcTransport::SendMessage(
-	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb)
+	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb)
 	{
 		MS_TRACE();
 
-		SendSctpMessage(dataConsumer, std::move(message), cb);
+		SendSctpMessage(dataConsumer, std::move(message), std::move(cb));
 	}
 
 	bool WebRtcTransport::SendData(const uint8_t* data, size_t len)

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/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