mediasoup 3.26.0 → 3.27.0

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

@@ -0,0 +1,94 @@
+#ifndef MS_RTC_BWE_ROBUST_THROUGHPUT_ESTIMATOR_HPP
+#define MS_RTC_BWE_ROBUST_THROUGHPUT_ESTIMATOR_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/AcknowledgedBitrateEstimatorInterface.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include <deque>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Measures the acknowledged bitrate over a sliding window of the packets the
+		 * receiver reported.
+		 *
+		 * The estimate is the smaller of the send rate and the receive rate observed
+		 * over that window, so that it never claims more than what was actually put
+		 * on the wire. The largest gap between arrivals is replaced by the second
+		 * largest one before dividing, which is what keeps a short pause followed by
+		 * a burst of delayed packets from collapsing the estimate.
+		 */
+		class RobustThroughputEstimator : public AcknowledgedBitrateEstimatorInterface
+		{
+		public:
+			struct RobustThroughputEstimatorOptions
+			{
+				/**
+				 * Smallest number of packets the window holds.
+				 */
+				size_t windowPackets{ 20 };
+				/**
+				 * Largest number of packets the window holds, so that a high bitrate
+				 * doesn't make it grow without bound.
+				 */
+				size_t maxWindowPackets{ 500 };
+				/**
+				 * Smallest duration the window covers, so that a low bitrate still gets
+				 * enough packets to measure.
+				 */
+				int64_t minWindowDurationUs{ 1000 * 1000 };
+				/**
+				 * Largest duration the window covers, so that very old packets don't
+				 * weigh on the estimate after sending was paused.
+				 */
+				int64_t maxWindowDurationUs{ 5 * 1000 * 1000 };
+				/**
+				 * Number of packets the window needs before it produces an estimate.
+				 */
+				size_t requiredPackets{ 10 };
+				/**
+				 * Weight given to the data that was sent but is not covered by any
+				 * feedback.
+				 *
+				 * @remarks
+				 * - Set it to 0 when audio is not included in the allocation, and to 1
+				 *   when it is included in the allocation but not in the estimation.
+				 *   Its value is irrelevant once every packet is tracked.
+				 */
+				double unackedWeight{ 1.0 };
+			};
+
+		public:
+			RobustThroughputEstimator();
+
+			explicit RobustThroughputEstimator(RobustThroughputEstimatorOptions options);
+
+			void IncomingPacketFeedbackVector(const std::vector<Types::PacketResult>& packetResults) override;
+
+			std::optional<int64_t> GetBitrate() const override;
+
+			void SetAlr(bool /*inAlr*/) override
+			{
+			}
+
+			void SetAlrEndedTimeUs(int64_t /*alrEndedTimeUs*/) override
+			{
+			}
+
+		private:
+			/**
+			 * Whether the oldest packet of the window no longer belongs to it.
+			 */
+			bool IsFirstPacketOutsideWindow() const;
+
+		private:
+			const RobustThroughputEstimatorOptions options;
+			std::deque<Types::PacketResult> window;
+			std::optional<int64_t> latestDiscardedSendTimeUs;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

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

@@ -0,0 +1,137 @@
+#ifndef MS_RTC_BWE_SEND_PACKET_HISTORY_HPP
+#define MS_RTC_BWE_SEND_PACKET_HISTORY_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include <map>
+#include <tuple>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Holds every packet that was sent until a feedback reports on it.
+		 *
+		 * Packets are indexed by a sequence number of its own, handed out by this
+		 * history, so that nothing about how a feedback identifies a packet leaks
+		 * in here. Each packet also keeps its SSRC and RTP sequence number, which
+		 * is what allows a feedback that identifies packets that way to be resolved
+		 * against this very same history.
+		 *
+		 * It also tracks how many bytes are in flight, which are those that were
+		 * sent and no feedback has reported on yet.
+		 *
+		 * @see https://datatracker.ietf.org/doc/html/draft-holmer-rmcat-transport-wide-cc-extensions
+		 * @see https://datatracker.ietf.org/doc/html/rfc8888
+		 */
+		class SendPacketHistory
+		{
+		public:
+			struct SendPacketHistoryOptions
+			{
+				/**
+				 * Time a packet is kept for, beyond which a feedback reporting on it
+				 * arrives too late to be of any use.
+				 */
+				int64_t windowDurationUs{ 60 * 1000 * 1000 };
+			};
+
+		private:
+			struct SentPacketEntry
+			{
+				Types::SentPacket sentPacket;
+				uint32_t ssrc{ 0 };
+				uint16_t seq{ 0 };
+			};
+
+			struct SsrcAndSeq
+			{
+				bool operator<(const SsrcAndSeq& other) const
+				{
+					return std::tie(this->ssrc, this->seq) < std::tie(other.ssrc, other.seq);
+				}
+
+				uint32_t ssrc{ 0 };
+				uint16_t seq{ 0 };
+			};
+
+		public:
+			SendPacketHistory();
+
+			explicit SendPacketHistory(SendPacketHistoryOptions options);
+
+			/**
+			 * Take note of a packet that has just been sent.
+			 *
+			 * @param size - Size of the packet including overhead up to the IP layer
+			 *   (bytes).
+			 * @param audio - Whether it's an audio packet. False for video, padding
+			 *   and RTX.
+			 * @returns The sequence number given to the packet, which is what a
+			 *   feedback has to be resolved into.
+			 */
+			int64_t AddPacket(uint32_t ssrc, uint16_t seq, size_t size, bool audio, int64_t sentAtUs);
+
+			/**
+			 * Resolve what a feedback reported about a single packet.
+			 *
+			 * @param received - Whether the feedback reported the packet as received.
+			 * @returns The packet as it was sent, or no value if this history doesn't
+			 *   hold it anymore.
+			 *
+			 * @remarks
+			 * - Every packet up to the given one stops counting as in flight, since
+			 *   the feedback settles whether it arrived or not.
+			 * - A packet reported as received is dropped, while one reported as lost
+			 *   is kept, since a later feedback may still report it as received.
+			 */
+			std::optional<Types::SentPacket> RetrievePacket(int64_t sequenceNumber, bool received);
+
+			/**
+			 * Same, for a feedback that identifies the packet by its SSRC and RTP
+			 * sequence number rather than by the sequence number given to it.
+			 */
+			std::optional<Types::SentPacket> RetrievePacket(uint32_t ssrc, uint16_t seq, bool received);
+
+			/**
+			 * Sequence number this history gave to the latest packet added, or no
+			 * value if no packet was ever added.
+			 *
+			 * @remarks
+			 * - It's the sequence number of this history, not the RTP one, so it
+			 *   never wraps around. It's also the highest a feedback carrying only
+			 *   the lowest bits of it can possibly stand for.
+			 */
+			std::optional<int64_t> GetLastSequenceNumber() const;
+
+			/**
+			 * Bytes that were sent and no feedback has reported on yet.
+			 */
+			size_t GetOutstandingBytes() const
+			{
+				return this->outstandingBytes;
+			}
+
+		private:
+			void RemoveOutstandingBytes(const SentPacketEntry& entry);
+
+			/**
+			 * Drop the mapping of a packet, unless the same SSRC and RTP sequence
+			 * number were sent again afterwards and hence took it over.
+			 */
+			void RemoveSsrcAndSeq(const SentPacketEntry& entry);
+
+		private:
+			const SendPacketHistoryOptions options;
+			std::map<int64_t, SentPacketEntry> history;
+			std::map<SsrcAndSeq, int64_t> ssrcAndSeqToSequenceNumber;
+			int64_t nextSequenceNumber{ 0 };
+			// Sequence numbers are never negative, so this sits below all of them.
+			int64_t lastAckSequenceNumber{ -1 };
+			size_t outstandingBytes{ 0 };
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

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

@@ -0,0 +1,101 @@
+#ifndef MS_RTC_BWE_TRENDLINE_ESTIMATOR_HPP
+#define MS_RTC_BWE_TRENDLINE_ESTIMATOR_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include <deque>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Detects network congestion from the delay between groups of packets,
+		 * before any packet is lost.
+		 *
+		 * For each pair of consecutive groups it accumulates `arrivalDelta -
+		 * sendDelta`, smooths it, and fits a least squares line over the last
+		 * `WindowSize` samples. The slope of that line approximates
+		 * `(sendRate - capacity) / capacity`, so a positive slope means that queues
+		 * are filling up somewhere in the network.
+		 *
+		 * That slope is compared against a threshold that adapts itself to the
+		 * observed noise, and overuse is only declared once the condition persists,
+		 * which is what prevents an isolated jitter spike from bringing the estimate
+		 * down.
+		 */
+		class TrendlineEstimator
+		{
+		private:
+			struct PacketTiming
+			{
+				double arrivalTimeUs;
+				double smoothedDelayUs;
+			};
+
+		public:
+			/**
+			 * Number of samples of the least squares regression window used unless
+			 * another one is given.
+			 */
+			static constexpr size_t DefaultWindowSize{ 20 };
+
+		public:
+			/**
+			 * @param windowSize - Number of samples of the least squares regression
+			 *   window. A shorter window reacts sooner at the cost of being noisier.
+			 *
+			 * @remarks
+			 * - `windowSize` must be at least 2, since a line cannot be fitted to a
+			 *   single point.
+			 */
+			explicit TrendlineEstimator(size_t windowSize = DefaultWindowSize);
+
+			/**
+			 * Feed the deltas between two consecutive groups of packets.
+			 *
+			 * @param sendDeltaUs - Time elapsed between the send times of both groups.
+			 * @param arrivalDeltaUs - Time elapsed between the arrival times of both
+			 *   groups.
+			 * @param arrivalTimeUs - Arrival time of the latest group, in the remote
+			 *   clock reference.
+			 */
+			void Update(int64_t sendDeltaUs, int64_t arrivalDeltaUs, int64_t arrivalTimeUs);
+
+			/**
+			 * Current hypothesis about how the network is behaving.
+			 */
+			Types::BandwidthUsage GetState() const
+			{
+				return this->state;
+			}
+
+		private:
+			/**
+			 * Slope of the least squares line fitted to the samples window, or no
+			 * value if it cannot be computed.
+			 */
+			std::optional<double> GetLinearFitSlope() const;
+
+			void Detect(double trend, double sendDeltaUs, int64_t arrivalTimeUs);
+
+			void UpdateThreshold(double modifiedTrend, int64_t arrivalTimeUs);
+
+		private:
+			const size_t windowSize;
+			int numOfDeltas{ 0 };
+			std::optional<int64_t> firstArrivalTimeUs;
+			double accumulatedDelayUs{ 0 };
+			double smoothedDelayUs{ 0 };
+			std::deque<PacketTiming> delayHist;
+			double threshold{ 12.5 };
+			double prevTrend{ 0 };
+			std::optional<double> timeOverUsingUs;
+			int overuseCounter{ 0 };
+			std::optional<int64_t> lastThresholdUpdateAtUs;
+			Types::BandwidthUsage state{ Types::BandwidthUsage::NORMAL };
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

package/worker/include/RTC/Consts.hpp

@@ -10,7 +10,7 @@ namespace RTC
 		/**
 		 * Max MTU size.
 		 */
-		constexpr size_t MtuSize{ 1500u };
+		constexpr size_t MtuSize{ 1500 };
 
 		/**
 		 * Maximum size for a RTCP compound packet.
@@ -21,23 +21,23 @@ namespace RTC
 		 *     be added to an RTCP packet by srtp_protect_rtcp().
 		 *   - srtp.h: SRTP_MAX_TRAILER_LEN (SRTP_MAX_TAG_LEN + SRTP_MAX_MKI_LEN).
 		 */
-		constexpr size_t RtcpPacketMaxSize{ RTC::Consts::MtuSize - 40 - 20 - 148u };
+		constexpr size_t RtcpPacketMaxSize{ RTC::Consts::MtuSize - 40 - 20 - 148 };
 
 		/**
 		 * Max length for a 1 byte RTP header extension.
 		 */
-		constexpr uint8_t OneByteRtpExtensionMaxLength{ 16u };
+		constexpr uint8_t OneByteRtpExtensionMaxLength{ 16 };
 
 		/**
 		 * Max length for a 2 bytes RTP header extension.
 		 */
-		constexpr uint8_t TwoBytesRtpExtensionMaxLength{ 255u };
+		constexpr uint8_t TwoBytesRtpExtensionMaxLength{ 255 };
 
 		/**
 		 * MID RTP header extension max length (just used when setting/updating MID
 		 * extension).
 		 */
-		constexpr uint8_t MidRtpExtensionMaxLength{ 8u };
+		constexpr uint8_t MidRtpExtensionMaxLength{ 8 };
 
 		/**
 		 * Largest safe SCTP packet. Starting from the minimum guaranteed MTU value
@@ -59,7 +59,7 @@ namespace RTC
 		 * @remarks
 		 * Value copied from dcSCTP library.
 		 */
-		constexpr size_t MaxSafeMtuSizeForSctp{ 1191u };
+		constexpr size_t MaxSafeMtuSizeForSctp{ 1191 };
 	} // namespace Consts
 } // namespace RTC
 

package/worker/include/RTC/Consumer.hpp

@@ -18,7 +18,6 @@
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include "RTC/SeqManager.hpp"
-#include "Shared.hpp"
 #include "SharedInterface.hpp"
 #include <ankerl/unordered_dense.h>
 #include <bitset>
@@ -134,6 +133,8 @@ namespace RTC
 		void ProducerRtpStreamScores(const std::vector<uint8_t>* scores);
 		void ProducerRtpStreamScore(RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore);
 		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first);
+		void ProducerSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive);
 		void ProducerClosed();
 		void SetExternallyManagedBitrate()
 		{
@@ -141,21 +142,22 @@ namespace RTC
 			this->producerStreamManager->SetExternallyManagedBitrate();
 		}
 		uint8_t GetBitratePriority() const;
-		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss);
+		int64_t IncreaseLayer(int64_t bitrate, bool considerLoss);
 		void ApplyLayers();
-		uint32_t GetDesiredBitrate() const;
+		int64_t GetDesiredBitrate() const;
 		void SendRtpPacket(RTC::RTP::Packet* packet, RTC::RTP::SharedPacket& sharedPacket);
-		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs);
+		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, int64_t nowUs);
 		/**
 		 * Worst remote fraction lost among the RTP streams of this Consumer.
 		 */
 		uint8_t GetWorstRemoteFractionLost(uint32_t mappedSsrc) const;
 		void ReceiveNack(RTC::RTCP::FeedbackRtpNackPacket* nackPacket);
 		void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType, uint32_t ssrc);
-		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
-		void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report);
-		uint32_t GetTransmissionRate(uint64_t nowMs);
-		float GetRtt() const;
+		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs);
+		void ReceiveRtcpXrReceiverReferenceTime(
+		  RTC::RTCP::ReceiverReferenceTime* report, int64_t receivedAtUs);
+		int64_t GetTransmissionRate(int64_t nowMs);
+		float GetRttMs() const;
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
 	public:
@@ -215,11 +217,11 @@ namespace RTC
 		struct RTC::RTP::HeaderExtensionIds rtpHeaderExtensionIds;
 		const std::vector<uint8_t>* producerRtpStreamScores{ nullptr };
 		// Others.
-		std::bitset<128u> supportedCodecPayloadTypes;
-		uint64_t lastRtcpSentTime{ 0u };
-		uint16_t maxRtcpInterval{ 0u };
+		std::bitset<128> supportedCodecPayloadTypes;
+		int64_t lastRtcpSentAtUs{ 0 };
+		int64_t maxRtcpIntervalMs{ 0 };
 		bool externallyManagedBitrate{ false };
-		uint8_t priority{ 1u };
+		uint8_t priority{ 1 };
 		struct TraceEventTypes traceEventTypes;
 
 	private:

package/worker/include/RTC/DataConsumer.hpp

@@ -125,7 +125,7 @@ namespace RTC
 		// Passed by argument.
 		SharedInterface* shared{ nullptr };
 		RTC::DataConsumer::Listener* listener{ nullptr };
-		size_t maxMessageSize{ 0u };
+		size_t maxMessageSize{ 0 };
 		bool pipe{ false };
 		// Others.
 		Type type;
@@ -137,8 +137,8 @@ namespace RTC
 		bool paused{ false };
 		bool dataProducerPaused{ false };
 		bool dataProducerClosed{ false };
-		size_t messagesSent{ 0u };
-		size_t bytesSent{ 0u };
+		size_t messagesSent{ 0 };
+		size_t bytesSent{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/DataProducer.hpp

@@ -87,7 +87,7 @@ namespace RTC
 	private:
 		// Passed by argument.
 		SharedInterface* shared{ nullptr };
-		size_t maxMessageSize{ 0u };
+		size_t maxMessageSize{ 0 };
 		RTC::DataProducer::Listener* listener{ nullptr };
 		// Others.
 		Type type;
@@ -95,8 +95,8 @@ namespace RTC
 		std::string label;
 		std::string protocol;
 		bool paused{ false };
-		size_t messagesReceived{ 0u };
-		size_t bytesReceived{ 0u };
+		size_t messagesReceived{ 0 };
+		size_t bytesReceived{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/DtlsTransport.hpp

@@ -91,7 +91,10 @@ namespace RTC
 			  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) = 0;
 			// DTLS application data received.
 			virtual void OnDtlsTransportApplicationDataReceived(
-			  const RTC::DtlsTransport* dtlsTransport, const uint8_t* data, size_t len) = 0;
+			  const RTC::DtlsTransport* dtlsTransport,
+			  const uint8_t* data,
+			  size_t len,
+			  int64_t receivedAtUs) = 0;
 		};
 
 	public:
@@ -143,7 +146,7 @@ namespace RTC
 		void Dump(int indentation = 0) const;
 		void Run(Role localRole);
 		bool SetRemoteFingerprint(const Fingerprint& fingerprint);
-		void ProcessDtlsData(const uint8_t* data, size_t len);
+		void ProcessDtlsData(const uint8_t* data, size_t len, int64_t receivedAtUs);
 		DtlsState GetState() const
 		{
 			return this->state;

package/worker/include/RTC/ICE/IceCandidate.hpp

@@ -80,10 +80,10 @@ namespace RTC
 		private:
 			// Others.
 			std::string foundation;
-			uint32_t priority{ 0u };
+			uint32_t priority{ 0 };
 			std::string address;
 			Protocol protocol;
-			uint16_t port{ 0u };
+			uint16_t port{ 0 };
 			CandidateType type{ CandidateType::HOST };
 			TcpCandidateType tcpType{ TcpCandidateType::PASSIVE };
 		};

package/worker/include/RTC/ICE/IceServer.hpp

@@ -121,7 +121,7 @@ namespace RTC
 			void SetSelectedTuple(RTC::TransportTuple* storedTuple);
 			bool IsConsentCheckSupported() const
 			{
-				return this->consentTimeoutMs != 0u;
+				return this->consentTimeoutMs != 0;
 			}
 			bool IsConsentCheckRunning() const
 			{
@@ -141,12 +141,12 @@ namespace RTC
 			SharedInterface* shared{ nullptr };
 			std::string usernameFragment;
 			std::string password;
-			uint16_t consentTimeoutMs{ 30000u };
+			int64_t consentTimeoutMs{ 30000 };
 			// Others.
 			std::string oldUsernameFragment;
 			std::string oldPassword;
 			IceState state{ IceState::NEW };
-			uint32_t remoteNomination{ 0u };
+			uint32_t remoteNomination{ 0 };
 			std::list<RTC::TransportTuple> tuples;
 			RTC::TransportTuple* selectedTuple{ nullptr };
 			TimerHandleInterface* consentCheckTimer{ nullptr };

package/worker/include/RTC/KeyFrameRequestManager.hpp

@@ -64,7 +64,7 @@ namespace RTC
 		};
 
 	public:
-		KeyFrameRequestDelayer(Listener* listener, SharedInterface* shared, uint32_t ssrc, uint32_t delay);
+		KeyFrameRequestDelayer(Listener* listener, SharedInterface* shared, uint32_t ssrc, int64_t delayMs);
 		~KeyFrameRequestDelayer() override;
 
 		uint32_t GetSsrc() const
@@ -106,7 +106,7 @@ namespace RTC
 
 	public:
 		explicit KeyFrameRequestManager(
-		  Listener* listener, SharedInterface* shared, uint32_t keyFrameRequestDelay);
+		  Listener* listener, SharedInterface* shared, int64_t keyFrameRequestDelayMs);
 		~KeyFrameRequestManager() override;
 
 		void KeyFrameNeeded(uint32_t ssrc);
@@ -124,7 +124,7 @@ namespace RTC
 	private:
 		Listener* listener{ nullptr };
 		SharedInterface* shared{ nullptr };
-		uint32_t keyFrameRequestDelay{ 0u }; // 0 means disabled.
+		int64_t keyFrameRequestDelayMs{ 0 }; // 0 means disabled.
 		ankerl::unordered_dense::map<uint32_t, PendingKeyFrameInfo*> mapSsrcPendingKeyFrameInfo;
 		ankerl::unordered_dense::map<uint32_t, KeyFrameRequestDelayer*> mapSsrcKeyFrameRequestDelayer;
 	};

package/worker/include/RTC/NEW_RTCP/packet/Packet.hpp

@@ -321,7 +321,7 @@ namespace RTC
 			{
 				if (!HasVariableLengthValue())
 				{
-					return 0u;
+					return 0;
 				}
 
 				return GetLengthFieldComputed() - Packet::CommonHeaderLength;

package/worker/include/RTC/NackGenerator.hpp

@@ -28,16 +28,16 @@ namespace RTC
 	private:
 		struct NackInfo
 		{
-			explicit NackInfo(uint64_t createdAtMs, uint16_t seq, uint16_t sendAtSeq)
+			explicit NackInfo(int64_t createdAtMs, uint16_t seq, uint16_t sendAtSeq)
 			  : createdAtMs(createdAtMs), seq(seq), sendAtSeq(sendAtSeq)
 			{
 			}
 
-			uint64_t createdAtMs{ 0u };
-			uint16_t seq{ 0u };
-			uint16_t sendAtSeq{ 0u };
-			uint64_t sentAtMs{ 0u };
-			uint8_t retries{ 0u };
+			int64_t createdAtMs{ 0 };
+			uint16_t seq{ 0 };
+			uint16_t sendAtSeq{ 0 };
+			int64_t sentAtMs{ 0 };
+			uint8_t retries{ 0 };
 		};
 
 		enum class NackFilter : uint8_t
@@ -47,7 +47,7 @@ namespace RTC
 		};
 
 	public:
-		explicit NackGenerator(Listener* listener, SharedInterface* shared, uint32_t sendNackDelayMs);
+		explicit NackGenerator(Listener* listener, SharedInterface* shared, int64_t sendNackDelayMs);
 		~NackGenerator() override;
 
 		bool ReceivePacket(const RTC::RTP::Packet* packet, bool isRecovered);
@@ -55,9 +55,9 @@ namespace RTC
 		{
 			return this->nackList.size();
 		}
-		void UpdateRtt(uint32_t rtt)
+		void UpdateRttMs(int64_t rttMs)
 		{
-			this->rtt = rtt;
+			this->rttMs = rttMs;
 		}
 		void Reset();
 
@@ -75,7 +75,7 @@ namespace RTC
 		// Passed by argument.
 		Listener* listener{ nullptr };
 		SharedInterface* shared{ nullptr };
-		uint32_t sendNackDelayMs{ 0u };
+		int64_t sendNackDelayMs{ 0 };
 		// Allocated by this.
 		TimerHandleInterface* timer{ nullptr };
 		// Others.
@@ -83,8 +83,8 @@ namespace RTC
 		std::set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> keyFrameList;
 		std::set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> recoveredList;
 		bool started{ false };
-		uint16_t lastSeq{ 0u }; // Seq number of last valid packet.
-		uint32_t rtt{ 0u };     // Round trip time (ms).
+		uint16_t lastSeq{ 0 }; // Seq number of last valid packet.
+		int64_t rttMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/PipeProducerStreamManager.hpp

@@ -50,10 +50,9 @@ namespace RTC
 		void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
-		uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
-		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
-		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		int64_t IncreaseLayer(int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) override;
+		void ApplyLayers(int64_t rtpStreamActiveMs) override;
+		int64_t GetDesiredBitrate(int64_t nowMs) const override;
 		RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,
 		  bool lastSentPacketHasMarker,