mediasoup 3.26.0 → 3.27.1

package/worker/fbs/transport.fbs

@@ -123,7 +123,7 @@ table RecvRtpHeaderExtensions {
 
 table Options {
     direct: bool = false;
-    initial_available_outgoing_bitrate: uint32 = null;
+    initial_available_outgoing_bitrate: uint64 = null;
     enable_sctp: bool = false;
     max_send_message_size: uint32;
     max_receive_message_size: uint32;
@@ -164,38 +164,38 @@ table Stats {
     timestamp: uint64;
     sctp_state: FBS.SctpAssociation.SctpState = null;
     bytes_received: uint64;
-    recv_bitrate: uint32;
+    recv_bitrate: uint64;
     bytes_sent: uint64;
-    send_bitrate: uint32;
+    send_bitrate: uint64;
     rtp_bytes_received: uint64;
-    rtp_recv_bitrate: uint32;
+    rtp_recv_bitrate: uint64;
     rtp_bytes_sent: uint64;
-    rtp_send_bitrate: uint32;
+    rtp_send_bitrate: uint64;
     rtx_bytes_received: uint64;
-    rtx_recv_bitrate: uint32;
+    rtx_recv_bitrate: uint64;
     rtx_bytes_sent: uint64;
-    rtx_send_bitrate: uint32;
+    rtx_send_bitrate: uint64;
     probation_bytes_sent: uint64;
-    probation_send_bitrate: uint32;
-    available_outgoing_bitrate: uint32 = null;
-    available_incoming_bitrate: uint32 = null;
-    max_incoming_bitrate: uint32 = null;
-    max_outgoing_bitrate: uint32 = null;
-    min_outgoing_bitrate: uint32 = null;
+    probation_send_bitrate: uint64;
+    available_outgoing_bitrate: uint64 = null;
+    available_incoming_bitrate: uint64 = null;
+    max_incoming_bitrate: uint64 = null;
+    max_outgoing_bitrate: uint64 = null;
+    min_outgoing_bitrate: uint64 = null;
     rtp_packet_loss_received: float64 = null;
     rtp_packet_loss_sent: float64 = null;
 }
 
 table SetMaxIncomingBitrateRequest {
-    max_incoming_bitrate: uint32;
+    max_incoming_bitrate: uint64;
 }
 
 table SetMaxOutgoingBitrateRequest {
-    max_outgoing_bitrate: uint32;
+    max_outgoing_bitrate: uint64;
 }
 
 table SetMinOutgoingBitrateRequest {
-    min_outgoing_bitrate: uint32;
+    min_outgoing_bitrate: uint64;
 }
 
 table EnableTraceEventRequest {
@@ -245,13 +245,13 @@ enum BweType: uint8 {
 
 table BweTraceInfo {
     bwe_type: BweType;
-    desired_bitrate: uint32;
-    effective_desired_bitrate: uint32;
-    min_bitrate: uint32;
-    max_bitrate: uint32;
-    start_bitrate: uint32;
-    max_padding_bitrate: uint32;
-    available_bitrate: uint32;
+    desired_bitrate: uint64;
+    effective_desired_bitrate: uint64;
+    min_bitrate: uint64;
+    max_bitrate: uint64;
+    start_bitrate: uint64;
+    max_padding_bitrate: uint64;
+    available_bitrate: uint64;
 }
 
 table TraceNotification {

package/worker/fuzzer/include/RTC/FuzzerDtlsTransport.hpp

@@ -24,7 +24,10 @@ namespace FuzzerRtcDtlsTransport
 		void OnDtlsTransportSendData(
 		  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) override;
 		void OnDtlsTransportApplicationDataReceived(
-		  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) override;
+		  const RTC::DtlsTransport* dtlsTransport,
+		  const uint8_t* data,
+		  size_t len,
+		  int64_t receivedAtUs) override;
 	};
 
 	void Fuzz(const uint8_t* data, size_t len);

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -92,8 +92,10 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 
 	/* Time class. */
 
-	auto ntp = Utils::Time::TimeMs2Ntp(static_cast<uint64_t>(len));
+	auto ntp = Utils::Time::TimeUs2Ntp(static_cast<int64_t>(len));
 
-	Utils::Time::Ntp2TimeMs(ntp);
-	Utils::Time::TimeMsToAbsSendTime(static_cast<uint64_t>(len));
+	Utils::Time::Ntp2TimeUs(ntp);
+	Utils::Time::TimeUsToAbsSendTime(static_cast<int64_t>(len));
+	Utils::Time::Q32x32ToTimeUs(static_cast<int64_t>(len));
+	Utils::Time::TimeUs2Q32x32(static_cast<int64_t>(len));
 }

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

@@ -9,10 +9,10 @@
 namespace
 {
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local mocks::MockShared shared(/*getTimeMs*/
-	                                      []()
+	thread_local mocks::MockShared shared(/*getTimeUs*/
+	                                      []() -> int64_t
 	                                      {
-		                                      return 1000;
+		                                      return 1000 * 1000;
 	                                      });
 
 	// DtlsTransport instance. It's reset every time DTLS handshake fails or DTLS
@@ -70,7 +70,7 @@ void FuzzerRtcDtlsTransport::Fuzz(const uint8_t* data, size_t len)
 		dtlsTransportSingleton->SetRemoteFingerprint(dtlsRemoteFingerprint);
 	}
 
-	dtlsTransportSingleton->ProcessDtlsData(data, len);
+	dtlsTransportSingleton->ProcessDtlsData(data, len, shared.GetTimeUs());
 
 	// DTLS may have failed or closed after ProcessDtlsData(). If so, unset it.
 	if (
@@ -125,7 +125,10 @@ void FuzzerRtcDtlsTransport::DtlsTransportListener::OnDtlsTransportSendData(
 }
 
 void FuzzerRtcDtlsTransport::DtlsTransportListener::OnDtlsTransportApplicationDataReceived(
-  const RTC::DtlsTransport* /*dtlsTransport*/, const uint8_t* /*data*/, size_t /*len*/)
+  const RTC::DtlsTransport* /*dtlsTransport*/,
+  const uint8_t* /*data*/,
+  size_t /*len*/,
+  int64_t /*receivedAtUs*/)
 {
 	MS_DEBUG_DEV("DtlsTransport singleton received application data");
 }

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

@@ -8,7 +8,7 @@ namespace
 {
 	// NOLINTBEGIN(readability-identifier-naming)
 	RTC::RateCalculator rateCalculator;
-	uint64_t nowMs;
+	int64_t nowMs;
 	// NOLINTEND(readability-identifier-naming)
 
 	int init()
@@ -34,9 +34,9 @@ void FuzzerRtcRateCalculator::Fuzz(const uint8_t* data, size_t len)
 		return;
 	}
 
-	auto size = Utils::Crypto::GetRandomUInt<size_t>(0u, static_cast<uint32_t>(RTC::Consts::MtuSize));
+	auto size = Utils::Crypto::GetRandomUInt<size_t>(0, static_cast<uint32_t>(RTC::Consts::MtuSize));
 
-	nowMs += Utils::Crypto::GetRandomUInt<uint64_t>(0u, 1000u);
+	nowMs += static_cast<int64_t>(Utils::Crypto::GetRandomUInt<uint64_t>(0, 1000));
 
 	rateCalculator.Update(size, nowMs);
 

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

@@ -6,20 +6,20 @@
 void FuzzerRtcTrendCalculator::Fuzz(const uint8_t* data, size_t len)
 {
 	RTC::TrendCalculator trend;
-	auto nowMs = DepLibUV::GetTimeMs();
-	size_t offset{ 0u };
+	int64_t nowMs = DepLibUV::GetTimeMs();
+	size_t offset{ 0 };
 
-	while (len >= 4u)
+	while (len >= 4)
 	{
 		const auto value = Utils::Byte::Get4Bytes(data, offset);
 
 		trend.Update(value, nowMs);
 		trend.GetValue();
-		trend.Update(value, nowMs - 1000u);
+		trend.Update(value, nowMs - 1000);
 		trend.GetValue();
 
-		len -= 4u;
+		len -= 4;
 		offset += 4;
-		nowMs += 500u;
+		nowMs += 500;
 	}
 }

package/worker/fuzzer/src/RTC/RTCP/FuzzerFeedbackRtpTransport.cpp

@@ -10,11 +10,11 @@ void FuzzerRtcRtcpFeedbackRtpTransport::Fuzz(RTC::RTCP::FeedbackRtpTransportPack
 	packet->GetBaseSequenceNumber();
 	packet->GetPacketStatusCount();
 	packet->GetReferenceTime();
-	packet->GetReferenceTimestamp();
+	packet->GetReferenceTimestampUs();
 	packet->GetFeedbackPacketCount();
 	packet->GetLatestSequenceNumber();
-	packet->GetLatestTimestamp();
-	packet->GetPacketResults();
+	packet->GetLatestTimestampUs();
+	packet->GetPacketStatuses();
 	packet->GetPacketFractionLost();
 	packet->Serialize(RTC::RTCP::SerializationBuffer);
 }

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

@@ -91,7 +91,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->HasExtension(3);
 	packet->GetExtensionValue(3, extenLen);
 	packet->ReadAbsSendTime(absSendTime);
-	packet->UpdateAbsSendTime(12345678u);
+	packet->UpdateAbsSendTime(12345678);
 
 	packet->HasExtension(4);
 	packet->GetExtensionValue(4, extenLen);
@@ -150,7 +150,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::Auto, extensions);
 
 	uint8_t value3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
-		                   0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 };
+	                     0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 };
 
 	extensions.emplace_back(
 	  RTC::RtpHeaderExtensionUri::Type::MID, // type

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

@@ -6,8 +6,8 @@
 
 void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 {
-	const uint16_t maxItems{ 2500u };
-	const uint32_t maxRetransmissionDelayMs{ 2000u };
+	const uint16_t maxItems{ 2500 };
+	const int64_t maxRetransmissionDelayMs{ 2000 };
 	const uint32_t clockRate{ 90000 };
 
 	// Trick to initialize our stuff just once (use static).
@@ -25,9 +25,9 @@ void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 
 	// Create base RtpPacket instance.
 	auto* packet = RTC::RTP::Packet::Parse(buffer, 12);
-	size_t offset{ 0u };
+	size_t offset{ 0 };
 
-	while (len >= 4u)
+	while (len >= 4)
 	{
 		const RTC::RTP::SharedPacket sharedPacket;
 
@@ -37,7 +37,7 @@ void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 
 		retransmissionBuffer.Insert(packet, sharedPacket);
 
-		len -= 4u;
+		len -= 4;
 		offset += 4;
 	}
 

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

@@ -6,10 +6,10 @@
 namespace
 {
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local mocks::MockShared shared(/*getTimeMs*/
-	                                      []()
+	thread_local mocks::MockShared shared(/*getTimeUs*/
+	                                      []() -> int64_t
 	                                      {
-		                                      return 1000;
+		                                      return 1000 * 1000;
 	                                      });
 } // namespace
 

package/worker/fuzzer/src/fuzzer.cpp

@@ -3,7 +3,9 @@
 #include "common.hpp"
 #include "DepLibSRTP.hpp"
 #include "DepLibUV.hpp"
+#ifndef MS_USE_BUILTIN_BWE
 #include "DepLibWebRTC.hpp"
+#endif
 #include "DepOpenSSL.hpp"
 #include "FuzzerUtils.hpp"
 #include "RTC/DtlsTransport.hpp"
@@ -144,7 +146,9 @@ namespace
 		DepLibUV::ClassInit();
 		DepOpenSSL::ClassInit();
 		DepLibSRTP::ClassInit();
+#ifndef MS_USE_BUILTIN_BWE
 		DepLibWebRTC::ClassInit();
+#endif
 		Utils::Crypto::ClassInit();
 		RTC::DtlsTransport::ClassInit();
 

package/worker/include/Channel/ChannelNotification.hpp

@@ -12,16 +12,16 @@ namespace Channel
 		using Event = FBS::Notification::Event;
 
 	public:
-		explicit ChannelNotification(const FBS::Notification::Notification* notification);
+		ChannelNotification(const FBS::Notification::Notification* notification, int64_t receivedAtUs);
 		~ChannelNotification() = default;
 
 	public:
 		// Passed by argument.
-		Event event;
+		const FBS::Notification::Notification* data{ nullptr };
+		int64_t receivedAtUs{ 0 };
 		// Others.
 		const char* eventCStr;
 		std::string handlerId;
-		const FBS::Notification::Notification* data{ nullptr };
 	};
 } // namespace Channel
 

package/worker/include/Channel/ChannelRequest.hpp

@@ -68,7 +68,7 @@ namespace Channel
 		Channel::ChannelSocket* channel{ nullptr };
 		const FBS::Request::Request* data{ nullptr };
 		// Others.
-		uint32_t id{ 0u };
+		uint32_t id{ 0 };
 		Method method;
 		const char* methodCStr;
 		std::string handlerId;

package/worker/include/Channel/ChannelSocket.hpp

@@ -6,6 +6,10 @@
 #include "Channel/ChannelRequest.hpp"
 #include "handles/UnixStreamSocketHandle.hpp"
 
+// Avoid cyclic #include problem by declaring the class instead of including the
+// corresponding header file.
+class SharedInterface;
+
 namespace Channel
 {
 	class ConsumerSocket : public UnixStreamSocketHandle
@@ -96,6 +100,12 @@ namespace Channel
 	public:
 		void Close();
 		void SetListener(Listener* listener);
+		/**
+		 * @remarks
+		 * - Must be called before the libuv loop runs, since notifications take
+		 *   their arrival time from it.
+		 */
+		void SetShared(SharedInterface* shared);
 		void Send(const uint8_t* data, uint32_t dataLen);
 		void SendLog(const char* data, uint32_t dataLen);
 		bool CallbackRead();
@@ -111,6 +121,7 @@ namespace Channel
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Others.
 		bool closed{ false };
 		ConsumerSocket* consumerSocket{ nullptr };

package/worker/include/DepLibUV.hpp

@@ -20,57 +20,40 @@ public:
 		return DepLibUV::loop;
 	}
 
-	static uint64_t GetTimeMs()
-	{
-		return static_cast<uint64_t>(uv_hrtime() / 1000000u);
-	}
-
 	/**
-	 * Offset between our own monotonic clock and the NTP epoch (ms).
-	 *
-	 * @remarks
-	 * - It is taken just once, in ClassInit(), so that the NTP timestamps we generate
-	 *   never step when the system clock is adjusted. They just drift away from the real
-	 *   wall clock as much as our monotonic clock does.
+	 * Current value of the monotonic clock (ms).
 	 */
-	static uint64_t GetNtpOffsetMs()
+	static int64_t GetTimeMs()
 	{
-		return DepLibUV::ntpOffsetMs;
-	}
-
-	static uint64_t GetTimeUs()
-	{
-		return static_cast<uint64_t>(uv_hrtime() / 1000u);
-	}
-
-	static uint64_t GetTimeNs()
-	{
-		return uv_hrtime();
+		return static_cast<int64_t>(uv_hrtime() / 1000000);
 	}
 
 	/**
-	 * Used within libwebrtc dependency which uses int64_t values for time
-	 * representation.
+	 * Current value of the monotonic clock (us).
 	 */
-	static int64_t GetTimeMsInt64()
+	static int64_t GetTimeUs()
 	{
-		return static_cast<int64_t>(DepLibUV::GetTimeMs());
+		return static_cast<int64_t>(uv_hrtime() / 1000);
 	}
 
 	/**
-	 * Used within libwebrtc dependency which uses int64_t values for time
-	 * representation.
+	 * Offset between our own monotonic clock and the NTP epoch (us).
+	 *
+	 * @remarks
+	 * - It is taken just once, in ClassInit(), so that the NTP timestamps we generate
+	 *   never step when the system clock is adjusted. They just drift away from the real
+	 *   wall clock as much as our monotonic clock does.
 	 */
-	static int64_t GetTimeUsInt64()
+	static int64_t GetNtpOffsetUs()
 	{
-		return static_cast<int64_t>(DepLibUV::GetTimeUs());
+		return DepLibUV::ntpOffsetUs;
 	}
 
 private:
 	static thread_local uv_loop_t* loop;
-	// Distance from our own monotonic clock to the NTP epoch (ms), taken at
+	// Distance from our own monotonic clock to the NTP epoch (us), taken at
 	// ClassInit().
-	static thread_local uint64_t ntpOffsetMs;
+	static thread_local int64_t ntpOffsetUs;
 };
 
 #endif

package/worker/include/RTC/ActiveSpeakerObserver.hpp

@@ -25,8 +25,8 @@ namespace RTC
 		public:
 			void EvalActivityScores();
 			double GetActivityScore(uint8_t interval) const;
-			void LevelChanged(uint32_t level, uint64_t now);
-			void LevelTimedOut(uint64_t now);
+			void LevelChanged(uint32_t level, int64_t nowMs);
+			void LevelTimedOut(int64_t nowMs);
 
 		private:
 			bool ComputeImmediates();
@@ -42,17 +42,17 @@ namespace RTC
 			double immediateActivityScore{ 0 };
 			double mediumActivityScore{ 0 };
 			double longActivityScore{ 0 };
-			uint64_t lastLevelChangeTime{ 0 };
+			int64_t lastLevelChangeAtMs{ 0 };
 
 		private:
-			uint8_t minLevel{ 0u };
-			uint8_t nextMinLevel{ 0u };
-			uint32_t nextMinLevelWindowLen{ 0u };
+			uint8_t minLevel{ 0 };
+			uint8_t nextMinLevel{ 0 };
+			uint32_t nextMinLevelWindowLen{ 0 };
 			std::vector<uint8_t> immediates;
 			std::vector<uint8_t> mediums;
 			std::vector<uint8_t> longs;
 			std::vector<uint8_t> levels;
-			size_t nextLevelIndex{ 0u };
+			size_t nextLevelIndex{ 0 };
 		};
 
 		class ProducerSpeaker
@@ -67,7 +67,7 @@ namespace RTC
 		};
 
 	private:
-		static const uint8_t RelativeSpeachActivitiesLen{ 3u };
+		static const uint8_t RelativeSpeachActivitiesLen{ 3 };
 
 	public:
 		ActiveSpeakerObserver(
@@ -89,7 +89,7 @@ namespace RTC
 		void Resumed() override;
 		void Update();
 		bool CalculateActiveSpeaker();
-		void TimeoutIdleLevels(uint64_t now);
+		void TimeoutIdleLevels(int64_t nowMs);
 
 		/* Pure virtual methods inherited from TimerHandleInterface. */
 	protected:
@@ -99,10 +99,10 @@ namespace RTC
 		double relativeSpeachActivities[RelativeSpeachActivitiesLen]{};
 		std::string dominantId;
 		TimerHandleInterface* periodicTimer{ nullptr };
-		uint16_t interval{ 300u };
+		int64_t intervalMs{ 300 };
 		// Map of ProducerSpeakers indexed by Producer id.
 		ankerl::unordered_dense::map<std::string, ProducerSpeaker*> mapProducerSpeakers;
-		uint64_t lastLevelIdleTime{ 0u };
+		int64_t lastLevelIdleAtMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/AudioLevelObserver.hpp

@@ -13,8 +13,8 @@ namespace RTC
 	private:
 		struct DBovs
 		{
-			uint16_t totalSum{ 0u }; // Sum of dBvos (positive integer).
-			size_t count{ 0u };      // Number of dBvos entries in totalSum.
+			uint16_t totalSum{ 0 }; // Sum of dBvos (positive integer).
+			size_t count{ 0 };      // Number of dBvos entries in totalSum.
 		};
 
 	public:
@@ -44,9 +44,9 @@ namespace RTC
 
 	private:
 		// Passed by argument.
-		uint16_t maxEntries{ 1u };
+		uint16_t maxEntries{ 1 };
 		int8_t threshold{ -80 };
-		uint16_t interval{ 1000u };
+		int64_t intervalMs{ 1000 };
 		// Allocated by this.
 		TimerHandleInterface* periodicTimer{ nullptr };
 		// Others.

package/worker/include/RTC/BWE/AcknowledgedBitrateEstimatorInterface.hpp

@@ -0,0 +1,55 @@
+#ifndef MS_RTC_BWE_ACKNOWLEDGED_BITRATE_ESTIMATOR_INTERFACE_HPP
+#define MS_RTC_BWE_ACKNOWLEDGED_BITRATE_ESTIMATOR_INTERFACE_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Measures the bitrate the receiver is acknowledging, which is what the rate
+		 * control compares its target against.
+		 */
+		class AcknowledgedBitrateEstimatorInterface
+		{
+		public:
+			AcknowledgedBitrateEstimatorInterface() = default;
+
+			AcknowledgedBitrateEstimatorInterface& operator=(
+			  const AcknowledgedBitrateEstimatorInterface&) = delete;
+
+			AcknowledgedBitrateEstimatorInterface(const AcknowledgedBitrateEstimatorInterface&) = delete;
+
+			virtual ~AcknowledgedBitrateEstimatorInterface() = default;
+
+		public:
+			/**
+			 * Feed the packets a feedback reported as received.
+			 *
+			 * @param packetResults - The reported packets, ordered by arrival time.
+			 */
+			virtual void IncomingPacketFeedbackVector(
+			  const std::vector<Types::PacketResult>& packetResults) = 0;
+
+			/**
+			 * Acknowledged bitrate (bps), or no value if it cannot be measured yet.
+			 */
+			virtual std::optional<int64_t> GetBitrate() const = 0;
+
+			/**
+			 * @param inAlr - Whether the sender is in an application limited region.
+			 */
+			virtual void SetAlr(bool inAlr) = 0;
+
+			/**
+			 * @param alrEndedTimeUs - Time at which the sender stopped being in an
+			 *   application limited region.
+			 */
+			virtual void SetAlrEndedTimeUs(int64_t alrEndedTimeUs) = 0;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif