mediasoup 3.26.0 → 3.27.0

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

@@ -12,18 +12,18 @@ namespace RTC
 		struct HeaderExtensionIds
 		{
 			// 0 means no id.
-			uint8_t mid{ 0u };
-			uint8_t rid{ 0u };
-			uint8_t rrid{ 0u };
-			uint8_t absSendTime{ 0u };
-			uint8_t transportWideCc01{ 0u };
-			uint8_t ssrcAudioLevel{ 0u };
-			uint8_t dependencyDescriptor{ 0u };
-			uint8_t videoOrientation{ 0u };
-			uint8_t timeOffset{ 0u };
-			uint8_t absCaptureTime{ 0u };
-			uint8_t playoutDelay{ 0u };
-			uint8_t mediasoupPacketId{ 0u };
+			uint8_t mid{ 0 };
+			uint8_t rid{ 0 };
+			uint8_t rrid{ 0 };
+			uint8_t absSendTime{ 0 };
+			uint8_t transportWideCc01{ 0 };
+			uint8_t ssrcAudioLevel{ 0 };
+			uint8_t dependencyDescriptor{ 0 };
+			uint8_t videoOrientation{ 0 };
+			uint8_t timeOffset{ 0 };
+			uint8_t absCaptureTime{ 0 };
+			uint8_t playoutDelay{ 0 };
+			uint8_t mediasoupPacketId{ 0 };
 		};
 	} // namespace RTP
 } // namespace RTC

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

@@ -527,10 +527,10 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Contrary to `ReadAbsSendTime()` method, given `ms` is internally
-			 *   converted to ABS Send Time.
+			 * - `sentAtUs` is converted internally to the 3 bytes ABS Send Time format,
+			 *   unlike `ReadAbsSendTime()`, which exposes the raw extension value.
 			 */
-			bool UpdateAbsSendTime(uint64_t ms) const;
+			bool UpdateAbsSendTime(int64_t sentAtUs) const;
 
 			bool ReadTransportWideCc01(uint16_t& wideSeqNumber) const;
 
@@ -819,7 +819,7 @@ namespace RTC
 			{
 				if (!this->payloadDescriptorHandler)
 				{
-					return 0u;
+					return 0;
 				}
 
 				return this->payloadDescriptorHandler->GetSpatialLayer();
@@ -832,26 +832,26 @@ namespace RTC
 			{
 				if (!this->payloadDescriptorHandler)
 				{
-					return 0u;
+					return 0;
 				}
 
 				return this->payloadDescriptorHandler->GetTemporalLayer();
 			}
 
 			/**
-			 * Capture time (in ms) of the packet.
+			 * Capture time (in us) of the packet.
 			 */
-			std::optional<uint64_t> GetCaptureMs() const
+			std::optional<int64_t> GetCaptureAtUs() const
 			{
-				return this->captureMs;
+				return this->captureAtUs;
 			}
 
 			/**
-			 * Set the capture time (in ms) of the packet.
+			 * Set the capture time (in us) of the packet.
 			 */
-			void SetCaptureMs(uint64_t captureMs)
+			void SetCaptureAtUs(int64_t captureAtUs)
 			{
-				this->captureMs = captureMs;
+				this->captureAtUs = captureAtUs;
 			}
 
 		private:
@@ -967,7 +967,7 @@ namespace RTC
 			// each entry is the offset (in bytes) from the beginning of the header
 			// extension value to the beginning of the extension.
 			std::array<ssize_t, 14> oneByteExtensions{ -1, -1, -1, -1, -1, -1, -1,
-				                                         -1, -1, -1, -1, -1, -1, -1 };
+			                                           -1, -1, -1, -1, -1, -1, -1 };
 			// Ordered map of Two Bytes Extensions. Key is the id 1 of the extension,
 			// each entry is the offset (in bytes) from the beginning of the header
 			// extension value to the beginning of the extension.
@@ -977,7 +977,7 @@ namespace RTC
 			// Codec related.
 			std::shared_ptr<Codecs::PayloadDescriptorHandler> payloadDescriptorHandler;
 			// Capture time of the packet.
-			std::optional<uint64_t> captureMs;
+			std::optional<int64_t> captureAtUs;
 		};
 	} // namespace RTP
 } // namespace RTC

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

@@ -22,7 +22,7 @@ namespace RTC
 			/**
 			 * Codec payload type of the probation RTP stream.
 			 */
-			static const uint8_t PayloadType{ 127u };
+			static const uint8_t PayloadType{ 127 };
 
 		public:
 			explicit ProbationGenerator();

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

@@ -27,24 +27,24 @@ namespace RTC
 				// Payload descriptor encoder.
 				std::unique_ptr<RTP::Codecs::PayloadDescriptor::Encoder> encoder{ nullptr };
 				// Correct SSRC since original packet may not have the same.
-				uint32_t ssrc{ 0u };
+				uint32_t ssrc{ 0 };
 				// Correct sequence number since original packet may not have the same.
-				uint16_t sequenceNumber{ 0u };
+				uint16_t sequenceNumber{ 0 };
 				// Correct timestamp since original packet may not have the same.
-				uint32_t timestamp{ 0u };
+				uint32_t timestamp{ 0 };
 				// Correct marker bit since original packet may not have the same.
 				bool marker{ false };
 				// Last time this packet was resent.
-				uint64_t resentAtMs{ 0u };
+				int64_t resentAtMs{ 0 };
 				// Number of times this packet was resent.
-				uint8_t sentTimes{ 0u };
+				uint8_t sentTimes{ 0 };
 			};
 
 		private:
 			static Item* FillItem(Item* item, RTP::Packet* packet, const RTP::SharedPacket& sharedPacket);
 
 		public:
-			RetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate);
+			RetransmissionBuffer(uint16_t maxItems, int64_t maxRetransmissionDelayMs, uint32_t clockRate);
 			~RetransmissionBuffer();
 
 			void Dump(int indentation = 0) const;
@@ -67,7 +67,7 @@ namespace RTC
 		private:
 			// Given as argument.
 			uint16_t maxItems;
-			uint32_t maxRetransmissionDelayMs;
+			int64_t maxRetransmissionDelayMs;
 			uint32_t clockRate;
 		};
 	} // namespace RTP

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.