mediasoup 3.28.0 → 3.29.0

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

@@ -90,11 +90,11 @@ namespace RTC
 			 * Feed what the delay based detector says about the network.
 			 *
 			 * @param input - State of the network plus the acknowledged bitrate.
-			 * @param atTimeUs - Time at which the input was produced.
+			 * @param nowUs - Current time.
 			 *
 			 * @returns The new target bitrate (bps).
 			 */
-			int64_t Update(const Types::RateControlInput& input, int64_t atTimeUs);
+			int64_t Update(const Types::RateControlInput& input, int64_t nowUs);
 
 			/**
 			 * Set the target bitrate from outside the rate control, for instance out of
@@ -102,7 +102,7 @@ namespace RTC
 			 *
 			 * @param bitrate - New target bitrate (bps).
 			 */
-			void SetEstimate(int64_t bitrate, int64_t atTimeUs);
+			void SetEstimate(int64_t bitrate, int64_t nowUs);
 
 			/**
 			 * @param startBitrate - Bitrate to start from (bps).
@@ -126,13 +126,13 @@ namespace RTC
 			 * below the current target. It's what keeps a single overuse from
 			 * collapsing the bitrate in a few milliseconds.
 			 */
-			bool IsTimeToReduceFurther(int64_t atTimeUs, int64_t estimatedThroughput) const;
+			bool IsTimeToReduceFurther(int64_t nowUs, int64_t estimatedThroughput) const;
 
 			/**
 			 * As above, to be used when overusing before any throughput has been
 			 * measured.
 			 */
-			bool IsInitialTimeToReduceFurther(int64_t atTimeUs) const;
+			bool IsInitialTimeToReduceFurther(int64_t nowUs) const;
 
 			/**
 			 * Rate at which the bitrate is increased once it's close to the capacity of
@@ -147,9 +147,9 @@ namespace RTC
 			int64_t GetFeedbackIntervalUs() const;
 
 		private:
-			void ChangeBitrate(const Types::RateControlInput& input, int64_t atTimeUs);
+			void ChangeBitrate(const Types::RateControlInput& input, int64_t nowUs);
 
-			void ChangeState(const Types::RateControlInput& input, int64_t atTimeUs);
+			void ChangeState(const Types::RateControlInput& input, int64_t nowUs);
 
 			/**
 			 * Apply the configured bounds to a candidate bitrate.
@@ -161,13 +161,13 @@ namespace RTC
 			 * fast to discover it.
 			 */
 			int64_t MultiplicativeRateIncrease(
-			  int64_t atTimeUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const;
+			  int64_t nowUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const;
 
 			/**
 			 * Increase used once the capacity of the link has been estimated, which
 			 * approaches it in small steps.
 			 */
-			int64_t AdditiveRateIncrease(int64_t atTimeUs, int64_t lastTimeUs) const;
+			int64_t AdditiveRateIncrease(int64_t nowUs, int64_t lastTimeUs) const;
 
 		private:
 			const AimdRateControlOptions options;

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

@@ -23,31 +23,42 @@ namespace RTC
 			constexpr int64_t TimeUsInfinite{ std::numeric_limits<int64_t>::max() };
 
 			/**
-			 * The two bits of the IP header with which the network tells that it is
-			 * congested instead of dropping the packet.
-			 *
-			 * @see https://www.rfc-editor.org/rfc/rfc9331.html
+			 * Which RTCP mechanism the two endpoints negotiated to deal with
+			 * congestion, which is what decides on which of them the estimation is
+			 * computed.
 			 */
-			enum class EcnMarking : uint8_t
+			enum class CongestionControlType : uint8_t
 			{
 				/**
-				 * Not ECN capable transport.
-				 */
-				NOT_ECT = 0b00,
-				/**
-				 * ECN capable transport, which is the one L4S uses.
-				 */
-				ECT1 = 0b01,
-				/**
-				 * ECN capable transport, not used by L4S.
+				 * The receiving endpoint reports when each packet arrived and the
+				 * sending one estimates from that.
 				 */
-				ECT0 = 0b10,
+				TRANSPORT_CC = 1,
 				/**
-				 * Congestion experienced, which is what the network sets on the way.
+				 * The receiving endpoint estimates and tells the sending one how much
+				 * it may send.
 				 */
-				CE = 0b11
+				REMB = 2
 			};
 
+			constexpr std::string_view congestionControlTypeToString(CongestionControlType congestionControlType)
+			{
+				switch (congestionControlType)
+				{
+					case CongestionControlType::TRANSPORT_CC:
+					{
+						return "TRANSPORT_CC";
+					}
+
+					case CongestionControlType::REMB:
+					{
+						return "REMB";
+					}
+
+						NO_DEFAULT();
+				}
+			}
+
 			/**
 			 * How the network is behaving according to the delay based detector.
 			 */
@@ -90,6 +101,32 @@ namespace RTC
 				}
 			}
 
+			/**
+			 * The two bits of the IP header with which the network tells that it is
+			 * congested instead of dropping the packet.
+			 *
+			 * @see https://www.rfc-editor.org/rfc/rfc9331.html
+			 */
+			enum class EcnMarking : uint8_t
+			{
+				/**
+				 * Not ECN capable transport.
+				 */
+				NOT_ECT = 0b00,
+				/**
+				 * ECN capable transport, which is the one L4S uses.
+				 */
+				ECT1 = 0b01,
+				/**
+				 * ECN capable transport, not used by L4S.
+				 */
+				ECT0 = 0b10,
+				/**
+				 * Congestion experienced, which is what the network sets on the way.
+				 */
+				CE = 0b11
+			};
+
 			/**
 			 * Estimate of the capacity of the link, used to bound the rate control.
 			 */

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

@@ -138,20 +138,20 @@ namespace RTC
 			}
 
 		private:
-			void IncomingPacketFeedback(const Types::PacketResult& packetResult, int64_t atTimeUs);
+			void IncomingPacketFeedback(const Types::PacketResult& packetResult, int64_t nowUs);
 
 			Result MaybeUpdateEstimate(
 			  std::optional<int64_t> ackedBitrate,
 			  std::optional<int64_t> probeBitrate,
 			  bool recoveredFromOveruse,
-			  int64_t atTimeUs);
+			  int64_t nowUs);
 
 			/**
 			 * Recompute the target bitrate.
 			 *
 			 * @returns Whether there is a valid estimate.
 			 */
-			bool UpdateEstimate(int64_t atTimeUs, std::optional<int64_t> ackedBitrate, int64_t& targetBitrate);
+			bool UpdateEstimate(int64_t nowUs, std::optional<int64_t> ackedBitrate, int64_t& targetBitrate);
 
 		private:
 			const DelayBasedBweOptions options;

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

@@ -33,14 +33,14 @@ namespace RTC
 			explicit FeedbackAdapter(SendPacketHistory* sendPacketHistory);
 
 			/**
-			 * Process a transport-cc feedback.
+			 * Process a transport wide cc feedback.
 			 *
 			 * @param receivedAtUs - Time at which the feedback was received.
 			 * @returns What the feedback reports about the packets that were sent, in
 			 *   the order it reports them, or no value if it reports on no packet the
 			 *   history still holds.
 			 */
-			std::optional<Types::TransportPacketsFeedback> ProcessTransportFeedback(
+			std::optional<Types::TransportPacketsFeedback> ProcessTransportWideCcFeedback(
 			  const RTCP::FeedbackRtpTransportPacket* feedback, int64_t receivedAtUs);
 
 		private:

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

@@ -594,10 +594,10 @@ namespace RTC
 			std::vector<double> temporalWeights;
 			// The same, for the average observed loss.
 			std::vector<double> immediateUpperBoundTemporalWeights;
-			struct PartialObservation partialObservation;
-			struct ChannelParameters currentBestEstimate;
-			struct HoldInfo lastHoldInfo;
-			struct Result result;
+			PartialObservation partialObservation;
+			ChannelParameters currentBestEstimate;
+			HoldInfo lastHoldInfo;
+			Result result;
 			// Observations closed so far, which never decreases and hence also gives
 			// the id of the next one.
 			int64_t numObservations{ 0 };

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

@@ -40,12 +40,13 @@ namespace RTC
 			 * @param sendDeltaMs - Time between the send times of both groups, which
 			 *   is how long this sample is worth.
 			 * @param numOfDeltas - Number of samples that offset is based on.
-			 * @param nowUs - Current time.
+			 * @param arrivalTimeUs - Instant the packet that produced this sample
+			 *   arrived.
 			 *
 			 * @returns What the network is taken to be doing after this sample.
 			 */
 			Types::BandwidthUsage Detect(
-			  double offsetMs, double sendDeltaMs, int64_t numOfDeltas, int64_t nowUs);
+			  double offsetMs, double sendDeltaMs, int64_t numOfDeltas, int64_t arrivalTimeUs);
 
 			Types::BandwidthUsage GetState() const
 			{
@@ -53,11 +54,11 @@ namespace RTC
 			}
 
 		private:
-			void UpdateThreshold(double modifiedOffsetMs, int64_t nowUs);
+			void UpdateThreshold(double modifiedOffsetMs, int64_t arrivalTimeUs);
 
 		private:
 			double threshold{ 12.5 };
-			std::optional<int64_t> lastThresholdUpdateAtUs;
+			std::optional<int64_t> lastSampleArrivalTimeUs;
 			double prevOffsetMs{ 0.0 };
 			// How long the trend has been above the threshold, or no value while it
 			// isn't.

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

@@ -70,7 +70,7 @@ namespace RTC
 			 * Forget the bursts whose last packet arrived long enough ago that they
 			 * cannot receive anything else.
 			 */
-			void EraseOldClusters(int64_t nowUs);
+			void EraseOldClusters(int64_t arrivalTimeUs);
 
 		private:
 			// Bursts being gathered, by their id. Nothing looks at them in any

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

@@ -108,6 +108,12 @@ namespace RTC
 				 *   over to decide how many bytes each of its shots carries.
 				 */
 				int64_t initialMinProbeDeltaUs{ 20 * 1000 };
+				/**
+				 * Whether bursts keep being sent while the sender is not filling the
+				 * link, which is the only way the estimate grows when the traffic
+				 * itself is not enough to measure with.
+				 */
+				bool enablePeriodicAlrProbing{ false };
 				/**
 				 * How often to probe while the sender is not filling the link.
 				 */
@@ -258,11 +264,6 @@ namespace RTC
 			[[nodiscard]] std::vector<Types::ProbeClusterConfig> SetEstimatedBitrate(
 			  int64_t bitrate, BandwidthLimitedCause bandwidthLimitedCause, int64_t nowUs);
 
-			void EnablePeriodicAlrProbing(bool enable)
-			{
-				this->enablePeriodicAlrProbing = enable;
-			}
-
 			/**
 			 * Whether the initial bursts keep being repeated for a while, which only
 			 * makes sense until there is traffic of its own to measure.
@@ -347,7 +348,6 @@ namespace RTC
 			State state{ State::INIT };
 			bool networkAvailable{ false };
 			bool repeatedInitialProbingEnabled{ false };
-			bool enablePeriodicAlrProbing{ false };
 			BandwidthLimitedCause bandwidthLimitedCause{ BandwidthLimitedCause::DELAY_BASED_LIMITED };
 			// Instant until which the initial bursts keep being repeated.
 			std::optional<int64_t> lastAllowedRepeatedInitialProbeAtUs;

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

@@ -34,9 +34,6 @@ namespace RTC
 				/**
 				 * A packet of the burst is ready.
 				 *
-				 * @returns Whether the rest of the burst is still wanted, so that a
-				 * packet that couldn't be sent stops the ones behind it.
-				 *
 				 * @remarks
 				 * - The packet must be sent before returning, since the next one is
 				 *   built over the very same instance.
@@ -46,10 +43,9 @@ namespace RTC
 				 * - Whoever measures the burst has to be told how much of it went out,
 				 *   so the length of the packet is reported from here as well.
 				 * - This must not destroy the `ProbePacketGenerator`, not even
-				 *   indirectly. It goes on reading its own members after this returns,
-				 *   so returning false is no way out of it either.
+				 *   indirectly. It goes on reading its own members after this returns.
 				 */
-				virtual bool OnProbePacketGeneratorSendRtpPacket(
+				virtual void OnProbePacketGeneratorSendRtpPacket(
 				  ProbePacketGenerator* probePacketGenerator, RTC::RTP::Packet* packet) = 0;
 			};
 

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

@@ -48,9 +48,6 @@ namespace RTC
 				/**
 				 * A packet of the burst is ready to go out.
 				 *
-				 * @returns Whether the rest of the burst is still wanted, so that a
-				 * packet that couldn't be sent stops the ones behind it.
-				 *
 				 * @remarks
 				 * - The packet must be sent before returning, since the next one is
 				 *   built over the very same instance.
@@ -58,10 +55,9 @@ namespace RTC
 				 *   sequence number but no value for either, so both have to be written
 				 *   here.
 				 * - This must not destroy the `ProbingScheduler`, not even indirectly.
-				 *   It goes on reading its own members after this returns, so
-				 *   returning false is no way out of it either.
+				 *   It goes on reading its own members after this returns.
 				 */
-				virtual bool OnProbingSchedulerSendRtpPacket(
+				virtual void OnProbingSchedulerSendRtpPacket(
 				  ProbingScheduler* probingScheduler,
 				  RTC::RTP::Packet* packet,
 				  const Types::ProbeCluster& probeCluster) = 0;
@@ -133,7 +129,7 @@ namespace RTC
 
 			/* Pure virtual methods inherited from RTC::BWE::ProbePacketGenerator::Listener. */
 		public:
-			bool OnProbePacketGeneratorSendRtpPacket(
+			void OnProbePacketGeneratorSendRtpPacket(
 			  ProbePacketGenerator* probePacketGenerator, RTC::RTP::Packet* packet) override;
 
 			/* Pure virtual methods inherited from TimerHandleInterface::Listener. */

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

@@ -0,0 +1,148 @@
+#ifndef MS_RTC_BWE_RECEIVER_TRANSPORT_CONGESTION_CONTROLLER_HPP
+#define MS_RTC_BWE_RECEIVER_TRANSPORT_CONGESTION_CONTROLLER_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include "RTC/BWE/RembGenerator.hpp"
+#include "RTC/BWE/RemoteBitrateEstimatorAbsSendTime.hpp"
+#include "RTC/BWE/TransportWideCcFeedbackGenerator.hpp"
+#include "RTC/Consts.hpp"
+#include "RTC/RTCP/Packet.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "RTC/RtpDictionaries.hpp"
+#include "SharedInterface.hpp"
+#include <vector>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Everything the receiving side of a transport does about congestion, which
+		 * amounts to telling the remote sender how much it may send towards us.
+		 *
+		 * How that is said depends on what both endpoints negotiated. With
+		 * transport-cc nothing is estimated here: the instant each packet arrived is
+		 * reported back and the remote sender does the estimating. With REMB it is
+		 * the other way round, and a bitrate is computed here and announced.
+		 *
+		 * The cap the application sets is announced as a REMB either way, since that
+		 * is the only way to tell a remote sender to hold back.
+		 */
+		class ReceiverTransportCongestionController : public TransportWideCcFeedbackGenerator::Listener,
+		                                              public RemoteBitrateEstimatorAbsSendTime::Listener,
+		                                              public RembGenerator::Listener
+		{
+		public:
+			class Listener
+			{
+			public:
+				virtual ~Listener() = default;
+
+			public:
+				/**
+				 * An RTCP packet is ready for the remote sender.
+				 *
+				 * @param packet - Packet to send. It belongs to the caller, so the
+				 *   listener must neither destroy it nor keep it around after this call
+				 *   returns.
+				 */
+				virtual void OnReceiverTransportCongestionControllerSendRtcpPacket(
+				  ReceiverTransportCongestionController* receiverTransportCongestionControl,
+				  RTC::RTCP::Packet* packet) = 0;
+			};
+
+			struct ReceiverTransportCongestionControllerOptions
+			{
+				/**
+				 * Mechanism both endpoints negotiated, which decides what is done with
+				 * every packet that comes in.
+				 */
+				Types::CongestionControlType congestionControlType;
+				/**
+				 * Largest an RTCP packet may be on this transport (bytes).
+				 */
+				size_t maxRtcpPacketLen{ RTC::Consts::RtcpPacketMaxSize };
+			};
+
+		public:
+			ReceiverTransportCongestionController(
+			  Listener* listener,
+			  SharedInterface* shared,
+			  ReceiverTransportCongestionControllerOptions options);
+
+			~ReceiverTransportCongestionController() override = default;
+
+			ReceiverTransportCongestionController(const ReceiverTransportCongestionController&) = delete;
+			ReceiverTransportCongestionController& operator=(
+			  const ReceiverTransportCongestionController&) = delete;
+
+			/**
+			 * Feed a received RTP packet.
+			 *
+			 * @param receivedAtUs - Instant the packet arrived.
+			 * @param kind - Media the stream the packet belongs to carries.
+			 */
+			void ReceiveRtpPacket(int64_t receivedAtUs, const RTC::RTP::Packet* packet, RTC::Media::Kind kind);
+
+			/**
+			 * Feed the round trip time towards the remote senders, which bounds how
+			 * often the estimation of the incoming link may be reduced.
+			 */
+			void OnRttUpdate(int64_t avgRttUs);
+
+			/**
+			 * Forget a stream, so that it no longer takes part in the estimation of
+			 * the incoming link nor in the streams the remote sender is told about.
+			 */
+			void RemoveStream(uint32_t ssrc);
+
+			/**
+			 * Cap what the remote sender is told it may send (bps), or zero to let it
+			 * send whatever the incoming link is estimated to bear.
+			 */
+			void SetMaxIncomingBitrate(int64_t bitrate);
+
+			/**
+			 * Latest estimation of the incoming link (bps), or no value while there is
+			 * none and whenever the estimating is the remote sender's job.
+			 */
+			std::optional<int64_t> GetAvailableBitrate() const;
+
+			/* Pure virtual methods inherited from TransportWideCcFeedbackGenerator::Listener. */
+		public:
+			void OnTransportWideCcFeedbackGeneratorSendPacket(
+			  TransportWideCcFeedbackGenerator* transportWideCcFeedbackGenerator,
+			  RTC::RTCP::FeedbackRtpTransportPacket* packet) override;
+
+			/* Pure virtual methods inherited from RemoteBitrateEstimatorAbsSendTime::Listener. */
+		public:
+			void OnRemoteBitrateEstimatorAbsSendTimeBitrateChanged(
+			  RemoteBitrateEstimatorAbsSendTime* remoteBitrateEstimator,
+			  const std::vector<uint32_t>& ssrcs,
+			  int64_t bitrate) override;
+
+			/* Pure virtual methods inherited from RembGenerator::Listener. */
+		public:
+			void OnRembGeneratorSendPacket(
+			  RembGenerator* rembGenerator, RTC::RTCP::FeedbackPsRembPacket* packet) override;
+
+		private:
+			const ReceiverTransportCongestionControllerOptions options;
+
+			// Passed by argument.
+			Listener* listener{ nullptr };
+			SharedInterface* shared{ nullptr };
+			// Allocated by this, the first one only in transport-cc mode and the
+			// second one only in REMB mode.
+			std::unique_ptr<TransportWideCcFeedbackGenerator> transportWideCcFeedbackGenerator;
+			std::unique_ptr<RemoteBitrateEstimatorAbsSendTime> remoteBitrateEstimator;
+			// Others.
+			// It lives in both modes, since the cap is announced as a REMB whatever
+			// was negotiated.
+			RembGenerator rembGenerator;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

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

@@ -27,10 +27,11 @@ namespace RTC
 				/**
 				 * A REMB packet is ready for the remote sender.
 				 *
-				 * @param packet - Packet to send, only valid for the duration of this
-				 *   call.
+				 * @param packet - Packet to send. It belongs to the caller, so the
+				 *   listener must neither destroy it nor keep it around after this call
+				 *   returns.
 				 */
-				virtual void OnRembGeneratorSendRemb(
+				virtual void OnRembGeneratorSendPacket(
 				  RembGenerator* rembGenerator, RTC::RTCP::FeedbackPsRembPacket* packet) = 0;
 			};
 

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

@@ -144,7 +144,7 @@ namespace RTC
 			 * @param nowUs - Current instant, which is not the one above when packets
 			 *   are processed in batches.
 			 */
-			void IncomingPacket(const RTC::RTP::Packet* packet, int64_t arrivalTimeUs, int64_t nowUs);
+			void ReceiveRtpPacket(const RTC::RTP::Packet* packet, int64_t arrivalTimeUs, int64_t nowUs);
 
 			/**
 			 * Feed the round trip time towards the senders, which bounds how often the