mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/RemoteClockOffsetEstimator.cpp

@@ -16,12 +16,12 @@ namespace RTC
 	}
 
 	void RemoteClockOffsetEstimator::AddSenderReport(
-	  uint64_t remoteNtpMs, uint64_t localArrivalMs, uint32_t rttMs)
+	  int64_t remoteNtpUs, int64_t localArrivalAtUs, int64_t rttMs)
 	{
 		MS_TRACE();
 
 		// Ignore Sender Reports with no NTP timestamp.
-		if (remoteNtpMs == 0)
+		if (remoteNtpUs == 0)
 		{
 			MS_DEBUG_DEV("ignoring Sender Report with no NTP timestamp");
 
@@ -31,17 +31,18 @@ namespace RTC
 		// Ignore a Sender Report belonging to a compound packet already accounted
 		// for. Otherwise a single delayed compound packet would contribute as many
 		// samples as streams it reports about, and hence bias the median.
-		if (localArrivalMs == this->lastLocalArrivalMs)
+		if (localArrivalAtUs == this->lastLocalArrivalAtUs)
 		{
 			return;
 		}
 
-		this->lastLocalArrivalMs = localArrivalMs;
+		this->lastLocalArrivalAtUs = localArrivalAtUs;
 
 		// The sample holds the clock offset plus the one way delay of this Sender
 		// Report. Assume a symmetric path and remove half of the RTT.
-		const int64_t sample = static_cast<int64_t>(localArrivalMs) -
-		                       static_cast<int64_t>(remoteNtpMs) - (static_cast<int64_t>(rttMs) / 2);
+		//
+		// NOTE: The RTT is given in milliseconds, hence the conversion.
+		const int64_t sample = localArrivalAtUs - remoteNtpUs - ((rttMs * 1000) / 2);
 
 		if (this->samples.size() == RemoteClockOffsetEstimator::WindowSize)
 		{
@@ -50,30 +51,30 @@ namespace RTC
 
 		this->samples.push_back(sample);
 
-		UpdateOffsetMs();
+		UpdateOffsetUs();
 	}
 
-	std::optional<uint64_t> RemoteClockOffsetEstimator::RemoteMsToLocalMs(uint64_t remoteMs) const
+	std::optional<int64_t> RemoteClockOffsetEstimator::RemoteUsToLocalUs(int64_t remoteUs) const
 	{
 		MS_TRACE();
 
-		if (!this->offsetMs.has_value())
+		if (!this->offsetUs.has_value())
 		{
 			return std::nullopt;
 		}
 
-		const int64_t localMs = static_cast<int64_t>(remoteMs) + this->offsetMs.value();
+		const int64_t localUs = remoteUs + this->offsetUs.value();
 
 		// The given time does not map into our clock, so the input is bogus.
-		if (localMs < 0)
+		if (localUs < 0)
 		{
 			MS_WARN_2TAGS(
-			  rtp, rtcp, "remote time does not map into our clock [remoteMs:%" PRIu64 "]", remoteMs);
+			  rtp, rtcp, "remote time does not map into our clock [remoteUs:%" PRIi64 "]", remoteUs);
 
 			return std::nullopt;
 		}
 
-		return static_cast<uint64_t>(localMs);
+		return localUs;
 	}
 
 	void RemoteClockOffsetEstimator::Reset()
@@ -81,11 +82,11 @@ namespace RTC
 		MS_TRACE();
 
 		this->samples.clear();
-		this->lastLocalArrivalMs = 0;
-		this->offsetMs.reset();
+		this->lastLocalArrivalAtUs = 0;
+		this->offsetUs.reset();
 	}
 
-	void RemoteClockOffsetEstimator::UpdateOffsetMs()
+	void RemoteClockOffsetEstimator::UpdateOffsetUs()
 	{
 		MS_TRACE();
 
@@ -101,6 +102,6 @@ namespace RTC
 
 		std::nth_element(sortedSamples.begin(), middle, sortedSamples.end());
 
-		this->offsetMs = *middle;
+		this->offsetUs = *middle;
 	}
 } // namespace RTC

package/worker/src/RTC/Router.cpp

@@ -649,6 +649,23 @@ namespace RTC
 		}
 	}
 
+	void Router::OnTransportProducerSpatialLayerActivityChanged(
+	  RTC::Transport* /*transport*/,
+	  RTC::Producer* producer,
+	  RTC::RTP::RtpStreamRecv* rtpStream,
+	  uint8_t spatialLayer,
+	  bool isActive)
+	{
+		MS_TRACE();
+
+		auto& consumers = this->mapProducerConsumers.at(producer);
+
+		for (auto* consumer : consumers)
+		{
+			consumer->ProducerSpatialLayerActivityChanged(rtpStream, spatialLayer, isActive);
+		}
+	}
+
 	void Router::OnTransportProducerRtpPacketReceived(
 	  RTC::Transport* /*transport*/, RTC::Producer* producer, RTC::RTP::Packet* packet)
 	{
@@ -923,7 +940,7 @@ namespace RTC
 		{
 			return dataConsumer->GetType() == DataConsumer::Type::SCTP
 			         ? dataConsumer->GetSctpStreamParameters().streamId
-			         : 0;
+							 : 0;
 		};
 
 		// NOTE: We don't send the message to a matching DataConsumer right away.

package/worker/src/RTC/RtpDictionaries/RtpEncodingParameters.cpp

@@ -5,6 +5,7 @@
 #include "MediaSoupErrors.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include <exception>
+#include <limits> // std::numeric_limits
 #include <regex>
 
 namespace RTC
@@ -44,7 +45,9 @@ namespace RTC
 		// maxBitrate is optional.
 		if (auto maxBitrate = data->maxBitrate(); maxBitrate.has_value())
 		{
-			this->maxBitrate = maxBitrate.value();
+			// NOTE: The API gives an unsigned 64 bits bitrate, so it is clamped here.
+			this->maxBitrate = static_cast<int64_t>(std::min<uint64_t>(
+			  maxBitrate.value(), static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
 		}
 
 		// dtx is optional, default is false.
@@ -90,7 +93,7 @@ namespace RTC
 		  this->ssrc != 0u ? flatbuffers::Optional<uint32_t>(this->ssrc) : flatbuffers::nullopt,
 		  !this->rid.empty() ? this->rid.c_str() : nullptr,
 		  this->hasCodecPayloadType ? flatbuffers::Optional<uint8_t>(this->codecPayloadType)
-		                            : flatbuffers::nullopt,
+			                          : flatbuffers::nullopt,
 		  this->hasRtx ? this->rtx.FillBuffer(builder) : 0u,
 		  this->dtx,
 		  this->scalabilityMode.c_str());