mediasoup 3.24.2 → 3.26.0

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

@@ -16,14 +16,34 @@ namespace RTC
 		                      public RTC::NackGenerator::Listener,
 		                      public TimerHandleInterface::Listener
 		{
+		public:
+			/**
+			 * How far the RTP timestamp of a packet may be from the last received
+			 * `abs-capture-time` RTP header extension for its capture instant to still be
+			 * interpolated from it (ms).
+			 *
+			 * @remarks
+			 * - Same value libwebrtc uses in `AbsoluteCaptureTimeInterpolator`, which
+			 *   pairs with senders emitting the extension at least once per second.
+			 */
+			static constexpr uint64_t MaxAbsCaptureTimeInterpolationMs{ 5000 };
+			/**
+			 * How far the RTP timestamp of a packet may be from the last received RTCP
+			 * Sender Report for its capture instant to still be interpolated from it (ms).
+			 */
+			static constexpr uint64_t MaxSenderReportInterpolationMs{ 10000 };
+
 		public:
 			class Listener : public RTP::RtpStream::Listener
 			{
 			public:
 				virtual void OnRtpStreamSendRtcpPacket(
 				  RTP::RtpStreamRecv* rtpStream, RTC::RTCP::Packet* packet) = 0;
-				virtual void OnRtpStreamNeedWorstRemoteFractionLost(
-				  RTP::RtpStreamRecv* rtpStream, uint8_t& worstRemoteFractionLost) = 0;
+				/**
+				 * Obtains the worst remote fraction lost of all the RtpStreamSend
+				 * streams consuming this RtpStreamRecv.
+				 */
+				virtual uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTP::RtpStreamRecv* rtpStream) = 0;
 			};
 
 		public:
@@ -32,18 +52,77 @@ namespace RTC
 			public:
 				TransmissionCounter(
 				  SharedInterface* shared, uint8_t spatialLayers, uint8_t temporalLayers, size_t windowSize);
+
+			public:
 				void Update(const RTP::Packet* packet);
+
 				uint32_t GetBitrate(uint64_t nowMs);
+
 				uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
+
 				uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer);
+
 				uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
+
 				size_t GetPacketCount() const;
+
 				size_t GetBytes() const;
 
 			private:
 				std::vector<std::vector<RTC::RtpDataCounter>> spatialLayerCounters;
 			};
 
+		public:
+			/**
+			 * Correspondence between the RTP timeline of this stream and our own monotonic
+			 * clock.
+			 */
+			struct CaptureMapping
+			{
+				/**
+				 * Capture instant of the media carried by the RTP timestamp below, in our own
+				 * monotonic clock (ms).
+				 */
+				uint64_t captureMs;
+				/**
+				 * RTP timestamp the capture instant above refers to.
+				 */
+				uint32_t ts;
+			};
+
+		private:
+			/**
+			 * Data of a received RTCP Sender Report needed to report LSR and DLSR back in a
+			 * Receiver Report.
+			 */
+			struct SenderReportTiming
+			{
+				/**
+				 * Middle 32 bits out of 64 in the NTP timestamp of the Sender Report.
+				 */
+				uint32_t compactNtp;
+				/**
+				 * Local time at which the Sender Report arrived.
+				 */
+				uint64_t receivedMs;
+			};
+
+			/**
+			 * Capture instant carried by an `abs-capture-time` RTP header extension, together
+			 * with the RTP timestamp it refers to.
+			 */
+			struct AbsCaptureTime
+			{
+				/**
+				 * RTP timestamp the capture instant below refers to.
+				 */
+				uint32_t ts;
+				/**
+				 * Capture instant in the remote sender's wall clock (ms).
+				 */
+				uint64_t ntpMs;
+			};
+
 		public:
 			RtpStreamRecv(
 			  RTP::RtpStreamRecv::Listener* listener,
@@ -51,36 +130,126 @@ namespace RTC
 			  RTP::RtpStream::Params& params,
 			  uint32_t sendNackDelayMs,
 			  bool useRtpInactivityCheck);
+
 			~RtpStreamRecv() override;
 
+		public:
 			flatbuffers::Offset<FBS::RtpStream::Stats> FillBufferStats(
 			  flatbuffers::FlatBufferBuilder& builder) override;
+
 			bool ReceivePacket(RTP::Packet* packet);
+
 			bool ReceiveRtxPacket(RTP::Packet* packet);
+
 			RTC::RTCP::ReceiverReport* GetRtcpReceiverReport();
+
 			RTC::RTCP::ReceiverReport* GetRtxRtcpReceiverReport();
+
 			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
+
 			void ReceiveRtxRtcpSenderReport(RTC::RTCP::SenderReport* report);
+
 			void ReceiveRtcpXrDelaySinceLastRr(RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo);
+
+			/**
+			 * Local time at which the last RTCP Sender Report arrived.
+			 *
+			 * @returns No value if no Sender Report has arrived yet.
+			 */
+			std::optional<uint64_t> GetSenderReportReceivedMs() const
+			{
+				if (!this->lastSenderReportTiming.has_value())
+				{
+					return std::nullopt;
+				}
+
+				return this->lastSenderReportTiming.value().receivedMs;
+			}
+
+			/**
+			 * Store the correspondence between the RTP timeline of this stream and our own
+			 * monotonic clock.
+			 *
+			 * @remarks
+			 * - Only the Producer can tell it, since translating the capture instant of the
+			 *   remote sender into our own clock needs the whole set of streams of that
+			 *   sender.
+			 *
+			 * @param captureMs - Capture instant of `ts` in our own monotonic clock.
+			 * @param ts - RTP timestamp the capture instant refers to.
+			 */
+			void SetCaptureMapping(uint64_t captureMs, uint32_t ts)
+			{
+				this->lastCaptureMapping = RTP::RtpStreamRecv::CaptureMapping{
+					.captureMs = captureMs,
+					.ts        = ts,
+				};
+			}
+
+			/**
+			 * Correspondence between the RTP timeline of this stream and our own monotonic
+			 * clock, as of the last RTP timestamp whose capture instant could be told.
+			 *
+			 * @remarks
+			 * - Once set it is never unset, so any two streams of a same sender that have it
+			 *   can always be aligned to each other.
+			 *
+			 * @returns No value if no capture instant could be told yet.
+			 */
+			std::optional<RTP::RtpStreamRecv::CaptureMapping> GetCaptureMapping() const
+			{
+				return this->lastCaptureMapping;
+			}
+
+			/**
+			 * Capture instant of the given RTP timestamp, expressed in the remote sender's
+			 * wall clock, interpolated from the last received `abs-capture-time` RTP header
+			 * extension.
+			 *
+			 * @param ts - RTP timestamp whose capture instant is wanted.
+			 *
+			 * @returns No value if no such extension has been received, or if the given RTP
+			 * timestamp is too far away from the one it referred to.
+			 */
+			std::optional<uint64_t> GetRemoteCaptureMsFromAbsCaptureTime(uint32_t ts) const;
+
+			/**
+			 * Capture instant of the given RTP timestamp, expressed in the remote sender's
+			 * wall clock, interpolated from the last received RTCP Sender Report.
+			 *
+			 * @param ts - RTP timestamp whose capture instant is wanted.
+			 *
+			 * @returns No value if no Sender Report has been received, or if the given RTP
+			 * timestamp is too far away from the one it reported.
+			 */
+			std::optional<uint64_t> GetRemoteCaptureMsFromSenderReport(uint32_t ts) const;
+
 			void RequestKeyFrame();
+
 			void Pause() override;
+
 			void Resume() override;
+
 			uint32_t GetBitrate(uint64_t nowMs) override
 			{
 				return this->transmissionCounter.GetBitrate(nowMs);
 			}
+
 			uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override
 			{
 				return this->transmissionCounter.GetBitrate(nowMs, spatialLayer, temporalLayer);
 			}
+
 			uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer) override
 			{
 				return this->transmissionCounter.GetSpatialLayerBitrate(nowMs, spatialLayer);
 			}
+
 			uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override
 			{
 				return this->transmissionCounter.GetLayerBitrate(nowMs, spatialLayer, temporalLayer);
 			}
+
 			bool HasRtpInactivityCheckEnabled() const
 			{
 				return this->useRtpInactivityCheck;
@@ -88,8 +257,21 @@ namespace RTC
 
 		private:
 			void CalculateJitter(uint32_t rtpTimestamp);
+
 			void UpdateScore();
 
+			/**
+			 * Interpolate the capture instant of `ts` from a reference pair, all of them
+			 * expressed in the remote sender's wall clock.
+			 *
+			 * @param referenceNtpMs - Capture instant of `referenceTs`.
+			 * @param referenceTs - RTP timestamp the reference instant refers to.
+			 * @param ts - RTP timestamp whose capture instant is wanted.
+			 * @param maxDistanceMs - How far `ts` may be from `referenceTs`.
+			 */
+			std::optional<uint64_t> InterpolateRemoteCaptureMs(
+			  uint64_t referenceNtpMs, uint32_t referenceTs, uint32_t ts, uint64_t maxDistanceMs) const;
+
 			/* Pure virtual methods inherited from RTP::RtpStream. */
 		public:
 			void UserOnSequenceNumberReset() override;
@@ -101,6 +283,7 @@ namespace RTC
 			/* Pure virtual methods inherited from RTC::NackGenerator. */
 		protected:
 			void OnNackGeneratorNackRequired(const std::vector<uint16_t>& seqNumbers) override;
+
 			void OnNackGeneratorKeyFrameRequired() override;
 
 		private:
@@ -116,11 +299,12 @@ namespace RTC
 			uint32_t receivedPrior{ 0u };
 			// Packets received at last interval for score calculation.
 			uint32_t receivedPriorScore{ 0u };
-			// The middle 32 bits out of 64 in the NTP timestamp received in the most
-			// recent sender report.
-			uint32_t lastSrTimestamp{ 0u };
-			// Wallclock time representing the most recent sender report arrival.
-			uint64_t lastSrReceived{ 0u };
+			// Timing data of the most recent Sender Report received.
+			std::optional<SenderReportTiming> lastSenderReportTiming;
+			// Most recent `abs-capture-time` RTP header extension received.
+			std::optional<AbsCaptureTime> lastAbsCaptureTime;
+			// Most recent RTP timestamp whose capture instant could be told, along with it.
+			std::optional<CaptureMapping> lastCaptureMapping;
 			// Relative transit time for prev packet.
 			int32_t transit{ 0u };
 			uint8_t firSeqNumber{ 0u };

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

@@ -13,10 +13,24 @@ namespace RTC
 		class RtpStreamSend : public RTP::RtpStream
 		{
 		public:
-			// Maximum retransmission buffer size for video (ms).
-			static const uint32_t MaxRetransmissionDelayForVideoMs;
-			// Maximum retransmission buffer size for audio (ms).
-			static const uint32_t MaxRetransmissionDelayForAudioMs;
+			/**
+			 * Maximum retransmission buffer size for video (ms).
+			 */
+			static constexpr uint32_t MaxRetransmissionDelayForVideoMs{ 2000 };
+			/**
+			 * Maximum retransmission buffer size for audio (ms).
+			 */
+			static constexpr uint32_t MaxRetransmissionDelayForAudioMs{ 1000 };
+			/**
+			 * How old the last packet sent may be for a Sender Report to still be generated
+			 * (ms).
+			 *
+			 * @remarks
+			 * - Above the interval between packets of any legitimate stream, including Opus
+			 *   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 };
 
 		public:
 			enum class ReceivePacketResult : uint8_t
@@ -34,37 +48,73 @@ namespace RTC
 				  RTP::RtpStreamSend* rtpStream, RTP::Packet* packet) = 0;
 			};
 
+		private:
+			/**
+			 * Data of a received Receiver Reference Time Extended Report needed to
+			 * report LRR and DLRR back in a Delay Since Last Receiver Report Extended
+			 * Report.
+			 */
+			struct ReceiverReferenceTime
+			{
+				/**
+				 * Middle 32 bits out of 64 in the NTP timestamp of the Receiver Reference Time.
+				 */
+				uint32_t compactNtp;
+				/**
+				 * Local time at which the Receiver Reference Time arrived.
+				 */
+				uint64_t receivedMs;
+			};
+
 		public:
 			RtpStreamSend(
 			  RTP::RtpStreamSend::Listener* listener,
 			  SharedInterface* shared,
 			  RTP::RtpStream::Params& params,
 			  std::string& mid);
+
 			~RtpStreamSend() override;
 
+		public:
 			flatbuffers::Offset<FBS::RtpStream::Stats> FillBufferStats(
 			  flatbuffers::FlatBufferBuilder& builder) override;
+
 			void SetRtx(uint8_t payloadType, uint32_t ssrc) override;
+
 			ReceivePacketResult ReceivePacket(RTP::Packet* packet, const RTP::SharedPacket& sharedPacket);
+
 			void ReceiveNack(RTC::RTCP::FeedbackRtpNackPacket* nackPacket);
+
 			void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType);
+
 			void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
+
 			void ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report);
+
 			RTC::RTCP::SenderReport* GetRtcpSenderReport(uint64_t nowMs);
+
 			RTC::RTCP::DelaySinceLastRr::SsrcInfo* GetRtcpXrDelaySinceLastRrSsrcInfo(uint64_t nowMs);
+
 			RTC::RTCP::SdesChunk* GetRtcpSdesChunk();
+
 			void Pause() override;
+
 			void Resume() override;
+
 			uint32_t GetBitrate(uint64_t nowMs) override
 			{
 				return this->transmissionCounter.GetBitrate(nowMs);
 			}
+
 			uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
+
 			uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer) override;
+
 			uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
 
 		private:
 			void FillRetransmissionContainer(uint16_t seq, uint16_t bitmask);
+
 			void UpdateScore(RTC::RTCP::ReceiverReport* report);
 
 			/* Pure virtual methods inherited from RTP::RtpStream. */
@@ -80,12 +130,8 @@ namespace RTC
 			uint16_t rtxSeq{ 0u };
 			RTC::RtpDataCounter transmissionCounter;
 			RTP::RetransmissionBuffer* retransmissionBuffer{ nullptr };
-			// The middle 32 bits out of 64 in the NTP timestamp received in the most
-			// recent receiver reference timestamp.
-			uint32_t lastRrTimestamp{ 0u };
-			// Wallclock time representing the most recent receiver reference timestamp
-			// arrival.
-			uint64_t lastRrReceivedMs{ 0u };
+			// Timing data of the most recent Receiver Reference Time received.
+			std::optional<ReceiverReferenceTime> lastReceiverReferenceTime;
 		};
 	} // namespace RTP
 } // namespace RTC

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

@@ -30,54 +30,86 @@ namespace RTC
 				std::string cname;
 			};
 
+		private:
+			/**
+			 * Data of a received RTCP Sender Report needed to report LSR and DLSR back in a
+			 * Receiver Report.
+			 */
+			struct SenderReportTiming
+			{
+				/**
+				 * Middle 32 bits out of 64 in the NTP timestamp of the Sender Report.
+				 */
+				uint32_t compactNtp;
+				/**
+				 * Local time at which the Sender Report arrived.
+				 */
+				uint64_t receivedMs;
+			};
+
 		public:
 			explicit RtxStream(SharedInterface* shared, RTP::RtxStream::Params& params);
+
 			virtual ~RtxStream();
 
+		public:
 			flatbuffers::Offset<FBS::RtxStream::RtxDump> FillBuffer(
 			  flatbuffers::FlatBufferBuilder& builder) const;
+
 			uint32_t GetSsrc() const
 			{
 				return this->params.ssrc;
 			}
+
 			uint8_t GetPayloadType() const
 			{
 				return this->params.payloadType;
 			}
+
 			const RTC::RtpCodecMimeType& GetMimeType() const
 			{
 				return this->params.mimeType;
 			}
+
 			uint32_t GetClockRate() const
 			{
 				return this->params.clockRate;
 			}
+
 			const std::string& GetRrid() const
 			{
 				return this->params.rrid;
 			}
+
 			const std::string& GetCname() const
 			{
 				return this->params.cname;
 			}
+
 			uint8_t GetFractionLost() const
 			{
 				return this->fractionLost;
 			}
+
 			float GetLossPercentage() const
 			{
 				return static_cast<float>(this->fractionLost) * 100 / 256;
 			}
+
 			size_t GetPacketsDiscarded() const
 			{
 				return this->packetsDiscarded;
 			}
+
 			bool ReceivePacket(const RTP::Packet* packet);
+
 			RTC::RTCP::ReceiverReport* GetRtcpReceiverReport();
+
 			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
 
 		protected:
 			bool UpdateSeq(const RTP::Packet* packet);
+
 			uint32_t GetExpectedPackets() const
 			{
 				return (this->cycles + this->maxSeq) - this->baseSeq + 1;
@@ -109,8 +141,8 @@ namespace RTC
 			// Fields for generating Receiver Reports.
 			uint32_t expectedPrior{ 0u };
 			uint32_t receivedPrior{ 0u };
-			uint32_t lastSrTimestamp{ 0u };
-			uint64_t lastSrReceived{ 0u };
+			// Timing data of the most recent Sender Report received.
+			std::optional<SenderReportTiming> lastSenderReportTiming;
 			int32_t reportedPacketsLost{ 0 };
 		};
 	} // namespace RTP

package/worker/include/RTC/RemoteCaptureTimeEstimator.hpp

@@ -0,0 +1,92 @@
+#ifndef MS_RTC_REMOTE_CAPTURE_TIME_ESTIMATOR_HPP
+#define MS_RTC_REMOTE_CAPTURE_TIME_ESTIMATOR_HPP
+
+#include "common.hpp"
+#include "RTC/RTP/RtpStreamRecv.hpp"
+#include "RTC/RemoteClockOffsetEstimator.hpp"
+
+namespace RTC
+{
+	/**
+	 * Tells at which instant of our own monotonic clock the media carried by a given
+	 * RTP timestamp was captured, for every RTP stream of a same remote sender.
+	 *
+	 * The capture instant is read from one of two sources, and the same one is used
+	 * for every stream of the sender. Mixing them would reintroduce the very inter
+	 * stream skew this is meant to remove, since they do not carry the same residual
+	 * error: `abs-capture-time` is exact while a Sender Report is biased by its own
+	 * one way delay.
+	 *
+	 * The source is chosen from what the Producers of the sender negotiated. The
+	 * first Producer chooses it, and a single Producer that did not negotiate
+	 * `abs-capture-time` moves it to Sender Report for the rest of the life of this
+	 * object, never back.
+	 *
+	 * A single instance is meant to be shared by all the RTP streams of a given
+	 * CNAME, which is what identifies media coming from a same machine and hence
+	 * from a same wall clock.
+	 */
+	class RemoteCaptureTimeEstimator
+	{
+	public:
+		enum class Source : uint8_t
+		{
+			ABS_CAPTURE_TIME = 1,
+			SENDER_REPORT
+		};
+
+	public:
+		/**
+		 * Take a Producer of this sender into account to choose the source.
+		 *
+		 * @param absCaptureTimeNegotiated - Whether the Producer negotiated the
+		 * `abs-capture-time` RTP header extension.
+		 */
+		void UpdateSource(bool absCaptureTimeNegotiated);
+
+		/**
+		 * Source the capture instant is being read from.
+		 *
+		 * @returns No value until the first Producer has been taken into account.
+		 */
+		std::optional<Source> GetSource() const
+		{
+			return this->source;
+		}
+
+		/**
+		 * Notify that a Sender Report has been received on one of the RTP streams of
+		 * this sender.
+		 */
+		void SenderReportReceived(const RTC::RTP::RtpStreamRecv* rtpStream);
+
+		/**
+		 * Offset between the wall clock of this sender and our own monotonic one (ms).
+		 *
+		 * @returns No value while the offset cannot be told yet.
+		 */
+		std::optional<int64_t> GetClockOffsetMs() const
+		{
+			return this->clockOffsetEstimator.GetOffsetMs();
+		}
+
+		/**
+		 * Capture instant of the given RTP timestamp of the given RTP stream,
+		 * expressed in our own monotonic clock.
+		 *
+		 * @param rtpStream - RTP stream the RTP timestamp belongs to.
+		 * @param ts - RTP timestamp whose capture instant is wanted.
+		 *
+		 * @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;
+
+	private:
+		// Offset between the wall clock of the sender and our monotonic one.
+		RTC::RemoteClockOffsetEstimator clockOffsetEstimator;
+		// Source the capture instant is read from, for every stream of this sender.
+		std::optional<Source> source;
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/RemoteClockOffsetEstimator.hpp

@@ -0,0 +1,87 @@
+#ifndef MS_RTC_REMOTE_CLOCK_OFFSET_ESTIMATOR_HPP
+#define MS_RTC_REMOTE_CLOCK_OFFSET_ESTIMATOR_HPP
+
+#include "common.hpp"
+#include <vector>
+
+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:
+	 *
+	 *   localMs = remoteMs + offsetMs
+	 *
+	 * 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
+	 * of that Sender Report. That delay is removed with half of the RTT when known,
+	 * and the median of a sliding window is taken so that transient delay spikes are
+	 * rejected.
+	 *
+	 * A single instance is meant to be shared by all the RTP streams of a given
+	 * CNAME. Those streams come from the same machine and hence from the same wall
+	 * clock, and using a different offset for each of them would reintroduce the
+	 * very inter stream skew this is meant to remove.
+	 *
+	 * @remarks
+	 * - Based on the RemoteNtpTimeEstimator class of libwebrtc.
+	 */
+	class RemoteClockOffsetEstimator
+	{
+	public:
+		/**
+		 * Number of most recent samples the median is computed over.
+		 */
+		static constexpr size_t WindowSize{ 7 };
+		/**
+		 * Number of samples required before an offset is reported.
+		 */
+		static constexpr size_t MinSampleCount{ 3 };
+
+	public:
+		RemoteClockOffsetEstimator();
+
+	public:
+		/**
+		 * 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 rttMs - RTT towards the sender, or 0 if not known yet.
+		 */
+		void AddSenderReport(uint64_t remoteNtpMs, uint64_t localArrivalMs, uint32_t rttMs);
+
+		/**
+		 * The estimated offset, or no value while less than `MinSampleCount` samples
+		 * have been gathered.
+		 */
+		std::optional<int64_t> GetOffsetMs() const
+		{
+			return this->offsetMs;
+		}
+
+		/**
+		 * Translate a time expressed in the remote sender's wall clock into our own
+		 * 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;
+
+		void Reset();
+
+	private:
+		void UpdateOffsetMs();
+
+	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 };
+		// Median of the samples in the window.
+		std::optional<int64_t> offsetMs;
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/Router.hpp

@@ -79,11 +79,8 @@ namespace RTC
 		  bool first) override;
 		void OnTransportProducerRtpPacketReceived(
 		  RTC::Transport* transport, RTC::Producer* producer, RTC::RTP::Packet* packet) override;
-		void OnTransportNeedWorstRemoteFractionLost(
-		  RTC::Transport* transport,
-		  RTC::Producer* producer,
-		  uint32_t mappedSsrc,
-		  uint8_t& worstRemoteFractionLost) override;
+		uint8_t OnTransportNeedWorstRemoteFractionLost(
+		  RTC::Transport* transport, RTC::Producer* producer, uint32_t mappedSsrc) override;
 		void OnTransportNewConsumer(
 		  RTC::Transport* transport, RTC::Consumer* consumer, const std::string& producerId) override;
 		void OnTransportConsumerClosed(RTC::Transport* transport, RTC::Consumer* consumer) override;