mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/KeyFrameRequestManager.cpp

@@ -4,17 +4,19 @@
 #include "RTC/KeyFrameRequestManager.hpp"
 #include "Logger.hpp"
 
-static constexpr uint32_t KeyFrameRetransmissionWaitTime{ 1000u };
+static constexpr int64_t KeyFrameRetransmissionWaitMs{ 1000 };
 
 /* PendingKeyFrameInfo methods. */
 
 RTC::PendingKeyFrameInfo::PendingKeyFrameInfo(
   PendingKeyFrameInfo::Listener* listener, SharedInterface* shared, uint32_t ssrc)
-  : listener(listener), ssrc(ssrc), timer(shared->CreateTimer(this))
+  : listener(listener),
+    ssrc(ssrc),
+    timer(shared->CreateTimer(this, "key-frame-request-manager-pending-key-frame-info"))
 {
 	MS_TRACE();
 
-	this->timer->Start(KeyFrameRetransmissionWaitTime);
+	this->timer->Start(KeyFrameRetransmissionWaitMs);
 }
 
 RTC::PendingKeyFrameInfo::~PendingKeyFrameInfo()
@@ -38,12 +40,14 @@ void RTC::PendingKeyFrameInfo::OnTimer(TimerHandleInterface* timer)
 /* KeyFrameRequestDelayer methods. */
 
 RTC::KeyFrameRequestDelayer::KeyFrameRequestDelayer(
-  KeyFrameRequestDelayer::Listener* listener, SharedInterface* shared, uint32_t ssrc, uint32_t delay)
-  : listener(listener), ssrc(ssrc), timer(shared->CreateTimer(this))
+  KeyFrameRequestDelayer::Listener* listener, SharedInterface* shared, uint32_t ssrc, int64_t delayMs)
+  : listener(listener),
+    ssrc(ssrc),
+    timer(shared->CreateTimer(this, "key-frame-request-manager-key-frame-request-delayer"))
 {
 	MS_TRACE();
 
-	this->timer->Start(delay);
+	this->timer->Start(delayMs);
 }
 
 RTC::KeyFrameRequestDelayer::~KeyFrameRequestDelayer()
@@ -67,8 +71,8 @@ void RTC::KeyFrameRequestDelayer::OnTimer(TimerHandleInterface* timer)
 /* KeyFrameRequestManager methods. */
 
 RTC::KeyFrameRequestManager::KeyFrameRequestManager(
-  KeyFrameRequestManager::Listener* listener, SharedInterface* shared, uint32_t keyFrameRequestDelay)
-  : listener(listener), shared(shared), keyFrameRequestDelay(keyFrameRequestDelay)
+  KeyFrameRequestManager::Listener* listener, SharedInterface* shared, int64_t keyFrameRequestDelayMs)
+  : listener(listener), shared(shared), keyFrameRequestDelayMs(keyFrameRequestDelayMs)
 {
 	MS_TRACE();
 }
@@ -98,7 +102,7 @@ void RTC::KeyFrameRequestManager::KeyFrameNeeded(uint32_t ssrc)
 {
 	MS_TRACE();
 
-	if (this->keyFrameRequestDelay > 0u)
+	if (this->keyFrameRequestDelayMs > 0)
 	{
 		auto it = this->mapSsrcKeyFrameRequestDelayer.find(ssrc);
 
@@ -119,7 +123,7 @@ void RTC::KeyFrameRequestManager::KeyFrameNeeded(uint32_t ssrc)
 			MS_DEBUG_DEV("creating a delayer for the given ssrc");
 
 			this->mapSsrcKeyFrameRequestDelayer[ssrc] =
-			  new KeyFrameRequestDelayer(this, this->shared, ssrc, this->keyFrameRequestDelay);
+			  new KeyFrameRequestDelayer(this, this->shared, ssrc, this->keyFrameRequestDelayMs);
 		}
 	}
 
@@ -145,7 +149,7 @@ void RTC::KeyFrameRequestManager::ForceKeyFrameNeeded(uint32_t ssrc)
 {
 	MS_TRACE();
 
-	if (this->keyFrameRequestDelay > 0u)
+	if (this->keyFrameRequestDelayMs > 0)
 	{
 		// Create/replace a delayer for this ssrc.
 		auto it = this->mapSsrcKeyFrameRequestDelayer.find(ssrc);
@@ -159,7 +163,7 @@ void RTC::KeyFrameRequestManager::ForceKeyFrameNeeded(uint32_t ssrc)
 		}
 
 		this->mapSsrcKeyFrameRequestDelayer[ssrc] =
-		  new KeyFrameRequestDelayer(this, this->shared, ssrc, this->keyFrameRequestDelay);
+		  new KeyFrameRequestDelayer(this, this->shared, ssrc, this->keyFrameRequestDelayMs);
 	}
 
 	auto it = this->mapSsrcPendingKeyFrameInfo.find(ssrc);

package/worker/src/RTC/NackGenerator.cpp

@@ -8,20 +8,20 @@ namespace RTC
 {
 	/* Static. */
 
-	static constexpr size_t MaxPacketAge{ 10000u };
-	static constexpr size_t MaxNackPackets{ 1000u };
-	static constexpr uint32_t DefaultRtt{ 100u };
-	static constexpr uint8_t MaxNackRetries{ 10u };
-	static constexpr uint64_t TimerInterval{ 40u };
+	static constexpr size_t MaxPacketAge{ 10000 };
+	static constexpr size_t MaxNackPackets{ 1000 };
+	static constexpr int64_t DefaultRttMs{ 100 };
+	static constexpr uint8_t MaxNackRetries{ 10 };
+	static constexpr int64_t TimerIntervalMs{ 40 };
 
 	/* Instance methods. */
 
-	NackGenerator::NackGenerator(Listener* listener, SharedInterface* shared, uint32_t sendNackDelayMs)
+	NackGenerator::NackGenerator(Listener* listener, SharedInterface* shared, int64_t sendNackDelayMs)
 	  : listener(listener),
 	    shared(shared),
 	    sendNackDelayMs(sendNackDelayMs),
-	    timer(shared->CreateTimer(this)),
-	    rtt(DefaultRtt)
+	    timer(shared->CreateTimer(this, "nack-generator")),
+	    rttMs(DefaultRttMs)
 	{
 		MS_TRACE();
 	}
@@ -247,7 +247,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		const uint64_t nowMs = this->shared->GetTimeMs();
+		const int64_t nowMs = this->shared->GetTimeMs();
 		std::vector<uint16_t> nackBatch;
 
 		auto it = this->nackList.begin();
@@ -266,7 +266,7 @@ namespace RTC
 			if (
 			  filter == NackFilter::SEQ && nackInfo.sentAtMs == 0 &&
 			  (nackInfo.sendAtSeq == this->lastSeq ||
-			   SeqManager<uint16_t>::IsSeqHigherThan(this->lastSeq, nackInfo.sendAtSeq)))
+				 SeqManager<uint16_t>::IsSeqHigherThan(this->lastSeq, nackInfo.sendAtSeq)))
 			{
 				nackBatch.emplace_back(seq);
 				nackInfo.retries++;
@@ -293,7 +293,7 @@ namespace RTC
 			if (
 			  filter == NackFilter::TIME &&
 			  (nackInfo.sentAtMs == 0 ||
-			   nowMs - nackInfo.sentAtMs >= (this->rtt > 0u ? this->rtt : DefaultRtt)))
+				 nowMs - nackInfo.sentAtMs >= (this->rttMs > 0 ? this->rttMs : DefaultRttMs)))
 			{
 				nackBatch.emplace_back(seq);
 				nackInfo.retries++;
@@ -363,7 +363,7 @@ namespace RTC
 		}
 		else
 		{
-			this->timer->Start(TimerInterval);
+			this->timer->Start(TimerIntervalMs);
 		}
 	}
 

package/worker/src/RTC/PipeProducerStreamManager.cpp

@@ -73,28 +73,28 @@ namespace RTC
 		// Do nothing.
 	}
 
-	uint32_t PipeProducerStreamManager::IncreaseLayer(
-	  uint32_t /*bitrate*/, bool /*considerLoss*/, float /*lossPercentage*/, uint64_t /*nowMs*/)
+	int64_t PipeProducerStreamManager::IncreaseLayer(
+	  int64_t /*bitrate*/, bool /*considerLoss*/, float /*lossPercentage*/, int64_t /*nowMs*/)
 	{
 		MS_TRACE();
 
 		// Pipe does not play the BWE game.
-		return 0u;
+		return 0;
 	}
 
-	void PipeProducerStreamManager::ApplyLayers(uint64_t /*rtpStreamActiveMs*/)
+	void PipeProducerStreamManager::ApplyLayers(int64_t /*rtpStreamActiveMs*/)
 	{
 		MS_TRACE();
 
 		// Pipe does not play the BWE game.
 	}
 
-	uint32_t PipeProducerStreamManager::GetDesiredBitrate(uint64_t /*nowMs*/) const
+	int64_t PipeProducerStreamManager::GetDesiredBitrate(int64_t /*nowMs*/) const
 	{
 		MS_TRACE();
 
 		// Pipe does not play the BWE game.
-		return 0u;
+		return 0;
 	}
 
 	ProducerStreamManager::RtpPacketProcessResult PipeProducerStreamManager::ProcessRtpPacket(

package/worker/src/RTC/PipeTransport.cpp

@@ -80,6 +80,7 @@ namespace RTC
 
 				this->udpSocket = new RTC::UdpSocket(
 				  this,
+				  this->shared,
 				  this->listenInfo.ip,
 				  this->listenInfo.portRange.min,
 				  this->listenInfo.portRange.max,
@@ -89,7 +90,7 @@ namespace RTC
 			else if (this->listenInfo.port != 0)
 			{
 				this->udpSocket = new RTC::UdpSocket(
-				  this, this->listenInfo.ip, this->listenInfo.port, this->listenInfo.flags);
+				  this, this->shared, this->listenInfo.ip, this->listenInfo.port, this->listenInfo.flags);
 			}
 			// NOTE: This is temporal to allow deprecated usage of worker port range.
 			// In the future this should throw since |port| or |portRange| will be
@@ -100,6 +101,7 @@ namespace RTC
 
 				this->udpSocket = new RTC::UdpSocket(
 				  this,
+				  this->shared,
 				  this->listenInfo.ip,
 				  Settings::configuration.rtcMinPort,
 				  Settings::configuration.rtcMaxPort,
@@ -632,7 +634,7 @@ namespace RTC
 	}
 
 	inline void PipeTransport::OnPacketReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -642,17 +644,17 @@ namespace RTC
 		// Check if it's RTCP.
 		if (RTC::RTCP::Packet::IsRtcp(data, len))
 		{
-			OnRtcpDataReceived(tuple, data, len);
+			OnRtcpDataReceived(tuple, data, len, receivedAtUs);
 		}
 		// Check if it's RTP.
 		else if (RTC::RTP::Packet::IsRtp(data, len))
 		{
-			OnRtpDataReceived(tuple, data, len, bufferLen);
+			OnRtpDataReceived(tuple, data, len, bufferLen, receivedAtUs);
 		}
 		// Check if it's SCTP.
 		else if (RTC::SCTP::Packet::IsSctp(data, len))
 		{
-			OnSctpDataReceived(tuple, data, len);
+			OnSctpDataReceived(tuple, data, len, receivedAtUs);
 		}
 		else
 		{
@@ -661,7 +663,7 @@ namespace RTC
 	}
 
 	inline void PipeTransport::OnRtpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -717,11 +719,11 @@ namespace RTC
 		}
 
 		// Pass the packet to the parent transport.
-		RTC::Transport::ReceiveRtpPacket(packet);
+		RTC::Transport::ReceiveRtpPacket(packet, receivedAtUs);
 	}
 
 	inline void PipeTransport::OnRtcpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -754,11 +756,11 @@ namespace RTC
 		}
 
 		// Pass the packet to the parent transport.
-		RTC::Transport::ReceiveRtcpPacket(packet);
+		RTC::Transport::ReceiveRtcpPacket(packet, receivedAtUs);
 	}
 
 	inline void PipeTransport::OnSctpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -776,7 +778,7 @@ namespace RTC
 		}
 
 		// Pass it to the parent transport.
-		RTC::Transport::ReceiveSctpData(data, len);
+		RTC::Transport::ReceiveSctpData(data, len, receivedAtUs);
 	}
 
 	inline void PipeTransport::OnUdpSocketPacketReceived(
@@ -784,12 +786,13 @@ namespace RTC
 	  const uint8_t* data,
 	  size_t len,
 	  size_t bufferLen,
-	  const struct sockaddr* remoteAddr)
+	  const struct sockaddr* remoteAddr,
+	  int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		RTC::TransportTuple tuple(socket, remoteAddr);
 
-		OnPacketReceived(&tuple, data, len, bufferLen);
+		OnPacketReceived(&tuple, data, len, bufferLen, receivedAtUs);
 	}
 } // namespace RTC

package/worker/src/RTC/PlainTransport.cpp

@@ -22,11 +22,11 @@ namespace RTC
 	static constexpr size_t SrtpAesGcm256MasterKeyLength{ 32 };
 	static constexpr size_t SrtpAesGcm256MasterSaltLength{ 12 };
 	static constexpr size_t SrtpAesGcm256MasterLength{ SrtpAesGcm256MasterKeyLength +
-		                                                 SrtpAesGcm256MasterSaltLength };
+	                                                   SrtpAesGcm256MasterSaltLength };
 	static constexpr size_t SrtpAesGcm128MasterKeyLength{ 16 };
 	static constexpr size_t SrtpAesGcm128MasterSaltLength{ 12 };
 	static constexpr size_t SrtpAesGcm128MasterLength{ SrtpAesGcm128MasterKeyLength +
-		                                                 SrtpAesGcm128MasterSaltLength };
+	                                                   SrtpAesGcm128MasterSaltLength };
 
 	/* Class variables. */
 
@@ -159,6 +159,7 @@ namespace RTC
 
 				this->udpSocket = new RTC::UdpSocket(
 				  this,
+				  this->shared,
 				  this->listenInfo.ip,
 				  this->listenInfo.portRange.min,
 				  this->listenInfo.portRange.max,
@@ -168,7 +169,7 @@ namespace RTC
 			else if (this->listenInfo.port != 0)
 			{
 				this->udpSocket = new RTC::UdpSocket(
-				  this, this->listenInfo.ip, this->listenInfo.port, this->listenInfo.flags);
+				  this, this->shared, this->listenInfo.ip, this->listenInfo.port, this->listenInfo.flags);
 			}
 			// NOTE: This is temporal to allow deprecated usage of worker port range.
 			// In the future this should throw since |port| or |portRange| will be
@@ -179,6 +180,7 @@ namespace RTC
 
 				this->udpSocket = new RTC::UdpSocket(
 				  this,
+				  this->shared,
 				  this->listenInfo.ip,
 				  Settings::configuration.rtcMinPort,
 				  Settings::configuration.rtcMaxPort,
@@ -206,6 +208,7 @@ namespace RTC
 
 					this->rtcpUdpSocket = new RTC::UdpSocket(
 					  this,
+					  this->shared,
 					  this->rtcpListenInfo.ip,
 					  this->rtcpListenInfo.portRange.min,
 					  this->rtcpListenInfo.portRange.max,
@@ -215,7 +218,11 @@ namespace RTC
 				else if (this->rtcpListenInfo.port != 0)
 				{
 					this->rtcpUdpSocket = new RTC::UdpSocket(
-					  this, this->rtcpListenInfo.ip, this->rtcpListenInfo.port, this->rtcpListenInfo.flags);
+					  this,
+					  this->shared,
+					  this->rtcpListenInfo.ip,
+					  this->rtcpListenInfo.port,
+					  this->rtcpListenInfo.flags);
 				}
 				// NOTE: This is temporal to allow deprecated usage of worker port range.
 				// In the future this should throw since |port| or |portRange| will be
@@ -226,6 +233,7 @@ namespace RTC
 
 					this->rtcpUdpSocket = new RTC::UdpSocket(
 					  this,
+					  this->shared,
 					  this->rtcpListenInfo.ip,
 					  Settings::configuration.rtcMinPort,
 					  Settings::configuration.rtcMaxPort,
@@ -956,7 +964,7 @@ namespace RTC
 	}
 
 	inline void PlainTransport::OnPacketReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -966,17 +974,17 @@ namespace RTC
 		// Check if it's RTCP.
 		if (RTC::RTCP::Packet::IsRtcp(data, len))
 		{
-			OnRtcpDataReceived(tuple, data, len);
+			OnRtcpDataReceived(tuple, data, len, receivedAtUs);
 		}
 		// Check if it's RTP.
 		else if (RTC::RTP::Packet::IsRtp(data, len))
 		{
-			OnRtpDataReceived(tuple, data, len, bufferLen);
+			OnRtpDataReceived(tuple, data, len, bufferLen, receivedAtUs);
 		}
 		// Check if it's SCTP.
 		else if (RTC::SCTP::Packet::IsSctp(data, len))
 		{
-			OnSctpDataReceived(tuple, data, len);
+			OnSctpDataReceived(tuple, data, len, receivedAtUs);
 		}
 		else
 		{
@@ -985,7 +993,7 @@ namespace RTC
 	}
 
 	inline void PlainTransport::OnRtpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1077,11 +1085,11 @@ namespace RTC
 		}
 
 		// Pass the packet to the parent transport.
-		RTC::Transport::ReceiveRtpPacket(packet);
+		RTC::Transport::ReceiveRtpPacket(packet, receivedAtUs);
 	}
 
 	inline void PlainTransport::OnRtcpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1175,11 +1183,11 @@ namespace RTC
 		}
 
 		// Pass the packet to the parent transport.
-		RTC::Transport::ReceiveRtcpPacket(packet);
+		RTC::Transport::ReceiveRtcpPacket(packet, receivedAtUs);
 	}
 
 	inline void PlainTransport::OnSctpDataReceived(
-	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len)
+	  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1223,7 +1231,7 @@ namespace RTC
 		}
 
 		// Pass it to the parent transport.
-		RTC::Transport::ReceiveSctpData(data, len);
+		RTC::Transport::ReceiveSctpData(data, len, receivedAtUs);
 	}
 
 	inline void PlainTransport::EmitTuple() const
@@ -1262,12 +1270,13 @@ namespace RTC
 	  const uint8_t* data,
 	  size_t len,
 	  size_t bufferLen,
-	  const struct sockaddr* remoteAddr)
+	  const struct sockaddr* remoteAddr,
+	  int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		RTC::TransportTuple tuple(socket, remoteAddr);
 
-		OnPacketReceived(&tuple, data, len, bufferLen);
+		OnPacketReceived(&tuple, data, len, bufferLen, receivedAtUs);
 	}
 } // namespace RTC