mediasoup 3.26.0 → 3.27.0

package/worker/include/RTC/RTP/RtpStreamSend.hpp

@@ -1,6 +1,11 @@
 #ifndef MS_RTC_RTP_RTP_STREAM_SEND_HPP
 #define MS_RTC_RTP_RTP_STREAM_SEND_HPP
 
+#include "RTC/RTCP/FeedbackPs.hpp"
+#include "RTC/RTCP/FeedbackRtpNack.hpp"
+#include "RTC/RTCP/Sdes.hpp"
+#include "RTC/RTCP/XrDelaySinceLastRr.hpp"
+#include "RTC/RTCP/XrReceiverReferenceTime.hpp"
 #include "RTC/RTP/RetransmissionBuffer.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
@@ -16,11 +21,11 @@ namespace RTC
 			/**
 			 * Maximum retransmission buffer size for video (ms).
 			 */
-			static constexpr uint32_t MaxRetransmissionDelayForVideoMs{ 2000 };
+			static constexpr int64_t MaxRetransmissionDelayForVideoMs{ 2000 };
 			/**
 			 * Maximum retransmission buffer size for audio (ms).
 			 */
-			static constexpr uint32_t MaxRetransmissionDelayForAudioMs{ 1000 };
+			static constexpr int64_t MaxRetransmissionDelayForAudioMs{ 1000 };
 			/**
 			 * How old the last packet sent may be for a Sender Report to still be generated
 			 * (ms).
@@ -30,7 +35,7 @@ namespace RTC
 			 *   with a 120 ms ptime and screen sharing at 1 fps, so that it only triggers on
 			 *   a stream that has really stopped sending.
 			 */
-			static constexpr uint32_t MaxSenderReportReferenceAgeMs{ 2000 };
+			static constexpr int64_t MaxSenderReportReferenceAgeMs{ 2000 };
 
 		public:
 			enum class ReceivePacketResult : uint8_t
@@ -63,7 +68,7 @@ namespace RTC
 				/**
 				 * Local time at which the Receiver Reference Time arrived.
 				 */
-				uint64_t receivedMs;
+				int64_t receivedAtUs;
 			};
 
 		public:
@@ -87,13 +92,14 @@ namespace RTC
 
 			void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType);
 
-			void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
+			void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report, int64_t receivedAtUs);
 
-			void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report);
+			void ReceiveRtcpXrReceiverReferenceTime(
+			  RTC::RTCP::ReceiverReferenceTime* report, int64_t receivedAtUs);
 
-			RTC::RTCP::SenderReport* GetRtcpSenderReport(uint64_t nowMs);
+			RTC::RTCP::SenderReport* GetRtcpSenderReport(int64_t nowUs);
 
-			RTC::RTCP::DelaySinceLastRr::SsrcInfo* GetRtcpXrDelaySinceLastRrSsrcInfo(uint64_t nowMs);
+			RTC::RTCP::DelaySinceLastRr::SsrcInfo* GetRtcpXrDelaySinceLastRrSsrcInfo(int64_t nowUs);
 
 			RTC::RTCP::SdesChunk* GetRtcpSdesChunk();
 
@@ -101,16 +107,16 @@ namespace RTC
 
 			void Resume() override;
 
-			uint32_t GetBitrate(uint64_t nowMs) override
+			int64_t GetBitrate(int64_t nowMs) override
 			{
 				return this->transmissionCounter.GetBitrate(nowMs);
 			}
 
-			uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
+			int64_t GetBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
 
-			uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer) override;
+			int64_t GetSpatialLayerBitrate(int64_t nowMs, uint8_t spatialLayer) override;
 
-			uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
+			int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
 
 		private:
 			void FillRetransmissionContainer(uint16_t seq, uint16_t bitmask);
@@ -125,9 +131,9 @@ namespace RTC
 			// Packets lost at last interval for score calculation.
 			int32_t lostPriorScore{ 0 };
 			// Packets sent at last interval for score calculation.
-			uint32_t sentPriorScore{ 0u };
+			uint32_t sentPriorScore{ 0 };
 			std::string mid;
-			uint16_t rtxSeq{ 0u };
+			uint16_t rtxSeq{ 0 };
 			RTC::RtpDataCounter transmissionCounter;
 			RTP::RetransmissionBuffer* retransmissionBuffer{ nullptr };
 			// Timing data of the most recent Receiver Reference Time received.

package/worker/include/RTC/RTP/RtxStream.hpp

@@ -44,7 +44,7 @@ namespace RTC
 				/**
 				 * Local time at which the Sender Report arrived.
 				 */
-				uint64_t receivedMs;
+				int64_t receivedAtUs;
 			};
 
 		public:
@@ -105,7 +105,7 @@ namespace RTC
 
 			RTC::RTCP::ReceiverReport* GetRtcpReceiverReport();
 
-			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
+			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs);
 
 		protected:
 			bool UpdateSeq(const RTP::Packet* packet);
@@ -124,23 +124,22 @@ namespace RTC
 			Params params;
 			// Others.
 			//   https://tools.ietf.org/html/rfc3550#appendix-A.1 stuff.
-			uint16_t maxSeq{ 0u };      // Highest seq. number seen.
-			uint32_t cycles{ 0u };      // Shifted count of seq. number cycles.
-			uint32_t baseSeq{ 0u };     // Base seq number.
-			uint32_t badSeq{ 0u };      // Last 'bad' seq number + 1.
-			uint32_t maxPacketTs{ 0u }; // Highest timestamp seen.
-			uint64_t maxPacketMs{ 0u }; // When the packet with highest timestammp was seen.
+			uint16_t maxSeq{ 0 };      // Highest seq. number seen.
+			uint32_t cycles{ 0 };      // Shifted count of seq. number cycles.
+			uint32_t baseSeq{ 0 };     // Base seq number.
+			uint32_t badSeq{ 0 };      // Last 'bad' seq number + 1.
+			uint32_t maxPacketTs{ 0 }; // Highest timestamp seen.
 			int32_t packetsLost{ 0 };
-			uint8_t fractionLost{ 0u };
-			size_t packetsDiscarded{ 0u };
-			size_t packetsCount{ 0u };
+			uint8_t fractionLost{ 0 };
+			size_t packetsDiscarded{ 0 };
+			size_t packetsCount{ 0 };
 
 		private:
 			// Whether at least a RTP packet has been received.
 			bool started{ false };
 			// Fields for generating Receiver Reports.
-			uint32_t expectedPrior{ 0u };
-			uint32_t receivedPrior{ 0u };
+			uint32_t expectedPrior{ 0 };
+			uint32_t receivedPrior{ 0 };
 			// Timing data of the most recent Sender Report received.
 			std::optional<SenderReportTiming> lastSenderReportTiming;
 			int32_t reportedPacketsLost{ 0 };

package/worker/include/RTC/RateCalculator.hpp

@@ -8,24 +8,34 @@
 
 namespace RTC
 {
-	// It is considered that the time source increases monotonically.
-	// ie: the current timestamp can never be minor than a timestamp in the past.
+	/**
+	 * Sliding window rate meter.
+	 *
+	 * Data is accumulated into a ring of fixed duration items that covers the
+	 * whole window. The in-window total is kept incrementally, so both Update()
+	 * and GetRate() are O(1) amortized.
+	 *
+	 * It is considered that the time source increases monotonically. Timestamps
+	 * going backwards are however tolerated (time comparisons are wrap safe):
+	 * data still within the window is added to the newest item, older data is
+	 * ignored, and nothing is ever expired ahead of time.
+	 */
 	class RateCalculator
 	{
 	public:
-		static constexpr size_t DefaultWindowSize{ 1000u };
+		static constexpr int64_t DefaultWindowSizeMs{ 1000 };
 		static constexpr float DefaultBpsScale{ 8000.0f };
-		static constexpr uint16_t DefaultWindowItems{ 100u };
+		static constexpr uint16_t DefaultWindowItems{ 100 };
 
 	public:
 		explicit RateCalculator(
-		  size_t windowSizeMs  = DefaultWindowSize,
+		  int64_t windowSizeMs = DefaultWindowSizeMs,
 		  float scale          = DefaultBpsScale,
 		  uint16_t windowItems = DefaultWindowItems);
 
-		void Update(size_t size, uint64_t nowMs);
+		void Update(size_t size, int64_t nowMs);
 
-		uint32_t GetRate(uint64_t nowMs);
+		int64_t GetRate(int64_t nowMs);
 
 		size_t GetBytes() const
 		{
@@ -35,49 +45,45 @@ namespace RTC
 		void Reset();
 
 	private:
-		void RemoveOldData(uint64_t nowMs);
+		bool SlideWindow(int64_t nowMs);
 
 	private:
-		struct BufferItem
-		{
-			size_t count{ 0u };
-			uint64_t timeMs{ 0u };
-		};
-
-	private:
-		// Window Size (in milliseconds).
-		size_t windowSizeMs{ DefaultWindowSize };
-		// Scale in which the rate is represented.
-		float scale{ DefaultBpsScale };
-		// Window Size (number of items).
-		uint16_t windowItems{ DefaultWindowItems };
-		// Item Size (in milliseconds), calculated as: windowSizeMs / windowItems.
-		size_t itemSizeMs{ 0u };
-		// Buffer to keep data.
-		std::vector<BufferItem> buffer;
-		// Time (in milliseconds) for last item in the time window.
-		std::optional<uint64_t> newestItemStartTimeMs{ std::nullopt };
-		// Index for the last item in the time window.
-		int32_t newestItemIndex{ -1 };
-		// Time (in milliseconds) for oldest item in the time window.
-		std::optional<uint64_t> oldestItemStartTimeMs{ std::nullopt };
-		// Index for the oldest item in the time window.
-		int32_t oldestItemIndex{ -1 };
-		// Total count in the time window.
-		size_t totalCount{ 0u };
-		// Total bytes transmitted.
-		size_t bytes{ 0u };
-		// Last value calculated by GetRate().
-		uint32_t lastRate{ 0u };
-		// Last time GetRate() was called.
-		std::optional<uint64_t> lastTimeMs{ std::nullopt };
+		// Window size (in milliseconds). Always >= 1.
+		int64_t windowSizeMs{ DefaultWindowSizeMs };
+		// Item size (in milliseconds). Always >= 1.
+		int64_t itemSizeMs{ 1 };
+		// Precomputed `scale / windowSizeMs`.
+		double rateScale{ 0.0 };
+		// Ring of items, each one holding the count of the data within it. Never
+		// empty, and always long enough to cover the whole window.
+		std::vector<size_t> buffer;
+		// Index of the newest item. Always < buffer.size().
+		size_t newestItemIndex{ 0 };
+		// Time (in milliseconds) at which the newest item starts.
+		int64_t newestItemStartTimeMs{ 0 };
+		// Sum of the count of every item.
+		size_t totalCount{ 0 };
+		// Total bytes accounted for. Not affected by Reset().
+		size_t bytes{ 0 };
+		// Rate memoized by GetRate(), only valid while both `lastTimeMs` and
+		// `lastTotalCount` below still match. `lastTotalCount` is the one that makes
+		// any Update() changing the rate invalidate this implicitly, so that the hot
+		// path needs no memoization store.
+		// NOTE: No "not calculated yet" mark is needed, since the initial and post
+		// Reset() state is a valid entry on its own: a zero rate for a zero count.
+		int64_t lastRate{ 0 };
+		// Time of the latest GetRate() call. Prevents reusing `lastRate` once time
+		// has moved on and there is data pending expiration.
+		int64_t lastTimeMs{ 0 };
+		// Total count at the latest GetRate() call.
+		size_t lastTotalCount{ 0 };
 	};
 
 	class RtpDataCounter
 	{
 	public:
 		explicit RtpDataCounter(
-		  SharedInterface* shared, bool ignorePaddingOnlyPackets, size_t windowSizeMs = 2500)
+		  SharedInterface* shared, bool ignorePaddingOnlyPackets, int64_t windowSizeMs = 2500)
 		  : shared(shared), ignorePaddingOnlyPackets(ignorePaddingOnlyPackets), rate(windowSizeMs)
 		{
 		}
@@ -85,7 +91,7 @@ namespace RTC
 	public:
 		void Update(const RTC::RTP::Packet* packet);
 
-		uint32_t GetBitrate(uint64_t nowMs)
+		int64_t GetBitrate(int64_t nowMs)
 		{
 			return this->rate.GetRate(nowMs);
 		}
@@ -106,7 +112,7 @@ namespace RTC
 		// account.
 		bool ignorePaddingOnlyPackets{ false };
 		RateCalculator rate;
-		size_t packets{ 0u };
+		size_t packets{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/RemoteCaptureTimeEstimator.hpp

@@ -61,13 +61,13 @@ namespace RTC
 		void SenderReportReceived(const RTC::RTP::RtpStreamRecv* rtpStream);
 
 		/**
-		 * Offset between the wall clock of this sender and our own monotonic one (ms).
+		 * Offset between the wall clock of this sender and our own monotonic one (us).
 		 *
 		 * @returns No value while the offset cannot be told yet.
 		 */
-		std::optional<int64_t> GetClockOffsetMs() const
+		std::optional<int64_t> GetClockOffsetUs() const
 		{
-			return this->clockOffsetEstimator.GetOffsetMs();
+			return this->clockOffsetEstimator.GetOffsetUs();
 		}
 
 		/**
@@ -79,7 +79,8 @@ namespace RTC
 		 *
 		 * @returns No value while the capture instant cannot be told yet.
 		 */
-		std::optional<uint64_t> GetLocalCaptureMs(const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const;
+		std::optional<int64_t> GetLocalCaptureAtUs(
+		  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const;
 
 	private:
 		// Offset between the wall clock of the sender and our monotonic one.

package/worker/include/RTC/RemoteClockOffsetEstimator.hpp

@@ -9,9 +9,9 @@ namespace RTC
 	/**
 	 * Estimates the offset between the wall clock of a remote sender, as reported in
 	 * the NTP field of the RTCP Sender Reports it sends, and mediasoup's own monotonic
-	 * clock. Both are expressed in milliseconds, so the estimated offset satisfies:
+	 * clock. Both are expressed in microseconds, so the estimated offset satisfies:
 	 *
-	 *   localMs = remoteMs + offsetMs
+	 *   localUs = remoteUs + offsetUs
 	 *
 	 * Each sample is the difference between the arrival time of a Sender Report and
 	 * the NTP value it carries, so it holds the clock offset plus the one way delay
@@ -46,19 +46,19 @@ namespace RTC
 		/**
 		 * Feed a received RTCP Sender Report.
 		 *
-		 * @param remoteNtpMs - NTP field of the Sender Report, in milliseconds.
-		 * @param localArrivalMs - Our local time at which the Sender Report arrived.
+		 * @param remoteNtpUs - NTP field of the Sender Report, in microseconds.
+		 * @param localArrivalAtUs - Our local time at which the Sender Report arrived.
 		 * @param rttMs - RTT towards the sender, or 0 if not known yet.
 		 */
-		void AddSenderReport(uint64_t remoteNtpMs, uint64_t localArrivalMs, uint32_t rttMs);
+		void AddSenderReport(int64_t remoteNtpUs, int64_t localArrivalAtUs, int64_t rttMs);
 
 		/**
 		 * The estimated offset, or no value while less than `MinSampleCount` samples
 		 * have been gathered.
 		 */
-		std::optional<int64_t> GetOffsetMs() const
+		std::optional<int64_t> GetOffsetUs() const
 		{
-			return this->offsetMs;
+			return this->offsetUs;
 		}
 
 		/**
@@ -66,21 +66,21 @@ namespace RTC
 		 * monotonic clock. Returns no value if there is no offset yet or if the given
 		 * time does not map into our clock.
 		 */
-		std::optional<uint64_t> RemoteMsToLocalMs(uint64_t remoteMs) const;
+		std::optional<int64_t> RemoteUsToLocalUs(int64_t remoteUs) const;
 
 		void Reset();
 
 	private:
-		void UpdateOffsetMs();
+		void UpdateOffsetUs();
 
 	private:
 		// Most recent samples, oldest first.
 		std::vector<int64_t> samples;
 		// Arrival time of the last accepted Sender Report, so that all the Sender
 		// Reports of a same compound packet produce a single sample.
-		uint64_t lastLocalArrivalMs{ 0 };
+		int64_t lastLocalArrivalAtUs{ 0 };
 		// Median of the samples in the window.
-		std::optional<int64_t> offsetMs;
+		std::optional<int64_t> offsetUs;
 	};
 } // namespace RTC
 

package/worker/include/RTC/Router.hpp

@@ -77,6 +77,12 @@ namespace RTC
 		  RTC::Producer* producer,
 		  RTC::RTP::RtpStreamRecv* rtpStream,
 		  bool first) override;
+		void OnTransportProducerSpatialLayerActivityChanged(
+		  RTC::Transport* transport,
+		  RTC::Producer* producer,
+		  RTC::RTP::RtpStreamRecv* rtpStream,
+		  uint8_t spatialLayer,
+		  bool isActive) override;
 		void OnTransportProducerRtpPacketReceived(
 		  RTC::Transport* transport, RTC::Producer* producer, RTC::RTP::Packet* packet) override;
 		uint8_t OnTransportNeedWorstRemoteFractionLost(

package/worker/include/RTC/RtcLogger.hpp

@@ -42,7 +42,7 @@ namespace RTC
 			void Clear();
 
 		public:
-			uint64_t timestamp{};
+			int64_t timestamp{};
 			std::string recvTransportId;
 			std::string sendTransportId;
 			std::string routerId;

package/worker/include/RTC/RtpDictionaries.hpp

@@ -162,9 +162,9 @@ namespace RTC
 
 	public:
 		RtpCodecMimeType mimeType;
-		uint8_t payloadType{ 0u };
-		uint32_t clockRate{ 0u };
-		uint8_t channels{ 1u };
+		uint8_t payloadType{ 0 };
+		uint32_t clockRate{ 0 };
+		uint8_t channels{ 1 };
 		RTC::Parameters parameters;
 		std::vector<RtcpFeedback> rtcpFeedback;
 	};
@@ -178,7 +178,7 @@ namespace RTC
 		flatbuffers::Offset<FBS::RtpParameters::Rtx> FillBuffer(flatbuffers::FlatBufferBuilder& builder) const;
 
 	public:
-		uint32_t ssrc{ 0u };
+		uint32_t ssrc{ 0 };
 	};
 
 	class RtpEncodingParameters
@@ -191,18 +191,18 @@ namespace RTC
 		  flatbuffers::FlatBufferBuilder& builder) const;
 
 	public:
-		uint32_t ssrc{ 0u };
+		uint32_t ssrc{ 0 };
 		std::string rid;
-		uint8_t codecPayloadType{ 0u };
+		uint8_t codecPayloadType{ 0 };
 		bool hasCodecPayloadType{ false };
 		RtpRtxParameters rtx;
 		bool hasRtx{ false };
-		uint32_t maxBitrate{ 0u };
+		int64_t maxBitrate{ 0 };
 		double maxFramerate{ 0 };
 		bool dtx{ false };
 		std::string scalabilityMode{ "S1T1" };
-		uint8_t spatialLayers{ 1u };
-		uint8_t temporalLayers{ 1u };
+		uint8_t spatialLayers{ 1 };
+		uint8_t temporalLayers{ 1 };
 		bool ksvc{ false };
 	};
 
@@ -218,7 +218,7 @@ namespace RTC
 
 	public:
 		RtpHeaderExtensionUri::Type type;
-		uint8_t id{ 0u };
+		uint8_t id{ 0 };
 		bool encrypt{ false };
 		RTC::Parameters parameters;
 	};

package/worker/include/RTC/SCTP/association/Association.hpp

@@ -345,7 +345,7 @@ namespace RTC
 			/**
 			 * Receives SCTP data (hopefully an SCTP packet) from the remote peer.
 			 */
-			void ReceiveSctpData(const uint8_t* data, size_t len) override;
+			void ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs) override;
 
 			/**
 			 * Get negotiated max outbound streams. Returns 0 if the association is
@@ -418,65 +418,93 @@ namespace RTC
 
 			bool ValidateReceivedPacket(const Packet* receivedPacket);
 
-			bool HandleReceivedChunk(const Packet* receivedPacket, const Chunk* receivedChunk);
+			bool HandleReceivedChunk(
+			  const Packet* receivedPacket, const Chunk* receivedChunk, int64_t receivedAtUs);
 
-			void HandleReceivedInitChunk(const Packet* receivedPacket, const InitChunk* receivedInitChunk);
+			void HandleReceivedInitChunk(
+			  const Packet* receivedPacket, const InitChunk* receivedInitChunk, int64_t receivedAtUs);
 
 			void HandleReceivedInitAckChunk(
-			  const Packet* receivedPacket, const InitAckChunk* receivedInitAckChunk);
+			  const Packet* receivedPacket, const InitAckChunk* receivedInitAckChunk, int64_t receivedAtUs);
 
 			void HandleReceivedCookieEchoChunk(
-			  const Packet* receivedPacket, const CookieEchoChunk* receivedCookieEchoChunk);
+			  const Packet* receivedPacket,
+			  const CookieEchoChunk* receivedCookieEchoChunk,
+			  int64_t receivedAtUs);
 
-			bool HandleReceivedCookieEchoChunkWithTcb(const Packet* receivedPacket, const StateCookie* cookie);
+			bool HandleReceivedCookieEchoChunkWithTcb(
+			  const Packet* receivedPacket, const StateCookie* cookie, int64_t receivedAtUs);
 
 			void HandleReceivedCookieAckChunk(
-			  const Packet* receivedPacket, const CookieAckChunk* receivedCookieAckChunk);
+			  const Packet* receivedPacket,
+			  const CookieAckChunk* receivedCookieAckChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedShutdownChunk(
-			  const Packet* receivedPacket, const ShutdownChunk* receivedShutdownChunk);
+			  const Packet* receivedPacket, const ShutdownChunk* receivedShutdownChunk, int64_t receivedAtUs);
 
 			void HandleReceivedShutdownAckChunk(
-			  const Packet* receivedPacket, const ShutdownAckChunk* receivedShutdownAckChunk);
+			  const Packet* receivedPacket,
+			  const ShutdownAckChunk* receivedShutdownAckChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedShutdownCompleteChunk(
-			  const Packet* receivedPacket, const ShutdownCompleteChunk* receivedShutdownCompleteChunk);
+			  const Packet* receivedPacket,
+			  const ShutdownCompleteChunk* receivedShutdownCompleteChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedOperationErrorChunk(
-			  const Packet* receivedPacket, const OperationErrorChunk* receivedOperationErrorChunk);
+			  const Packet* receivedPacket,
+			  const OperationErrorChunk* receivedOperationErrorChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedAbortAssociationChunk(
-			  const Packet* receivedPacket, const AbortAssociationChunk* receivedAbortAssociationChunk);
+			  const Packet* receivedPacket,
+			  const AbortAssociationChunk* receivedAbortAssociationChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedHeartbeatRequestChunk(
-			  const Packet* receivedPacket, const HeartbeatRequestChunk* receivedHeartbeatRequestChunk);
+			  const Packet* receivedPacket,
+			  const HeartbeatRequestChunk* receivedHeartbeatRequestChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedHeartbeatAckChunk(
-			  const Packet* receivedPacket, const HeartbeatAckChunk* receivedHeartbeatAckChunk);
+			  const Packet* receivedPacket,
+			  const HeartbeatAckChunk* receivedHeartbeatAckChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedReConfigChunk(
-			  const Packet* receivedPacket, const ReConfigChunk* receivedReConfigChunk);
+			  const Packet* receivedPacket, const ReConfigChunk* receivedReConfigChunk, int64_t receivedAtUs);
 
 			void HandleReceivedForwardTsnChunk(
-			  const Packet* receivedPacket, const ForwardTsnChunk* receivedForwardTsnChunk);
+			  const Packet* receivedPacket,
+			  const ForwardTsnChunk* receivedForwardTsnChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedIForwardTsnChunk(
-			  const Packet* receivedPacket, const IForwardTsnChunk* receivedIForwardTsnChunk);
+			  const Packet* receivedPacket,
+			  const IForwardTsnChunk* receivedIForwardTsnChunk,
+			  int64_t receivedAtUs);
 
 			void HandleReceivedAnyForwardTsnChunk(
-			  const Packet* receivedPacket, const AnyForwardTsnChunk* receivedAnyForwardTsnChunk);
+			  const Packet* receivedPacket,
+			  const AnyForwardTsnChunk* receivedAnyForwardTsnChunk,
+			  int64_t receivedAtUs);
 
-			void HandleReceivedDataChunk(const Packet* receivedPacket, const DataChunk* receivedDataChunk);
+			void HandleReceivedDataChunk(
+			  const Packet* receivedPacket, const DataChunk* receivedDataChunk, int64_t receivedAtUs);
 
-			void HandleReceivedIDataChunk(const Packet* receivedPacket, const IDataChunk* receivedIDataChunk);
+			void HandleReceivedIDataChunk(
+			  const Packet* receivedPacket, const IDataChunk* receivedIDataChunk, int64_t receivedAtUs);
 
 			void HandleReceivedAnyDataChunk(
-			  const Packet* receivedPacket, const AnyDataChunk* receivedAnyDataChunk);
+			  const Packet* receivedPacket, const AnyDataChunk* receivedAnyDataChunk, int64_t receivedAtUs);
 
-			void HandleReceivedSackChunk(const Packet* receivedPacket, const SackChunk* receivedSackChunk);
+			void HandleReceivedSackChunk(
+			  const Packet* receivedPacket, const SackChunk* receivedSackChunk, int64_t receivedAtUs);
 
 			bool HandleReceivedUnknownChunk(
-			  const Packet* receivedPacket, const UnknownChunk* receivedUnknownChunk);
+			  const Packet* receivedPacket, const UnknownChunk* receivedUnknownChunk, int64_t receivedAtUs);
 
 			/**
 			 * Verify the MAC and freshness of an authenticated State Cookie received
@@ -489,13 +517,13 @@ namespace RTC
 			 *
 			 * @see RFC 9260 section 5.1.4.
 			 */
-			bool VerifyReceivedStateCookie(const StateCookie* cookie);
+			bool VerifyReceivedStateCookie(const StateCookie* cookie, int64_t receivedAtUs);
 
-			void OnT1InitTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnT1InitTimer(int64_t& baseTimeoutMs, bool& stop);
 
-			void OnT1CookieTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnT1CookieTimer(int64_t& baseTimeoutMs, bool& stop);
 
-			void OnT2ShutdownTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnT2ShutdownTimer(int64_t& baseTimeoutMs, bool& stop);
 
 			template<typename... States>
 			void AssertState(States... expectedStates) const;
@@ -520,7 +548,7 @@ namespace RTC
 			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
 			void OnBackoffTimer(
-			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop) override;
 
 			/* Pure virtual methods inherited from TransmissionControlBlockContextInterface::Listener. */
 		public:

package/worker/include/RTC/SCTP/association/HeartbeatHandler.hpp

@@ -53,14 +53,14 @@ namespace RTC
 			void HandleReceivedHeartbeatAckChunk(const HeartbeatAckChunk* receivedHeartbeatAckChunk);
 
 		private:
-			void OnIntervalTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnIntervalTimer(int64_t& baseTimeoutMs, bool& stop);
 
-			void OnTimeoutTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnTimeoutTimer(int64_t& baseTimeoutMs, bool& stop);
 
 			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
 			void OnBackoffTimer(
-			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			AssociationListenerDeferrer& associationListenerDeferrer;
@@ -68,7 +68,7 @@ namespace RTC
 			SharedInterface* shared;
 			TransmissionControlBlockContextInterface* tcbContext;
 			// The time for a connection to be idle before a heartbeat is sent.
-			const uint64_t intervalDurationMs;
+			const int64_t intervalDurationMs;
 			// Adding RTT to the duration will add some jitter, which is good in
 			// production, but less good in unit tests, which is why it can be disabled.
 			const bool intervalDurationShouldIncludeRtt;