mediasoup 3.26.0 → 3.27.1

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

@@ -3,15 +3,6 @@
 
 #include "common.hpp"
 #include "FBS/rtpStream.h"
-#include "RTC/RTCP/FeedbackPsFir.hpp"
-#include "RTC/RTCP/FeedbackPsPli.hpp"
-#include "RTC/RTCP/FeedbackRtpNack.hpp"
-#include "RTC/RTCP/Packet.hpp"
-#include "RTC/RTCP/ReceiverReport.hpp"
-#include "RTC/RTCP/Sdes.hpp"
-#include "RTC/RTCP/SenderReport.hpp"
-#include "RTC/RTCP/XrDelaySinceLastRr.hpp"
-#include "RTC/RTCP/XrReceiverReferenceTime.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtxStream.hpp"
 #include "RTC/RtpDictionaries.hpp"
@@ -42,22 +33,22 @@ namespace RTC
 				flatbuffers::Offset<FBS::RtpStream::Params> FillBuffer(
 				  flatbuffers::FlatBufferBuilder& builder) const;
 
-				size_t encodingIdx{ 0u };
-				uint32_t ssrc{ 0u };
-				uint8_t payloadType{ 0u };
+				size_t encodingIdx{ 0 };
+				uint32_t ssrc{ 0 };
+				uint8_t payloadType{ 0 };
 				RTC::RtpCodecMimeType mimeType;
-				uint32_t clockRate{ 0u };
+				uint32_t clockRate{ 0 };
 				std::string rid;
 				std::string cname;
-				uint32_t rtxSsrc{ 0u };
-				uint8_t rtxPayloadType{ 0u };
+				uint32_t rtxSsrc{ 0 };
+				uint8_t rtxPayloadType{ 0 };
 				bool useNack{ false };
 				bool usePli{ false };
 				bool useFir{ false };
 				bool useInBandFec{ false };
 				bool useDtx{ false };
-				uint8_t spatialLayers{ 1u };
-				uint8_t temporalLayers{ 1u };
+				uint8_t spatialLayers{ 1 };
+				uint8_t temporalLayers{ 1 };
 			};
 
 		public:
@@ -68,9 +59,9 @@ namespace RTC
 			struct SenderReportMapping
 			{
 				/**
-				 * NTP timestamp of the Sender Report (ms).
+				 * NTP timestamp of the Sender Report (us).
 				 */
-				uint64_t ntpMs;
+				int64_t ntpUs;
 				/**
 				 * RTP timestamp the NTP timestamp above corresponds to.
 				 */
@@ -165,13 +156,13 @@ namespace RTC
 
 			virtual void Resume() = 0;
 
-			virtual uint32_t GetBitrate(uint64_t nowMs) = 0;
+			virtual int64_t GetBitrate(int64_t nowMs) = 0;
 
-			virtual uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) = 0;
+			virtual int64_t GetBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) = 0;
 
-			virtual uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer) = 0;
+			virtual int64_t GetSpatialLayerBitrate(int64_t nowMs, uint8_t spatialLayer) = 0;
 
-			virtual uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) = 0;
+			virtual int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) = 0;
 
 			void ResetScore(uint8_t score, bool notify);
 
@@ -185,14 +176,9 @@ namespace RTC
 				return static_cast<float>(this->fractionLost) * 100 / 256;
 			}
 
-			float GetRtt() const
+			float GetRttMs() const
 			{
-				return this->rtt;
-			}
-
-			uint64_t GetMaxPacketMs() const
-			{
-				return this->maxPacketMs;
+				return this->rttMs;
 			}
 
 			uint32_t GetMaxPacketTs() const
@@ -216,7 +202,7 @@ namespace RTC
 				return this->score;
 			}
 
-			uint64_t GetActiveMs() const
+			int64_t GetActiveMs() const
 			{
 				return this->shared->GetTimeMs() - this->activeSinceMs;
 			}
@@ -250,55 +236,55 @@ namespace RTC
 			// Others.
 			//   https://tools.ietf.org/html/rfc3550#appendix-A.1 stuff.
 			// Highest seq. number seen.
-			uint16_t maxSeq{ 0u };
+			uint16_t maxSeq{ 0 };
 			// Shifted count of seq. number cycles.
-			uint32_t cycles{ 0u };
+			uint32_t cycles{ 0 };
 			// Base seq number.
-			uint32_t baseSeq{ 0u };
+			uint32_t baseSeq{ 0 };
 			// Last 'bad' seq number + 1.
-			uint32_t badSeq{ 0u };
+			uint32_t badSeq{ 0 };
 			// Highest timestamp seen.
-			uint32_t maxPacketTs{ 0u };
+			uint32_t maxPacketTs{ 0 };
 			// When the packet with highest timestammp was seen.
-			uint64_t maxPacketMs{ 0u };
+			int64_t maxPacketAtUs{ 0 };
 			// When the media in the packet with highest timestamp was captured, in our own
 			// monotonic clock.
 			// NOTE: Only meaningful in a send stream, whose packets arrive already carrying
 			// their capture instant. In a receive stream it is the Producer that tells it,
 			// once this class has already seen the packet, so
 			// RtpStreamRecv::GetCaptureMapping() is what must be used there.
-			std::optional<uint64_t> maxPacketCaptureMs;
+			std::optional<int64_t> maxPacketCaptureAtUs;
 			int32_t packetsLost{ 0 };
-			uint8_t fractionLost{ 0u };
+			uint8_t fractionLost{ 0 };
 			// Jitter in RTP timestamp units. As per spec it's kept as floating value
 			// although it's exposed as integer in the stats.
 			float jitter{ 0 };
-			size_t packetsDiscarded{ 0u };
-			size_t packetsRetransmitted{ 0u };
-			size_t packetsRepaired{ 0u };
-			size_t nackCount{ 0u };
-			size_t nackPacketCount{ 0u };
-			size_t pliCount{ 0u };
-			size_t firCount{ 0u };
+			size_t packetsDiscarded{ 0 };
+			size_t packetsRetransmitted{ 0 };
+			size_t packetsRepaired{ 0 };
+			size_t nackCount{ 0 };
+			size_t nackPacketCount{ 0 };
+			size_t pliCount{ 0 };
+			size_t firCount{ 0 };
 			// Packets repaired at last interval for score calculation.
-			size_t repairedPriorScore{ 0u };
+			size_t repairedPriorScore{ 0 };
 			// Packets retransmitted at last interval for score calculation.
-			size_t retransmittedPriorScore{ 0u };
+			size_t retransmittedPriorScore{ 0 };
 			// Correspondence between wall clock and RTP timeline given by the last Sender
 			// Report.
 			std::optional<RTP::RtpStream::SenderReportMapping> lastSenderReportMapping;
-			float rtt{ 0.0f };
+			float rttMs{ 0.0f };
 			// Instance of RtxStream.
 			RTP::RtxStream* rtxStream{ nullptr };
 
 		private:
 			// Score related.
-			uint8_t score{ 0u };
+			uint8_t score{ 0 };
 			std::vector<uint8_t> scores;
 			// Whether at least a RTP packet has been received.
 			bool started{ false };
 			// Last time since the stream is active.
-			uint64_t activeSinceMs{ 0u };
+			int64_t activeSinceMs{ 0 };
 		};
 	} // namespace RTP
 } // namespace RTC

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

@@ -3,6 +3,9 @@
 
 #include "handles/TimerHandleInterface.hpp"
 #include "RTC/NackGenerator.hpp"
+#include "RTC/RTCP/Packet.hpp"
+#include "RTC/RTCP/ReceiverReport.hpp"
+#include "RTC/RTCP/SenderReport.hpp"
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RateCalculator.hpp"
@@ -26,12 +29,12 @@ namespace RTC
 			 * - Same value libwebrtc uses in `AbsoluteCaptureTimeInterpolator`, which
 			 *   pairs with senders emitting the extension at least once per second.
 			 */
-			static constexpr uint64_t MaxAbsCaptureTimeInterpolationMs{ 5000 };
+			static constexpr int64_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 };
+			static constexpr int64_t MaxSenderReportInterpolationMs{ 10000 };
 
 		public:
 			class Listener : public RTP::RtpStream::Listener
@@ -44,6 +47,16 @@ namespace RTC
 				 * streams consuming this RtpStreamRecv.
 				 */
 				virtual uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTP::RtpStreamRecv* rtpStream) = 0;
+				/**
+				 * A spatial layer of this stream started or stopped carrying traffic, so
+				 * whoever chose a target layer out of them must choose again.
+				 *
+				 * @remarks
+				 * - Only fired by streams with more than a spatial layer, which are those
+				 *   of a SVC sender.
+				 */
+				virtual void OnRtpStreamSpatialLayerActivityChanged(
+				  RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive) = 0;
 			};
 
 		public:
@@ -51,18 +64,18 @@ namespace RTC
 			{
 			public:
 				TransmissionCounter(
-				  SharedInterface* shared, uint8_t spatialLayers, uint8_t temporalLayers, size_t windowSize);
+				  SharedInterface* shared, uint8_t spatialLayers, uint8_t temporalLayers, int64_t windowSizeMs);
 
 			public:
 				void Update(const RTP::Packet* packet);
 
-				uint32_t GetBitrate(uint64_t nowMs);
+				int64_t GetBitrate(int64_t nowMs);
 
-				uint32_t GetBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
+				int64_t GetBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
 
-				uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer);
+				int64_t GetSpatialLayerBitrate(int64_t nowMs, uint8_t spatialLayer);
 
-				uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
+				int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
 
 				size_t GetPacketCount() const;
 
@@ -81,9 +94,9 @@ namespace RTC
 			{
 				/**
 				 * Capture instant of the media carried by the RTP timestamp below, in our own
-				 * monotonic clock (ms).
+				 * monotonic clock (us).
 				 */
-				uint64_t captureMs;
+				int64_t captureAtUs;
 				/**
 				 * RTP timestamp the capture instant above refers to.
 				 */
@@ -104,7 +117,7 @@ namespace RTC
 				/**
 				 * Local time at which the Sender Report arrived.
 				 */
-				uint64_t receivedMs;
+				int64_t receivedAtUs;
 			};
 
 			/**
@@ -118,9 +131,9 @@ namespace RTC
 				 */
 				uint32_t ts;
 				/**
-				 * Capture instant in the remote sender's wall clock (ms).
+				 * Capture instant in the remote sender's wall clock (us).
 				 */
-				uint64_t ntpMs;
+				int64_t ntpUs;
 			};
 
 		public:
@@ -128,7 +141,7 @@ namespace RTC
 			  RTP::RtpStreamRecv::Listener* listener,
 			  SharedInterface* shared,
 			  RTP::RtpStream::Params& params,
-			  uint32_t sendNackDelayMs,
+			  int64_t sendNackDelayMs,
 			  bool useRtpInactivityCheck);
 
 			~RtpStreamRecv() override;
@@ -137,7 +150,7 @@ namespace RTC
 			flatbuffers::Offset<FBS::RtpStream::Stats> FillBufferStats(
 			  flatbuffers::FlatBufferBuilder& builder) override;
 
-			bool ReceivePacket(RTP::Packet* packet);
+			bool ReceivePacket(RTP::Packet* packet, int64_t receivedAtUs);
 
 			bool ReceiveRtxPacket(RTP::Packet* packet);
 
@@ -145,25 +158,26 @@ namespace RTC
 
 			RTC::RTCP::ReceiverReport* GetRtxRtcpReceiverReport();
 
-			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
+			void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs);
 
-			void ReceiveRtxRtcpSenderReport(RTC::RTCP::SenderReport* report);
+			void ReceiveRtxRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs);
 
-			void ReceiveRtcpXrDelaySinceLastRr(RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo);
+			void ReceiveRtcpXrDelaySinceLastRr(
+			  RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo, int64_t receivedAtUs);
 
 			/**
 			 * 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
+			std::optional<int64_t> GetSenderReportReceivedAtUs() const
 			{
 				if (!this->lastSenderReportTiming.has_value())
 				{
 					return std::nullopt;
 				}
 
-				return this->lastSenderReportTiming.value().receivedMs;
+				return this->lastSenderReportTiming.value().receivedAtUs;
 			}
 
 			/**
@@ -175,14 +189,14 @@ namespace RTC
 			 *   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 captureAtUs - 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)
+			void SetCaptureMapping(int64_t captureAtUs, uint32_t ts)
 			{
 				this->lastCaptureMapping = RTP::RtpStreamRecv::CaptureMapping{
-					.captureMs = captureMs,
-					.ts        = ts,
+					.captureAtUs = captureAtUs,
+					.ts          = ts,
 				};
 			}
 
@@ -211,7 +225,7 @@ namespace RTC
 			 * @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;
+			std::optional<int64_t> GetRemoteCaptureAtUsFromAbsCaptureTime(uint32_t ts) const;
 
 			/**
 			 * Capture instant of the given RTP timestamp, expressed in the remote sender's
@@ -222,7 +236,7 @@ namespace RTC
 			 * @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;
+			std::optional<int64_t> GetRemoteCaptureAtUsFromSenderReport(uint32_t ts) const;
 
 			void RequestKeyFrame();
 
@@ -230,22 +244,22 @@ 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
 			{
 				return this->transmissionCounter.GetBitrate(nowMs, spatialLayer, temporalLayer);
 			}
 
-			uint32_t GetSpatialLayerBitrate(uint64_t nowMs, uint8_t spatialLayer) override
+			int64_t GetSpatialLayerBitrate(int64_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
+			int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override
 			{
 				return this->transmissionCounter.GetLayerBitrate(nowMs, spatialLayer, temporalLayer);
 			}
@@ -256,7 +270,7 @@ namespace RTC
 			}
 
 		private:
-			void CalculateJitter(uint32_t rtpTimestamp);
+			void CalculateJitter(uint32_t rtpTimestamp, int64_t receivedAtUs);
 
 			void UpdateScore();
 
@@ -264,13 +278,13 @@ namespace RTC
 			 * 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 referenceNtpUs - 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`.
+			 * @param maxDistanceUs - 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;
+			std::optional<int64_t> InterpolateRemoteCaptureAtUs(
+			  int64_t referenceNtpUs, uint32_t referenceTs, uint32_t ts, int64_t maxDistanceUs) const;
 
 			/* Pure virtual methods inherited from RTP::RtpStream. */
 		public:
@@ -288,17 +302,17 @@ namespace RTC
 
 		private:
 			// Passed by argument.
-			uint32_t sendNackDelayMs{ 0u };
+			int64_t sendNackDelayMs{ 0 };
 			bool useRtpInactivityCheck{ false };
 			// Others.
 			// Packets expected at last interval.
-			uint32_t expectedPrior{ 0u };
+			uint32_t expectedPrior{ 0 };
 			// Packets expected at last interval for score calculation.
-			uint32_t expectedPriorScore{ 0u };
+			uint32_t expectedPriorScore{ 0 };
 			// Packets received at last interval.
-			uint32_t receivedPrior{ 0u };
+			uint32_t receivedPrior{ 0 };
 			// Packets received at last interval for score calculation.
-			uint32_t receivedPriorScore{ 0u };
+			uint32_t receivedPriorScore{ 0 };
 			// Timing data of the most recent Sender Report received.
 			std::optional<SenderReportTiming> lastSenderReportTiming;
 			// Most recent `abs-capture-time` RTP header extension received.
@@ -306,12 +320,16 @@ namespace RTC
 			// 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 };
+			int32_t transit{ 0 };
+			uint8_t firSeqNumber{ 0 };
 			int32_t reportedPacketsLost{ 0 };
 			std::unique_ptr<RTC::NackGenerator> nackGenerator;
 			TimerHandleInterface* inactivityCheckPeriodicTimer{ nullptr };
 			bool inactive{ false };
+			TimerHandleInterface* spatialLayersActivityCheckPeriodicTimer{ nullptr };
+			// Whether each spatial layer was carrying traffic at the latest check.
+			// Empty unless this stream has more than a spatial layer.
+			std::vector<bool> spatialLayersActivity;
 			// Valid media + valid RTX.
 			TransmissionCounter transmissionCounter;
 			// Just valid media.

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 };