mediasoup 3.28.0 → 3.29.0

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

@@ -30,7 +30,7 @@ namespace RTC
 		/* Instance methods. */
 
 		Types::BandwidthUsage OveruseDetector::Detect(
-		  double offsetMs, double sendDeltaMs, int64_t numOfDeltas, int64_t nowUs)
+		  double offsetMs, double sendDeltaMs, int64_t numOfDeltas, int64_t arrivalTimeUs)
 		{
 			MS_TRACE();
 
@@ -86,25 +86,25 @@ namespace RTC
 
 			this->prevOffsetMs = offsetMs;
 
-			UpdateThreshold(modifiedOffsetMs, nowUs);
+			UpdateThreshold(modifiedOffsetMs, arrivalTimeUs);
 
 			return this->state;
 		}
 
-		void OveruseDetector::UpdateThreshold(double modifiedOffsetMs, int64_t nowUs)
+		void OveruseDetector::UpdateThreshold(double modifiedOffsetMs, int64_t arrivalTimeUs)
 		{
 			MS_TRACE();
 
-			if (!this->lastThresholdUpdateAtUs.has_value())
+			if (!this->lastSampleArrivalTimeUs.has_value())
 			{
-				this->lastThresholdUpdateAtUs = nowUs;
+				this->lastSampleArrivalTimeUs = arrivalTimeUs;
 			}
 
 			// Avoid adapting the threshold to big latency spikes, caused for instance
 			// by a sudden capacity drop.
 			if (std::fabs(modifiedOffsetMs) > this->threshold + MaxAdaptOffsetMs)
 			{
-				this->lastThresholdUpdateAtUs = nowUs;
+				this->lastSampleArrivalTimeUs = arrivalTimeUs;
 
 				return;
 			}
@@ -116,13 +116,13 @@ namespace RTC
 			// 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>(nowUs - this->lastThresholdUpdateAtUs.value()) / 1000.0,
+			  static_cast<double>(arrivalTimeUs - this->lastSampleArrivalTimeUs.value()) / 1000.0,
 			  MaxThresholdUpdateDeltaMs);
 
 			this->threshold += coef * (std::fabs(modifiedOffsetMs) - this->threshold) * elapsedMs;
 			this->threshold = std::clamp(this->threshold, ThresholdMin, ThresholdMax);
 
-			this->lastThresholdUpdateAtUs = nowUs;
+			this->lastSampleArrivalTimeUs = arrivalTimeUs;
 		}
 	} // namespace BWE
 } // namespace RTC

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

@@ -200,7 +200,7 @@ namespace RTC
 			return estimatedBitrate;
 		}
 
-		void ProbeBitrateEstimator::EraseOldClusters(int64_t nowUs)
+		void ProbeBitrateEstimator::EraseOldClusters(int64_t arrivalTimeUs)
 		{
 			MS_TRACE();
 
@@ -208,7 +208,7 @@ namespace RTC
 			{
 				const auto& cluster = it->second;
 
-				if (cluster.lastReceiveTimeUs.has_value() && cluster.lastReceiveTimeUs.value() + MaxClusterHistoryUs < nowUs)
+				if (cluster.lastReceiveTimeUs.has_value() && cluster.lastReceiveTimeUs.value() + MaxClusterHistoryUs < arrivalTimeUs)
 				{
 					it = this->clusters.erase(it);
 				}

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

@@ -535,7 +535,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			if (!this->enablePeriodicAlrProbing || !this->alrStartTimeUs.has_value())
+			if (!this->options.enablePeriodicAlrProbing || !this->alrStartTimeUs.has_value())
 			{
 				return false;
 			}

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

@@ -128,12 +128,7 @@ namespace RTC
 
 				remaining -= std::min(remaining, length);
 
-				if (!this->listener->OnProbePacketGeneratorSendRtpPacket(this, this->packet.get()))
-				{
-					MS_DEBUG_DEV("burst given up on, %zu bytes were left", remaining);
-
-					break;
-				}
+				this->listener->OnProbePacketGeneratorSendRtpPacket(this, this->packet.get());
 			}
 		}
 	} // namespace BWE

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

@@ -64,21 +64,16 @@ namespace RTC
 			this->nextProbeTimer->Restart(0);
 		}
 
-		bool ProbingScheduler::OnProbePacketGeneratorSendRtpPacket(
+		void ProbingScheduler::OnProbePacketGeneratorSendRtpPacket(
 		  ProbePacketGenerator* /*probePacketGenerator*/, RTC::RTP::Packet* packet)
 		{
 			MS_TRACE();
 
-			if (!this->listener->OnProbingSchedulerSendRtpPacket(this, packet, this->shotProbeCluster))
-			{
-				return false;
-			}
+			this->listener->OnProbingSchedulerSendRtpPacket(this, packet, this->shotProbeCluster);
 
 			// What the burst is measured against is what the link has to carry, which
 			// is more than what the packet itself is worth.
 			this->shotSentBytes += packet->GetLength() + this->packetOverhead;
-
-			return true;
 		}
 
 		void ProbingScheduler::OnTimer(TimerHandleInterface* timer)

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

@@ -0,0 +1,207 @@
+#define MS_CLASS "RTC::BWE::ReceiverTransportCongestionController"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/BWE/ReceiverTransportCongestionController.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/* Instance methods. */
+
+		ReceiverTransportCongestionController::ReceiverTransportCongestionController(
+		  Listener* listener, SharedInterface* shared, ReceiverTransportCongestionControllerOptions options)
+		  : options(options), listener(listener), shared(shared), rembGenerator(this)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(
+			  this->options.congestionControlType == Types::CongestionControlType::TRANSPORT_CC ||
+			    this->options.congestionControlType == Types::CongestionControlType::REMB,
+			  "no congestion control type given");
+
+			switch (this->options.congestionControlType)
+			{
+				case Types::CongestionControlType::TRANSPORT_CC:
+				{
+					this->transportWideCcFeedbackGenerator = std::make_unique<TransportWideCcFeedbackGenerator>(
+					  this, this->shared, this->options.maxRtcpPacketLen);
+
+					break;
+				}
+
+				case Types::CongestionControlType::REMB:
+				{
+					this->remoteBitrateEstimator = std::make_unique<RemoteBitrateEstimatorAbsSendTime>(this);
+
+					break;
+				}
+
+					NO_DEFAULT();
+			}
+		}
+
+		void ReceiverTransportCongestionController::ReceiveRtpPacket(
+		  int64_t receivedAtUs, const RTC::RTP::Packet* packet, RTC::Media::Kind kind)
+		{
+			MS_TRACE();
+
+			switch (this->options.congestionControlType)
+			{
+				case Types::CongestionControlType::TRANSPORT_CC:
+				{
+					this->transportWideCcFeedbackGenerator->ReceiveRtpPacket(receivedAtUs, packet);
+
+					break;
+				}
+
+				case Types::CongestionControlType::REMB:
+				{
+					// Audio packets take no part in the estimation of the incoming link,
+					// so their streams are not announced in the REMB either.
+					if (kind == RTC::Media::Kind::AUDIO)
+					{
+						break;
+					}
+
+					this->remoteBitrateEstimator->ReceiveRtpPacket(
+					  packet, receivedAtUs, this->shared->GetTimeUs());
+
+					break;
+				}
+
+					NO_DEFAULT();
+			}
+
+			// The cap has to keep being announced whatever was negotiated, since a
+			// remote sender that only reports arrival times is never told anything
+			// else.
+			this->rembGenerator.MaySendLimitationRembFeedback(this->shared->GetTimeMs());
+		}
+
+		void ReceiverTransportCongestionController::OnRttUpdate(int64_t avgRttUs)
+		{
+			MS_TRACE();
+
+			switch (this->options.congestionControlType)
+			{
+				case Types::CongestionControlType::TRANSPORT_CC:
+				{
+					// Nothing is estimated here in this mode, so there is nothing the
+					// round trip time bounds.
+
+					break;
+				}
+
+				case Types::CongestionControlType::REMB:
+				{
+					this->remoteBitrateEstimator->OnRttUpdate(avgRttUs);
+
+					break;
+				}
+
+					NO_DEFAULT();
+			}
+		}
+
+		void ReceiverTransportCongestionController::RemoveStream(uint32_t ssrc)
+		{
+			MS_TRACE();
+
+			switch (this->options.congestionControlType)
+			{
+				case Types::CongestionControlType::TRANSPORT_CC:
+				{
+					// No stream is kept track of in this mode.
+
+					break;
+				}
+
+				case Types::CongestionControlType::REMB:
+				{
+					this->remoteBitrateEstimator->RemoveStream(ssrc);
+
+					break;
+				}
+
+					NO_DEFAULT();
+			}
+		}
+
+		void ReceiverTransportCongestionController::SetMaxIncomingBitrate(int64_t bitrate)
+		{
+			MS_TRACE();
+
+			// NOTE: Zero is how the application asks for no cap at all, while the
+			// generator expresses that as no value.
+			std::optional<int64_t> maxIncomingBitrate;
+
+			if (bitrate != 0)
+			{
+				maxIncomingBitrate = bitrate;
+			}
+
+			this->rembGenerator.SetMaxIncomingBitrate(this->shared->GetTimeMs(), maxIncomingBitrate);
+		}
+
+		std::optional<int64_t> ReceiverTransportCongestionController::GetAvailableBitrate() const
+		{
+			MS_TRACE();
+
+			switch (this->options.congestionControlType)
+			{
+				case Types::CongestionControlType::TRANSPORT_CC:
+				{
+					// The estimating is the remote sender's job in this mode.
+					return std::nullopt;
+				}
+
+				case Types::CongestionControlType::REMB:
+				{
+					const int64_t bitrate = this->remoteBitrateEstimator->GetLatestEstimate();
+
+					// NOTE: Zero is how the estimator says that it has nothing, either because
+					// no estimation is valid yet or because no stream is active. A measured
+					// bitrate never comes out as zero, since the rate control clamps it to the
+					// lowest it is configured with.
+					if (bitrate == 0)
+					{
+						return std::nullopt;
+					}
+
+					return bitrate;
+				}
+
+					NO_DEFAULT();
+			}
+		}
+
+		void ReceiverTransportCongestionController::OnTransportWideCcFeedbackGeneratorSendPacket(
+		  TransportWideCcFeedbackGenerator* /*transportWideCcFeedbackGenerator*/,
+		  RTC::RTCP::FeedbackRtpTransportPacket* packet)
+		{
+			MS_TRACE();
+
+			this->listener->OnReceiverTransportCongestionControllerSendRtcpPacket(this, packet);
+		}
+
+		void ReceiverTransportCongestionController::OnRemoteBitrateEstimatorAbsSendTimeBitrateChanged(
+		  RemoteBitrateEstimatorAbsSendTime* /*remoteBitrateEstimator*/,
+		  const std::vector<uint32_t>& ssrcs,
+		  int64_t bitrate)
+		{
+			MS_TRACE();
+
+			this->rembGenerator.OnReceiveBitrateChanged(this->shared->GetTimeMs(), ssrcs, bitrate);
+		}
+
+		void ReceiverTransportCongestionController::OnRembGeneratorSendPacket(
+		  RembGenerator* /*rembGenerator*/, RTC::RTCP::FeedbackPsRembPacket* packet)
+		{
+			MS_TRACE();
+
+			this->listener->OnReceiverTransportCongestionControllerSendRtcpPacket(this, packet);
+		}
+	} // namespace BWE
+} // namespace RTC

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

@@ -163,7 +163,7 @@ namespace RTC
 				packet.SetSsrcs(ssrcs);
 			}
 
-			this->listener->OnRembGeneratorSendRemb(this, std::addressof(packet));
+			this->listener->OnRembGeneratorSendPacket(this, std::addressof(packet));
 		}
 	} // namespace BWE
 } // namespace RTC

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

@@ -71,7 +71,7 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(
+		void RemoteBitrateEstimatorAbsSendTime::ReceiveRtpPacket(
 		  const RTC::RTP::Packet* packet, int64_t arrivalTimeUs, int64_t nowUs)
 		{
 			MS_TRACE();