mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/BWE/TrendlineEstimator.cpp

@@ -0,0 +1,233 @@
+#define MS_CLASS "RTC::BWE::TrendlineEstimator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/BWE/TrendlineEstimator.hpp"
+#include "Logger.hpp"
+#include <cmath>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/* Static. */
+
+		// Coefficient of the exponential filter applied to the accumulated delay.
+		static constexpr double SmoothingCoef{ 0.9 };
+		// Gain applied to the slope before comparing it against the threshold.
+		static constexpr double ThresholdGain{ 4.0 };
+		// Number of deltas at which the modified trend stops being scaled down.
+		static constexpr int MinNumDeltas{ 60 };
+		// Maximum value of the delta counter.
+		static constexpr int DeltaCounterMax{ 1000 };
+		// Time the trend must stay above the threshold before declaring overuse.
+		static constexpr double OverusingTimeThresholdMs{ 10 };
+		// Rates at which the threshold adapts upwards and downwards, per millisecond.
+		static constexpr double ThresholdUpCoef{ 0.0087 };
+		static constexpr double ThresholdDownCoef{ 0.039 };
+		// Bounds of the adaptive threshold.
+		static constexpr double ThresholdMin{ 6.0 };
+		static constexpr double ThresholdMax{ 600.0 };
+		// Distance from the threshold beyond which it stops adapting, so that a
+		// sudden capacity drop doesn't drag it along.
+		//
+		// NOTE: It is not a time, being compared against the trend, which is a slope
+		// and hence dimensionless.
+		static constexpr double MaxAdaptOffset{ 15.0 };
+		// Maximum time step used when adapting the threshold.
+		static constexpr int64_t MaxThresholdUpdateDeltaMs{ 100 };
+
+		/* Instance methods. */
+
+		TrendlineEstimator::TrendlineEstimator(size_t windowSize) : windowSize(windowSize)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(windowSize >= 2, "window size must be at least 2 [windowSize:%zu]", windowSize);
+		}
+
+		void TrendlineEstimator::Update(int64_t sendDeltaUs, int64_t arrivalDeltaUs, int64_t arrivalTimeUs)
+		{
+			MS_TRACE();
+
+			const auto deltaUs = static_cast<double>(arrivalDeltaUs - sendDeltaUs);
+
+			this->numOfDeltas = std::min(this->numOfDeltas + 1, DeltaCounterMax);
+
+			if (!this->firstArrivalTimeUs.has_value())
+			{
+				this->firstArrivalTimeUs = arrivalTimeUs;
+			}
+
+			// Exponential backoff filter.
+			this->accumulatedDelayUs += deltaUs;
+			this->smoothedDelayUs =
+			  (SmoothingCoef * this->smoothedDelayUs) + ((1 - SmoothingCoef) * this->accumulatedDelayUs);
+
+			// Maintain the samples window. A group may arrive before the first one of
+			// the window did, in which case the regression just gets a negative x.
+			const auto elapsedUs = static_cast<double>(arrivalTimeUs - this->firstArrivalTimeUs.value());
+
+			this->delayHist.push_back({ elapsedUs, this->smoothedDelayUs });
+
+			if (this->delayHist.size() > this->windowSize)
+			{
+				this->delayHist.pop_front();
+			}
+
+			// Simple linear regression. The slope can be seen as an estimate of
+			// (sendRate - capacity) / capacity:
+			//   0 < trend < 1  ->  the delay increases, queues are filling up.
+			//   trend == 0     ->  the delay does not change.
+			//   trend < 0      ->  the delay decreases, queues are being emptied.
+			double trend = this->prevTrend;
+
+			if (this->delayHist.size() == this->windowSize)
+			{
+				// Keep the previous trend if the line cannot be fitted.
+				trend = GetLinearFitSlope().value_or(trend);
+			}
+
+			Detect(trend, static_cast<double>(sendDeltaUs), arrivalTimeUs);
+		}
+
+		std::optional<double> TrendlineEstimator::GetLinearFitSlope() const
+		{
+			MS_TRACE();
+
+			MS_ASSERT(
+			  this->delayHist.size() >= 2,
+			  "not enough samples to fit a line [samples:%zu]",
+			  this->delayHist.size());
+
+			// Compute the "center of mass".
+			double sumX{ 0 };
+			double sumY{ 0 };
+
+			for (const auto& sample : this->delayHist)
+			{
+				sumX += sample.arrivalTimeUs;
+				sumY += sample.smoothedDelayUs;
+			}
+
+			const double avgX = sumX / this->delayHist.size();
+			const double avgY = sumY / this->delayHist.size();
+
+			// Compute the slope as sum((x - avgX) * (y - avgY)) / sum((x - avgX)^2).
+			double numerator{ 0 };
+			double denominator{ 0 };
+
+			for (const auto& sample : this->delayHist)
+			{
+				const double x = sample.arrivalTimeUs - avgX;
+				const double y = sample.smoothedDelayUs - avgY;
+
+				numerator += x * y;
+				denominator += x * x;
+			}
+
+			// The line cannot be fitted when every sample arrived at the very same
+			// time.
+			if (denominator == 0)
+			{
+				return std::nullopt;
+			}
+
+			return numerator / denominator;
+		}
+
+		void TrendlineEstimator::Detect(double trend, double sendDeltaUs, int64_t arrivalTimeUs)
+		{
+			MS_TRACE();
+
+			if (this->numOfDeltas < 2)
+			{
+				this->state = Types::BandwidthUsage::NORMAL;
+
+				return;
+			}
+
+			// Scale the trend down while there are few deltas, so that the estimator
+			// doesn't react to a couple of samples.
+			const double modifiedTrend = std::min(this->numOfDeltas, MinNumDeltas) * trend * ThresholdGain;
+
+			if (modifiedTrend > this->threshold)
+			{
+				if (!this->timeOverUsingUs.has_value())
+				{
+					// Initialize the timer assuming that we have been over-using half of
+					// the time since the previous sample.
+					this->timeOverUsingUs = sendDeltaUs / 2;
+				}
+				else
+				{
+					this->timeOverUsingUs = this->timeOverUsingUs.value() + sendDeltaUs;
+				}
+
+				this->overuseCounter++;
+
+				// Only declare overuse once the condition has persisted for long enough,
+				// over more than a single sample, and while the trend is not decreasing
+				// already. This is what filters out isolated jitter spikes.
+				if (this->timeOverUsingUs.value() / 1000.0 > OverusingTimeThresholdMs && this->overuseCounter > 1)
+				{
+					if (trend >= this->prevTrend)
+					{
+						this->timeOverUsingUs = 0;
+						this->overuseCounter  = 0;
+						this->state           = Types::BandwidthUsage::OVERUSING;
+					}
+				}
+			}
+			else if (modifiedTrend < -this->threshold)
+			{
+				this->timeOverUsingUs.reset();
+				this->overuseCounter = 0;
+				this->state          = Types::BandwidthUsage::UNDERUSING;
+			}
+			else
+			{
+				this->timeOverUsingUs.reset();
+				this->overuseCounter = 0;
+				this->state          = Types::BandwidthUsage::NORMAL;
+			}
+
+			this->prevTrend = trend;
+
+			UpdateThreshold(modifiedTrend, arrivalTimeUs);
+		}
+
+		void TrendlineEstimator::UpdateThreshold(double modifiedTrend, int64_t arrivalTimeUs)
+		{
+			MS_TRACE();
+
+			if (!this->lastThresholdUpdateAtUs.has_value())
+			{
+				this->lastThresholdUpdateAtUs = arrivalTimeUs;
+			}
+
+			// Avoid adapting the threshold to big latency spikes, caused for instance
+			// by a sudden capacity drop.
+			if (std::fabs(modifiedTrend) > this->threshold + MaxAdaptOffset)
+			{
+				this->lastThresholdUpdateAtUs = arrivalTimeUs;
+
+				return;
+			}
+
+			// The threshold falls faster than it rises, so that it recovers quickly
+			// once the network calms down.
+			const double coef =
+			  std::fabs(modifiedTrend) < this->threshold ? ThresholdDownCoef : ThresholdUpCoef;
+			// NOTE: The coefficients above are rates per millisecond, so the step is
+			// expressed in those units no matter that the instants are microseconds.
+			const double elapsedMs = std::min(
+			  static_cast<double>(arrivalTimeUs - this->lastThresholdUpdateAtUs.value()) / 1000.0,
+			  static_cast<double>(MaxThresholdUpdateDeltaMs));
+
+			this->threshold += coef * (std::fabs(modifiedTrend) - this->threshold) * elapsedMs;
+			this->threshold = std::clamp(this->threshold, ThresholdMin, ThresholdMax);
+
+			this->lastThresholdUpdateAtUs = arrivalTimeUs;
+		}
+	} // namespace BWE
+} // namespace RTC

package/worker/src/RTC/Consumer.cpp

@@ -186,11 +186,11 @@ namespace RTC
 		// Set the RTCP report generation interval.
 		if (this->kind == RTC::Media::Kind::AUDIO)
 		{
-			this->maxRtcpInterval = RTC::RTCP::MaxAudioIntervalMs;
+			this->maxRtcpIntervalMs = RTC::RTCP::MaxAudioIntervalMs;
 		}
 		else
 		{
-			this->maxRtcpInterval = RTC::RTCP::MaxVideoIntervalMs;
+			this->maxRtcpIntervalMs = RTC::RTCP::MaxVideoIntervalMs;
 		}
 
 		auto& encoding = this->rtpParameters.encodings[0];
@@ -238,7 +238,7 @@ namespace RTC
 				if (
 				  mediaCodec->mimeType.type == RTC::RtpCodecMimeType::Type::AUDIO &&
 				  (mediaCodec->mimeType.subtype == RTC::RtpCodecMimeType::Subtype::OPUS ||
-				   mediaCodec->mimeType.subtype == RTC::RtpCodecMimeType::Subtype::MULTIOPUS))
+					 mediaCodec->mimeType.subtype == RTC::RtpCodecMimeType::Subtype::MULTIOPUS))
 				{
 					RTC::RTP::Codecs::EncodingContext::Params params;
 
@@ -556,7 +556,7 @@ namespace RTC
 		  RTC::RtpParameters::TypeToFbs(this->type),
 		  this->producerId.c_str(),
 		  this->kind == RTC::Media::Kind::AUDIO ? FBS::RtpParameters::MediaKind::AUDIO
-		                                        : FBS::RtpParameters::MediaKind::VIDEO,
+			                                      : FBS::RtpParameters::MediaKind::VIDEO,
 		  rtpParameters,
 		  &consumableRtpEncodings,
 		  &supportedCodecPayloadTypes,
@@ -984,6 +984,15 @@ namespace RTC
 		this->producerStreamManager->ProducerRtcpSenderReport(rtpStream, first);
 	}
 
+	void Consumer::ProducerSpatialLayerActivityChanged(
+	  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive)
+	{
+		MS_TRACE();
+
+		this->producerStreamManager->ProducerSpatialLayerActivityChanged(
+		  rtpStream, spatialLayer, isActive);
+	}
+
 	// The caller (Router) is supposed to proceed with the deletion of this Consumer
 	// right after calling this method. Otherwise ugly things may happen.
 	void Consumer::ProducerClosed()
@@ -1020,7 +1029,7 @@ namespace RTC
 		return this->priority;
 	}
 
-	uint32_t Consumer::IncreaseLayer(uint32_t bitrate, bool considerLoss)
+	int64_t Consumer::IncreaseLayer(int64_t bitrate, bool considerLoss)
 	{
 		MS_TRACE();
 
@@ -1030,7 +1039,7 @@ namespace RTC
 		// Pipe does not play the BWE game.
 		if (this->pipe)
 		{
-			return 0u;
+			return 0;
 		}
 
 		float lossPercentage{ 0.0f };
@@ -1042,7 +1051,7 @@ namespace RTC
 			lossPercentage = rtpStream->GetLossPercentage();
 		}
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		const int64_t nowMs = this->shared->GetTimeMs();
 
 		return this->producerStreamManager->IncreaseLayer(bitrate, considerLoss, lossPercentage, nowMs);
 	}
@@ -1065,7 +1074,7 @@ namespace RTC
 		this->producerStreamManager->ApplyLayers(rtpStream->GetActiveMs());
 	}
 
-	uint32_t Consumer::GetDesiredBitrate() const
+	int64_t Consumer::GetDesiredBitrate() const
 	{
 		MS_TRACE();
 
@@ -1074,21 +1083,22 @@ namespace RTC
 		// Pipe does not play the BWE game.
 		if (this->pipe)
 		{
-			return 0u;
+			return 0;
 		}
 
 		// Audio does not play the BWE game.
 		if (this->kind != RTC::Media::Kind::VIDEO)
 		{
-			return 0u;
+			return 0;
 		}
 
 		if (!IsActive())
 		{
-			return 0u;
+			return 0;
 		}
 
-		auto nowMs          = DepLibUV::GetTimeMs();
+		const int64_t nowMs = this->shared->GetTimeMs();
+
 		auto desiredBitrate = this->producerStreamManager->GetDesiredBitrate(nowMs);
 
 		// If consumer.rtpParameters.encodings[0].maxBitrate was given and it's
@@ -1356,22 +1366,24 @@ namespace RTC
 		}
 	}
 
-	bool Consumer::GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs)
+	bool Consumer::GetRtcp(RTC::RTCP::CompoundPacket* packet, int64_t nowUs)
 	{
 		MS_TRACE();
 
+		// NOTE: The interval is in milliseconds, being it given to a timer, so the
+		// elapsed time is truncated here.
+		const int64_t elapsedMs = (nowUs - this->lastRtcpSentAtUs) / 1000;
+
 		// Special condition for pipe consumer since this method will be called in a
 		// loop for each stream.
 		if (this->pipe)
 		{
-			if (
-			  nowMs != this->lastRtcpSentTime &&
-			  static_cast<float>((nowMs - this->lastRtcpSentTime) * 1.15) < this->maxRtcpInterval)
+			if (nowUs != this->lastRtcpSentAtUs && static_cast<float>(elapsedMs * 1.15) < this->maxRtcpIntervalMs)
 			{
 				return true;
 			}
 		}
-		else if (static_cast<float>((nowMs - this->lastRtcpSentTime) * 1.15) < this->maxRtcpInterval)
+		else if (static_cast<float>(elapsedMs * 1.15) < this->maxRtcpIntervalMs)
 		{
 			return true;
 		}
@@ -1382,7 +1394,7 @@ namespace RTC
 
 		for (auto* rtpStream : this->rtpStreams)
 		{
-			auto* report = rtpStream->GetRtcpSenderReport(nowMs);
+			auto* report = rtpStream->GetRtcpSenderReport(nowUs);
 
 			if (!report)
 			{
@@ -1395,7 +1407,7 @@ namespace RTC
 			auto* sdesChunk = rtpStream->GetRtcpSdesChunk();
 			sdesChunks.push_back(sdesChunk);
 
-			auto* delaySinceLastRrSsrcInfo = rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowMs);
+			auto* delaySinceLastRrSsrcInfo = rtpStream->GetRtcpXrDelaySinceLastRrSsrcInfo(nowUs);
 
 			if (delaySinceLastRrSsrcInfo)
 			{
@@ -1409,7 +1421,7 @@ namespace RTC
 			return false;
 		}
 
-		this->lastRtcpSentTime = nowMs;
+		this->lastRtcpSentAtUs = nowUs;
 
 		return true;
 	}
@@ -1512,26 +1524,27 @@ namespace RTC
 		}
 	}
 
-	void Consumer::ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report)
+	void Consumer::ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		auto* rtpStream = this->mapSsrcRtpStream.at(report->GetSsrc());
 
-		rtpStream->ReceiveRtcpReceiverReport(report);
+		rtpStream->ReceiveRtcpReceiverReport(report, receivedAtUs);
 	}
 
-	void Consumer::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	void Consumer::ReceiveRtcpXrReceiverReferenceTime(
+	  RTC::RTCP::ReceiverReferenceTime* report, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		for (auto* rtpStream : this->rtpStreams)
 		{
-			rtpStream->ReceiveRtcpXrReceiverReferenceTime(report);
+			rtpStream->ReceiveRtcpXrReceiverReferenceTime(report, receivedAtUs);
 		}
 	}
 
-	uint32_t Consumer::GetTransmissionRate(uint64_t nowMs)
+	int64_t Consumer::GetTransmissionRate(int64_t nowMs)
 	{
 		MS_TRACE();
 
@@ -1540,7 +1553,7 @@ namespace RTC
 			return 0u;
 		}
 
-		uint32_t rate{ 0u };
+		int64_t rate{ 0 };
 
 		for (auto* rtpStream : this->rtpStreams)
 		{
@@ -1550,18 +1563,18 @@ namespace RTC
 		return rate;
 	}
 
-	float Consumer::GetRtt() const
+	float Consumer::GetRttMs() const
 	{
 		MS_TRACE();
 
-		float rtt{ 0 };
+		float rttMs{ 0 };
 
 		for (auto* rtpStream : this->rtpStreams)
 		{
-			rtt = std::max(rtpStream->GetRtt(), rtt);
+			rttMs = std::max(rtpStream->GetRttMs(), rttMs);
 		}
 
-		return rtt;
+		return rttMs;
 	}
 
 	void Consumer::UserOnTransportConnected()
@@ -1837,7 +1850,7 @@ namespace RTC
 			auto notification = FBS::Consumer::CreateTraceNotification(
 			  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 			  FBS::Consumer::TraceEventType::KEYFRAME,
-			  this->shared->GetTimeMs(),
+			  static_cast<uint64_t>(this->shared->GetTimeMs()),
 			  FBS::Common::TraceDirection::DIRECTION_OUT,
 			  FBS::Consumer::TraceInfo::KeyFrameTraceInfo,
 			  traceInfo.Union());
@@ -1853,7 +1866,7 @@ namespace RTC
 			auto notification = FBS::Consumer::CreateTraceNotification(
 			  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 			  FBS::Consumer::TraceEventType::RTP,
-			  this->shared->GetTimeMs(),
+			  static_cast<uint64_t>(this->shared->GetTimeMs()),
 			  FBS::Common::TraceDirection::DIRECTION_OUT,
 			  FBS::Consumer::TraceInfo::RtpTraceInfo,
 			  traceInfo.Union());
@@ -1877,7 +1890,7 @@ namespace RTC
 		auto notification = FBS::Consumer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Consumer::TraceEventType::PLI,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_IN,
 		  FBS::Consumer::TraceInfo::PliTraceInfo,
 		  traceInfo.Union());
@@ -1900,7 +1913,7 @@ namespace RTC
 		auto notification = FBS::Consumer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Consumer::TraceEventType::FIR,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_IN,
 		  FBS::Consumer::TraceInfo::FirTraceInfo,
 		  traceInfo.Union());
@@ -1920,7 +1933,7 @@ namespace RTC
 		auto notification = FBS::Consumer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Consumer::TraceEventType::NACK,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_IN);
 
 		EmitTraceEvent(notification);

package/worker/src/RTC/DataConsumer.cpp

@@ -129,7 +129,7 @@ namespace RTC
 		  this->id.c_str(),
 		  this->dataProducerId.c_str(),
 		  this->type == DataConsumer::Type::SCTP ? FBS::DataConsumer::Type::SCTP
-		                                         : FBS::DataConsumer::Type::DIRECT,
+			                                       : FBS::DataConsumer::Type::DIRECT,
 		  sctpStreamParameters,
 		  this->label.c_str(),
 		  this->protocol.c_str(),
@@ -152,7 +152,7 @@ namespace RTC
 		return FBS::DataConsumer::CreateGetStatsResponseDirect(
 		  builder,
 		  // timestamp.
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  // label.
 		  this->label.c_str(),
 		  // protocol.
@@ -293,8 +293,8 @@ namespace RTC
 
 						  this->listener->OnDataConsumerNeedBufferedAmount(this, bufferedAmount);
 
-						  auto responseOffset = FBS::DataConsumer::CreateGetBufferedAmountResponse(
-						    request->GetBufferBuilder(), bufferedAmount);
+						  auto responseOffset =
+						    FBS::DataConsumer::CreateSendResponse(request->GetBufferBuilder(), bufferedAmount);
 
 						  request->Accept(FBS::Response::Body::DataConsumer_SendResponse, responseOffset);
 					  }

package/worker/src/RTC/DataProducer.cpp

@@ -92,7 +92,7 @@ namespace RTC
 		  builder,
 		  this->id.c_str(),
 		  this->type == DataProducer::Type::SCTP ? FBS::DataProducer::Type::SCTP
-		                                         : FBS::DataProducer::Type::DIRECT,
+			                                       : FBS::DataProducer::Type::DIRECT,
 		  sctpStreamParametersOffset,
 		  this->label.c_str(),
 		  this->protocol.c_str(),
@@ -107,7 +107,7 @@ namespace RTC
 		return FBS::DataProducer::CreateGetStatsResponseDirect(
 		  builder,
 		  // timestamp.
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  // label.
 		  this->label.c_str(),
 		  // protocol.
@@ -193,7 +193,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		switch (notification->event)
+		switch (notification->data->event())
 		{
 			case Channel::ChannelNotification::Event::DATAPRODUCER_SEND:
 			{

package/worker/src/RTC/DirectTransport.cpp

@@ -98,7 +98,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		switch (notification->event)
+		switch (notification->data->event())
 		{
 			case Channel::ChannelNotification::Event::TRANSPORT_SEND_RTCP:
 			{
@@ -125,7 +125,7 @@ namespace RTC
 				}
 
 				// Pass the packet to the parent transport.
-				RTC::Transport::ReceiveRtcpPacket(packet);
+				RTC::Transport::ReceiveRtcpPacket(packet, notification->receivedAtUs);
 
 				break;
 			}

package/worker/src/RTC/DtlsTransport.cpp

@@ -118,11 +118,11 @@ namespace RTC
 	static constexpr size_t SrtpAesGcm256MasterKeyLength{ 32u };
 	static constexpr size_t SrtpAesGcm256MasterSaltLength{ 12u };
 	static constexpr size_t SrtpAesGcm256MasterLength{ SrtpAesGcm256MasterKeyLength +
-		                                                 SrtpAesGcm256MasterSaltLength };
+	                                                   SrtpAesGcm256MasterSaltLength };
 	static constexpr size_t SrtpAesGcm128MasterKeyLength{ 16u };
 	static constexpr size_t SrtpAesGcm128MasterSaltLength{ 12u };
 	static constexpr size_t SrtpAesGcm128MasterLength{ SrtpAesGcm128MasterKeyLength +
-		                                                 SrtpAesGcm128MasterSaltLength };
+	                                                   SrtpAesGcm128MasterSaltLength };
 
 	/* Class variables. */
 
@@ -137,7 +137,7 @@ namespace RTC
 		  { "sha-256", DtlsTransport::FingerprintAlgorithm::SHA256 },
 		  { "sha-384", DtlsTransport::FingerprintAlgorithm::SHA384 },
 		  { "sha-512", DtlsTransport::FingerprintAlgorithm::SHA512 }
-  };
+	};
 	const ankerl::unordered_dense::map<DtlsTransport::FingerprintAlgorithm, std::string>
 	  DtlsTransport::FingerprintAlgorithm2String = {
 		  { DtlsTransport::FingerprintAlgorithm::SHA1,   "sha-1"   },
@@ -145,7 +145,7 @@ namespace RTC
 		  { DtlsTransport::FingerprintAlgorithm::SHA256, "sha-256" },
 		  { DtlsTransport::FingerprintAlgorithm::SHA384, "sha-384" },
 		  { DtlsTransport::FingerprintAlgorithm::SHA512, "sha-512" }
-  };
+	};
 	const ankerl::unordered_dense::map<std::string, DtlsTransport::Role> DtlsTransport::String2Role = {
 		{ "auto",   DtlsTransport::Role::AUTO   },
 		{ "client", DtlsTransport::Role::CLIENT },
@@ -780,7 +780,7 @@ namespace RTC
 		DTLS_set_timer_cb(this->ssl, onSslDtlsTimer);
 
 		// Set the DTLS timer.
-		this->timer = this->shared->CreateTimer(this);
+		this->timer = this->shared->CreateTimer(this, "dtls-transport");
 
 		return;
 
@@ -978,7 +978,7 @@ namespace RTC
 		return true;
 	}
 
-	void DtlsTransport::ProcessDtlsData(const uint8_t* data, size_t len)
+	void DtlsTransport::ProcessDtlsData(const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1034,7 +1034,10 @@ namespace RTC
 
 			// Notify the listener.
 			this->listener->OnDtlsTransportApplicationDataReceived(
-			  this, static_cast<const uint8_t*>(DtlsTransport::sslReadBuffer), static_cast<size_t>(read));
+			  this,
+			  static_cast<const uint8_t*>(DtlsTransport::sslReadBuffer),
+			  static_cast<size_t>(read),
+			  receivedAtUs);
 		}
 	}
 
@@ -1270,14 +1273,14 @@ namespace RTC
 		  "invalid DTLS state");
 
 		uv_timeval_t dtlsTimeout{ 0, 0 };
-		uint64_t timeoutMs;
+		int64_t timeoutMs;
 
 		// DTLSv1_get_timeout queries the next DTLS handshake timeout. If there is
 		// a timeout in progress, it sets *out to the time remaining and returns
 		// one. Otherwise, it returns zero.
 		DTLSv1_get_timeout(this->ssl, static_cast<void*>(std::addressof(dtlsTimeout)));
 
-		timeoutMs = (dtlsTimeout.tv_sec * static_cast<uint64_t>(1000)) + (dtlsTimeout.tv_usec / 1000);
+		timeoutMs = (dtlsTimeout.tv_sec * static_cast<int64_t>(1000)) + (dtlsTimeout.tv_usec / 1000);
 
 		if (timeoutMs == 0)
 		{
@@ -1289,7 +1292,7 @@ namespace RTC
 		}
 		else if (timeoutMs < 30000)
 		{
-			MS_DEBUG_DEV("DTLS timer set in %" PRIu64 "ms", timeoutMs);
+			MS_DEBUG_DEV("DTLS timer set in %" PRIi64 "ms", timeoutMs);
 
 			this->timer->Start(timeoutMs);
 
@@ -1299,7 +1302,7 @@ namespace RTC
 		// seconds.
 		else
 		{
-			MS_WARN_TAG(dtls, "DTLS timeout too high (%" PRIu64 "ms), resetting DLTS", timeoutMs);
+			MS_WARN_TAG(dtls, "DTLS timeout too high (%" PRIi64 "ms), resetting DLTS", timeoutMs);
 
 			Reset();
 

package/worker/src/RTC/ICE/IceServer.cpp

@@ -165,7 +165,7 @@ namespace RTC
 				MS_DUMP_CLEAN(indentation, "  selected tuple:");
 				this->selectedTuple->Dump(indentation + 2);
 			}
-			MS_DUMP_CLEAN(indentation, "  consent timeout (ms): %" PRIu16, this->consentTimeoutMs);
+			MS_DUMP_CLEAN(indentation, "  consent timeout (ms): %" PRIi64, this->consentTimeoutMs);
 			MS_DUMP_CLEAN(indentation, "  remote nomination: %" PRIu32, this->remoteNomination);
 			MS_DUMP_CLEAN(indentation, "</IceServer>");
 		}
@@ -937,7 +937,7 @@ namespace RTC
 			// Create the ICE consent check timer if it doesn't exist.
 			if (!this->consentCheckTimer)
 			{
-				this->consentCheckTimer = this->shared->CreateTimer(this);
+				this->consentCheckTimer = this->shared->CreateTimer(this, "ice-server-consent-check");
 			}
 
 			this->consentCheckTimer->Start(this->consentTimeoutMs);