mediasoup 3.26.0 → 3.27.1

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

@@ -0,0 +1,39 @@
+#ifndef MS_RTC_BWE_UTILS_HPP
+#define MS_RTC_BWE_UTILS_HPP
+
+#include "common.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		class Utils
+		{
+		public:
+			/**
+			 * Bitrate that results from applying a factor to another one (bps).
+			 *
+			 * @remarks
+			 * - The algorithm derives a bitrate from another one this way all over the
+			 *   place, and the result has to come back to an int64_t. A value beyond
+			 *   what that type holds becomes `Types::BitrateInfinite` rather than the
+			 *   undefined one that converting it would give.
+			 * - The result is rounded, not truncated, since each bitrate is derived
+			 *   from the previous one and dropping the fraction every time would drift
+			 *   downwards.
+			 */
+			static int64_t ApplyBitrateFactor(int64_t bitrate, double factor);
+
+			/**
+			 * Sum of two bitrates (bps).
+			 *
+			 * @remarks
+			 * - A sum beyond what an int64_t can hold becomes `Types::BitrateInfinite`
+			 *   rather than wrapping around into a negative bitrate.
+			 */
+			static int64_t AddBitrates(int64_t bitrate, int64_t otherBitrate);
+		};
+	} // 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,

package/worker/include/RTC/PipeTransport.hpp

@@ -59,10 +59,22 @@ namespace RTC
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
-		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtcpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnSctpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtpDataReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtcpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnSctpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 
 		/* Pure virtual methods inherited from RTC::UdpSocket::Listener. */
 	public:
@@ -71,7 +83,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 	private:
 		// Allocated by this.

package/worker/include/RTC/PlainTransport.hpp

@@ -48,10 +48,22 @@ namespace RTC
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
-		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtcpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnSctpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtpDataReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtcpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnSctpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 		void EmitTuple() const;
 		void EmitRtcpTuple() const;
 
@@ -62,7 +74,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 	private:
 		// Allocated by this.

package/worker/include/RTC/PortManager.hpp

@@ -66,8 +66,8 @@ namespace RTC
 		private:
 			Protocol protocol{ Protocol::UDP };
 			sockaddr_storage bindAddr{};
-			uint16_t minPort{ 0u };
-			uint16_t maxPort{ 0u };
+			uint16_t minPort{ 0 };
+			uint16_t maxPort{ 0 };
 		};
 
 		struct PortRangeKeyHash
@@ -92,8 +92,8 @@ namespace RTC
 			}
 
 			std::vector<bool> ports;
-			uint16_t minPort{ 0u };
-			uint16_t numUsedPorts{ 0u };
+			uint16_t minPort{ 0 };
+			uint16_t numUsedPorts{ 0 };
 		};
 
 	public:

package/worker/include/RTC/Producer.hpp

@@ -33,9 +33,10 @@ namespace RTC
 
 		public:
 			virtual void OnProducerReceiveData(RTC::Producer* producer, size_t len) = 0;
-			virtual void OnProducerReceiveRtpPacket(RTC::Producer* producer, RTC::RTP::Packet* packet) = 0;
-			virtual void OnProducerPaused(RTC::Producer* producer)  = 0;
-			virtual void OnProducerResumed(RTC::Producer* producer) = 0;
+			virtual void OnProducerReceiveRtpPacket(
+			  RTC::Producer* producer, RTC::RTP::Packet* packet, int64_t receivedAtUs) = 0;
+			virtual void OnProducerPaused(RTC::Producer* producer)                     = 0;
+			virtual void OnProducerResumed(RTC::Producer* producer)                    = 0;
 			virtual void OnProducerNewRtpStream(
 			  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) = 0;
 			virtual void OnProducerRtpStreamScore(
@@ -45,6 +46,11 @@ namespace RTC
 			  uint8_t previousScore) = 0;
 			virtual void OnProducerRtcpSenderReport(
 			  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+			virtual void OnProducerSpatialLayerActivityChanged(
+			  RTC::Producer* producer,
+			  RTC::RTP::RtpStreamRecv* rtpStream,
+			  uint8_t spatialLayer,
+			  bool isActive) = 0;
 			virtual void OnProducerRtpPacketReceived(RTC::Producer* producer, RTC::RTP::Packet* packet) = 0;
 			virtual void OnProducerSendRtcpPacket(RTC::Producer* producer, RTC::RTCP::Packet* packet) = 0;
 			/**
@@ -59,15 +65,15 @@ namespace RTC
 			 *
 			 * @returns No value while the capture instant cannot be told yet.
 			 */
-			virtual std::optional<uint64_t> OnProducerNeedLocalCaptureMs(
+			virtual std::optional<int64_t> OnProducerNeedLocalCaptureAtUs(
 			  RTC::Producer* producer, const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) = 0;
 			/**
 			 * Offset between the wall clock of the sender of this Producer and our own
-			 * monotonic one (ms).
+			 * monotonic one (us).
 			 *
 			 * @returns No value while the offset cannot be told yet.
 			 */
-			virtual std::optional<int64_t> OnProducerNeedRemoteClockOffsetMs(const RTC::Producer* producer) = 0;
+			virtual std::optional<int64_t> OnProducerNeedRemoteClockOffsetUs(const RTC::Producer* producer) = 0;
 		};
 
 	private:
@@ -153,10 +159,11 @@ namespace RTC
 		{
 			return std::addressof(this->rtpStreamScores);
 		}
-		ReceiveRtpPacketResult ReceiveRtpPacket(RTC::RTP::Packet* packet);
-		void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
-		void ReceiveRtcpXrDelaySinceLastRr(RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo);
-		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs);
+		ReceiveRtpPacketResult ReceiveRtpPacket(RTC::RTP::Packet* packet, int64_t receivedAtUs);
+		void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs);
+		void ReceiveRtcpXrDelaySinceLastRr(
+		  RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo, int64_t receivedAtUs);
+		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, int64_t nowUs);
 		void RequestKeyFrame(uint32_t mappedSsrc);
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
@@ -198,6 +205,8 @@ namespace RTC
 		void OnRtpStreamScore(RTC::RTP::RtpStream* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void OnRtpStreamSendRtcpPacket(RTC::RTP::RtpStreamRecv* rtpStream, RTC::RTCP::Packet* packet) override;
 		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* rtpStream) override;
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive) override;
 
 		/* Pure virtual methods inherited from RTC::KeyFrameRequestManager::Listener. */
 	public:
@@ -229,8 +238,8 @@ namespace RTC
 		bool enableMediasoupPacketIdHeaderExtension{ false };
 		RTC::RTP::Packet* currentRtpPacket{ nullptr };
 		// Timestamp when last RTCP was sent.
-		uint64_t lastRtcpSentTime{ 0u };
-		uint16_t maxRtcpInterval{ 0u };
+		int64_t lastRtcpSentAtUs{ 0 };
+		int64_t maxRtcpIntervalMs{ 0 };
 		// Video orientation.
 		bool videoOrientationDetected{ false };
 		struct VideoOrientation videoOrientation;

package/worker/include/RTC/ProducerStreamManager.hpp

@@ -42,9 +42,9 @@ namespace RTC
 			Type type{ Type::FORWARD };
 
 			// Valid when type == FORWARD:
-			uint32_t tsOffset{ 0u };
+			uint32_t tsOffset{ 0 };
 			bool isSyncPacket{ false };
-			uint16_t syncSeqValue{ 0u };
+			uint16_t syncSeqValue{ 0 };
 			bool shouldSyncEncodingContext{ false };
 			bool spatialLayerSwitched{ false };
 			bool temporalLayerChanged{ false };
@@ -100,16 +100,22 @@ namespace RTC
 		virtual void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore)           = 0;
 		virtual void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+		// Only spatial layers within a same RTP stream can start or stop separately,
+		// so just SVC cares about this.
+		virtual void ProducerSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/)
+		{
+		}
 
 		void SetExternallyManagedBitrate()
 		{
 			this->externallyManagedBitrate = true;
 		}
 
-		virtual uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) = 0;
-		virtual void ApplyLayers(uint64_t rtpStreamActiveMs)                         = 0;
-		virtual uint32_t GetDesiredBitrate(uint64_t nowMs) const                     = 0;
+		virtual int64_t IncreaseLayer(
+		  int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) = 0;
+		virtual void ApplyLayers(int64_t rtpStreamActiveMs)                        = 0;
+		virtual int64_t GetDesiredBitrate(int64_t nowMs) const                     = 0;
 
 		virtual RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,

package/worker/include/RTC/RTCP/Bye.hpp

@@ -60,11 +60,11 @@ namespace RTC
 			{
 				size_t size = Packet::CommonHeaderSize;
 
-				size += ssrcs.size() * 4u;
+				size += ssrcs.size() * 4;
 
 				if (!this->reason.empty())
 				{
-					size += 1u; // Length field.
+					size += 1; // Length field.
 					size += this->reason.length();
 				}
 

package/worker/include/RTC/RTCP/FeedbackPsRemb.hpp

@@ -52,7 +52,7 @@ namespace RTC
 			{
 				return this->isCorrect;
 			}
-			void SetBitrate(uint64_t bitrate)
+			void SetBitrate(int64_t bitrate)
 			{
 				this->bitrate = bitrate;
 			}
@@ -60,7 +60,7 @@ namespace RTC
 			{
 				this->ssrcs = ssrcs;
 			}
-			uint64_t GetBitrate() const
+			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
@@ -76,13 +76,13 @@ namespace RTC
 			size_t GetSize() const override
 			{
 				// NOLINTNEXTLINE(bugprone-parent-virtual-call)
-				return FeedbackPsPacket::GetSize() + 8 + (4u * this->ssrcs.size());
+				return FeedbackPsPacket::GetSize() + 8 + (4 * this->ssrcs.size());
 			}
 
 		private:
 			std::vector<uint32_t> ssrcs;
 			// Bitrate represented in bps.
-			uint64_t bitrate{ 0 };
+			int64_t bitrate{ 0 };
 			bool isCorrect{ true };
 		};
 	} // namespace RTCP

package/worker/include/RTC/RTCP/FeedbackRtpTmmb.hpp

@@ -52,11 +52,11 @@ namespace RTC
 			{
 				this->ssrc = ssrc;
 			}
-			uint64_t GetBitrate() const
+			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
-			void SetBitrate(uint64_t bitrate)
+			void SetBitrate(int64_t bitrate)
 			{
 				this->bitrate = bitrate;
 			}
@@ -80,7 +80,7 @@ namespace RTC
 
 		private:
 			uint32_t ssrc{ 0 };
-			uint64_t bitrate{ 0 };
+			int64_t bitrate{ 0 };
 			uint16_t overhead{ 0 };
 		};