mediasoup 3.27.1 → 3.28.0

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

@@ -0,0 +1,146 @@
+#ifndef MS_RTC_BWE_TRANSPORT_WIDE_CC_FEEDBACK_GENERATOR_HPP
+#define MS_RTC_BWE_TRANSPORT_WIDE_CC_FEEDBACK_GENERATOR_HPP
+
+#include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
+#include "RTC/RTCP/FeedbackRtpTransport.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "RTC/RateCalculator.hpp"
+#include "RTC/SeqManager.hpp"
+#include "SharedInterface.hpp"
+#include <map>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Tells the remote sender when each of its packets arrived, which is what
+		 * lets that sender estimate the link towards us.
+		 *
+		 * Nothing is estimated here. The arrival time of every packet carrying the
+		 * transport wide sequence number is kept, and a feedback packet with as many
+		 * of them as fit is emitted periodically. Turning those arrival times into a
+		 * bitrate is the remote sender's job.
+		 *
+		 * How often the feedback is emitted follows the bitrate coming in, so that
+		 * what reporting costs stays a small share of what is being reported on.
+		 */
+		class TransportWideCcFeedbackGenerator : public TimerHandleInterface::Listener
+		{
+		public:
+			class Listener
+			{
+			public:
+				virtual ~Listener() = default;
+
+			public:
+				/**
+				 * A feedback packet is ready for the remote sender.
+				 *
+				 * @param packet - Packet to send, only valid for the duration of this
+				 *   call.
+				 */
+				virtual void OnTransportWideCcFeedbackGeneratorSendRtcpPacket(
+				  TransportWideCcFeedbackGenerator* transportWideCcFeedbackGenerator,
+				  RTC::RTCP::FeedbackRtpTransportPacket* packet) = 0;
+			};
+
+		public:
+			TransportWideCcFeedbackGenerator(
+			  Listener* listener, SharedInterface* shared, size_t maxRtcpPacketLen);
+			~TransportWideCcFeedbackGenerator() override = default;
+
+			TransportWideCcFeedbackGenerator(const TransportWideCcFeedbackGenerator&)            = delete;
+			TransportWideCcFeedbackGenerator& operator=(const TransportWideCcFeedbackGenerator&) = delete;
+
+			/**
+			 * Feed a received RTP packet, which is ignored unless it carries the
+			 * transport wide sequence number extension.
+			 *
+			 * @param arrivalTimeUs - Instant the packet arrived.
+			 */
+			void IncomingPacket(int64_t arrivalTimeUs, const RTC::RTP::Packet* packet);
+
+#ifdef MS_TEST
+		public:
+#else
+		private:
+#endif
+			/**
+			 * Report everything received since the last time, in as many feedback
+			 * packets as it takes.
+			 */
+			void FillAndSendFeedback();
+
+			/**
+			 * How often feedback should be emitted (ms) to report on the given
+			 * incoming bitrate (bps) without taking more than a small share of it.
+			 */
+			static int64_t ComputeSendIntervalMs(int64_t incomingBitrate);
+
+			/**
+			 * How often feedback is being emitted right now (ms).
+			 */
+			int64_t GetSendIntervalMs() const
+			{
+				return this->sendIntervalMs;
+			}
+
+		private:
+			/**
+			 * Hand the feedback packet being filled to the listener.
+			 *
+			 * @returns Whether it was handed over, which does not happen when it holds
+			 *   nothing that can be put on the wire.
+			 */
+			bool SendFeedback();
+
+			/**
+			 * Forget the arrival times too old to be reported, keeping the one the
+			 * next feedback starts at.
+			 */
+			void MayDropOldPacketArrivalTimes(uint16_t seqNum, int64_t arrivalTimeUs);
+
+			/**
+			 * Start a new feedback packet, carrying on the given count.
+			 */
+			void ResetFeedbackPacket(uint8_t feedbackPacketCount);
+
+			/**
+			 * Work out how often feedback should be emitted out of the bitrate coming
+			 * in, and reprogram the timer if the answer changed.
+			 */
+			void MayUpdateSendInterval(int64_t nowMs);
+
+			/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
+		public:
+			void OnTimer(TimerHandleInterface* timer) override;
+
+		private:
+			// Largest an RTCP packet may be on this transport (bytes).
+			const size_t maxRtcpPacketLen;
+
+			// Passed by argument.
+			Listener* listener{ nullptr };
+			SharedInterface* shared{ nullptr };
+			// Allocated by this.
+			const std::unique_ptr<TimerHandleInterface> sendPeriodicTimer;
+			std::unique_ptr<RTC::RTCP::FeedbackRtpTransportPacket> feedbackPacket;
+			// Bitrate coming in, which is what decides how often feedback is emitted.
+			RTC::RtpDataCounter incomingDataCounter;
+			// How often feedback is emitted (ms).
+			int64_t sendIntervalMs;
+			uint8_t feedbackPacketCount{ 0 };
+			uint32_t feedbackMediaSsrc{ 0 };
+			// Sequence number the next feedback starts reporting at, or no value
+			// until the first packet is seen.
+			std::optional<uint16_t> feedbackWideSeqNumStart;
+			// Instant each packet arrived (us), indexed by its transport wide
+			// sequence number.
+			std::map<uint16_t, int64_t, RTC::SeqManager<uint16_t>::SeqLowerThan> mapPacketArrivalTimes;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

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

@@ -27,6 +27,13 @@ namespace RTC
 		class TrendlineEstimator
 		{
 		public:
+			/**
+			 * @remarks
+			 * - Every constraint documented below is checked by the constructor and
+			 *   aborts when it doesn't hold. These options are set from C++ alone,
+			 *   never from the network nor from the API, so breaking one of them is a
+			 *   programming error.
+			 */
 			struct TrendlineEstimatorOptions
 			{
 				/**
@@ -52,10 +59,18 @@ namespace RTC
 				bool enableCap{ false };
 				/**
 				 * How many packets of the beginning of the window that cap looks at.
+				 *
+				 * @remarks
+				 * - While `enableCap` is set it must be at least 1, and the two ends
+				 *   together must fit in `windowSize`, since the cap looks at both of
+				 *   them without them overlapping.
 				 */
 				size_t beginningPackets{ 7 };
 				/**
 				 * How many packets of the end of the window that cap looks at.
+				 *
+				 * @remarks
+				 * - The same constraints as `beginningPackets`.
 				 */
 				size_t endPackets{ 7 };
 				/**

package/worker/include/RTC/Consts.hpp

@@ -2,11 +2,39 @@
 #define MS_RTC_CONSTS_HPP
 
 #include "common.hpp"
+#include <string_view>
 
 namespace RTC
 {
 	namespace Consts
 	{
+		/**
+		 * Bytes an IPv4 header takes, without options.
+		 */
+		constexpr size_t Ipv4HeaderSize{ 20 };
+
+		/**
+		 * Bytes an IPv6 header takes, without extension headers.
+		 */
+		constexpr size_t Ipv6HeaderSize{ 40 };
+
+		/**
+		 * Bytes a UDP header takes.
+		 */
+		constexpr size_t UdpHeaderSize{ 8 };
+
+		/**
+		 * Bytes a TCP header takes, without options.
+		 */
+		constexpr size_t TcpHeaderSize{ 20 };
+
+		/**
+		 * Bytes of the length field that frames every packet sent over TCP.
+		 *
+		 * @see https://datatracker.ietf.org/doc/html/rfc4571
+		 */
+		constexpr size_t TcpFramingSize{ 2 };
+
 		/**
 		 * Max MTU size.
 		 */
@@ -39,6 +67,48 @@ namespace RTC
 		 */
 		constexpr uint8_t MidRtpExtensionMaxLength{ 8 };
 
+		/**
+		 * SSRC of the RTP stream the probing packets are sent on.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very SSRC, so it cannot be
+		 *   changed without changing the client as well.
+		 */
+		constexpr uint32_t BweProbeRtpSsrc{ 1234 };
+
+		/**
+		 * Codec payload type of the RTP stream the probing packets are sent on.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very payload type, so it
+		 *   cannot be changed without changing the client as well.
+		 */
+		constexpr uint8_t BweProbeRtpPayloadType{ 127 };
+
+		/**
+		 * MID of the RTP stream the probing packets are sent on, which is how the
+		 * receiver tells it apart.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very MID, so it cannot be
+		 *   changed without changing the client as well.
+		 */
+		constexpr std::string_view BweProbeRtpMid{ "probator" };
+
+		static_assert(
+		  BweProbeRtpMid.size() <= MidRtpExtensionMaxLength,
+		  "the MID of the probing stream does not fit in a MID RTP header extension");
+
+		/**
+		 * Lowest bitrate the bandwidth estimation ever produces (bps), so 5 kbps.
+		 */
+		constexpr int64_t BweMinBitrate{ 5000 };
+
+		/**
+		 * Highest bitrate the bandwidth estimation ever deals in (bps), so 1 Gbps.
+		 */
+		constexpr int64_t BweMaxBitrate{ 1000000000 };
+
 		/**
 		 * Largest safe SCTP packet. Starting from the minimum guaranteed MTU value
 		 * of 1280 for IPv6 (which may not support fragmentation), take off 85

package/worker/include/RTC/DataConsumer.hpp

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SctpDictionaries.hpp"
 #include "SharedInterface.hpp"
@@ -14,9 +15,6 @@ namespace RTC
 {
 	class DataConsumer : public Channel::ChannelSocket::RequestHandler
 	{
-	protected:
-		using onQueuedCallback = const std::function<void(bool queued, bool sctpSendBufferFull)>;
-
 	public:
 		class Listener
 		{
@@ -25,7 +23,7 @@ namespace RTC
 
 		public:
 			virtual void OnDataConsumerSendMessage(
-			  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb) = 0;
+			  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb) = 0;
 			virtual void OnDataConsumerNeedBufferedAmount(
 			  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const = 0;
 			virtual void OnDataConsumerNeedBufferedAmountLowThreshold(
@@ -110,7 +108,7 @@ namespace RTC
 		  std::vector<uint16_t>& subchannels,
 		  std::optional<uint16_t> requiredSubchannel,
 		  std::optional<uint16_t> ignoredSubchannel,
-		  const onQueuedCallback* cb = nullptr);
+		  onMessageQueuedCallback cb = {});
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
 	public:

package/worker/include/RTC/DirectTransport.hpp

@@ -1,6 +1,7 @@
 #ifndef MS_RTC_DIRECT_TRANSPORT_HPP
 #define MS_RTC_DIRECT_TRANSPORT_HPP
 
+#include "handles/SendCallbacks.hpp"
 #include "RTC/Transport.hpp"
 #include "SharedInterface.hpp"
 
@@ -24,16 +25,14 @@ namespace RTC
 
 	private:
 		bool IsConnected() const override;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		size_t GetPacketOverhead() const override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/RTC/PipeTransport.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_PIPE_TRANSPORT_HPP
 
 #include "FBS/pipeTransport.h"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -45,17 +46,15 @@ namespace RTC
 		{
 			return true;
 		}
+		size_t GetPacketOverhead() const override;
 		bool HasSrtp() const;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/RTC/PlainTransport.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_PLAIN_TRANSPORT_HPP
 
 #include "FBS/plainTransport.h"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -33,18 +34,16 @@ namespace RTC
 
 	private:
 		bool IsConnected() const override;
+		size_t GetPacketOverhead() const override;
 		bool HasSrtp() const;
 		bool IsSrtpReady() const;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

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

@@ -33,8 +33,10 @@ namespace RTC
 		{
 		public:
 			// 'R' 'E' 'M' 'B'.
-			static const uint32_t UniqueIdentifier{ 0x52454D42 };
-			static const size_t UniqueIdentifierSize{ 4 };
+			static constexpr uint32_t UniqueIdentifier{ 0x52454D42 };
+			static constexpr size_t UniqueIdentifierSize{ 4 };
+			// Most SSRCs that fit, since the field that counts them is a single byte.
+			static constexpr size_t MaxNumberOfSsrcs{ 0xFF };
 
 		public:
 			static FeedbackPsRembPacket* Parse(const uint8_t* data, size_t len);
@@ -56,15 +58,12 @@ namespace RTC
 			{
 				this->bitrate = bitrate;
 			}
-			void SetSsrcs(const std::vector<uint32_t>& ssrcs)
-			{
-				this->ssrcs = ssrcs;
-			}
+			void SetSsrcs(const std::vector<uint32_t>& ssrcs);
 			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
-			const std::vector<uint32_t>& GetSsrcs()
+			const std::vector<uint32_t>& GetSsrcs() const
 			{
 				return this->ssrcs;
 			}

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

@@ -3,6 +3,8 @@
 
 #include "common.hpp"
 #include "RTC/RTCP/Feedback.hpp"
+#include "Utils.hpp"
+#include <cstdlib> // std::abs()
 #include <vector>
 
 /* RTP extensions for Transport-wide Congestion Control
@@ -324,7 +326,7 @@ namespace RTC
 				size += this->deltasAndChunksSize;
 
 				// 32 bits padding.
-				size += (-size) & 3;
+				size = Utils::Byte::PadTo4Bytes(size);
 
 				return size;
 			}

package/worker/include/RTC/RTP/Codecs/Tools.hpp

@@ -186,7 +186,7 @@ namespace RTC
 							return true;
 						}
 
-							NO_DEFAULT_GCC();
+							NO_DEFAULT();
 					}
 				}
 

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

@@ -20,7 +20,6 @@ namespace RTC
 			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 };

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

@@ -10,7 +10,7 @@
 #include "RTC/Serializable.hpp"
 #include "Utils.hpp"
 #ifdef MS_RTC_LOGGER_RTP
-#include "RTC/RtcLogger.hpp"
+#include "RTC/RtcLogger/RtpPacket.hpp"
 #endif
 #include <flatbuffers/flatbuffers.h>
 #include <array>
@@ -527,10 +527,11 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - `sentAtUs` is converted internally to the 3 bytes ABS Send Time format,
-			 *   unlike `ReadAbsSendTime()`, which exposes the raw extension value.
+			 * - `absSendTime` is the raw 3 bytes unsigned integer the extension
+			 *   carries, the same one `ReadAbsSendTime()` gives back. An instant is
+			 *   turned into it with `Utils::Time::TimeUsToAbsSendTime()`.
 			 */
-			bool UpdateAbsSendTime(int64_t sentAtUs) const;
+			bool UpdateAbsSendTime(uint32_t absSendTime) const;
 
 			bool ReadTransportWideCc01(uint16_t& wideSeqNumber) const;
 
@@ -549,6 +550,17 @@ namespace RTC
 
 			bool ReadAbsCaptureTime(uint64_t& absCaptureTimestamp, int64_t& estimatedCaptureClockOffset) const;
 
+			/**
+			 * @remarks
+			 * - `absCaptureTimestamp` is the raw 8 bytes unsigned integer the extension
+			 *   carries, the same one `ReadAbsCaptureTime()` gives back, which is a
+			 *   capture instant in NTP format. An instant is turned into it with
+			 *   `Utils::Time::TimeUsToNtp()`.
+			 * - The estimated capture clock offset the extension carries when it is 16
+			 *   bytes long is left untouched.
+			 */
+			bool UpdateAbsCaptureTime(uint64_t absCaptureTimestamp) const;
+
 			bool ReadPlayoutDelay(uint16_t& minDelay, uint16_t& maxDelay) const;
 
 			bool ReadMediasoupPacketId(uint32_t& mediasoupPacketId) const;

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

@@ -15,14 +15,6 @@ namespace RTC
 			 * Maximum length of a probation RTP packet.
 			 */
 			static constexpr size_t ProbationPacketMaxLength{ 1400 };
-			/**
-			 * SSRC of the probation RTP stream.
-			 */
-			static const uint32_t Ssrc{ 1234 };
-			/**
-			 * Codec payload type of the probation RTP stream.
-			 */
-			static const uint8_t PayloadType{ 127 };
 
 		public:
 			explicit ProbationGenerator();

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

@@ -259,17 +259,20 @@ namespace RTC
 			// 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{ 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 };
+			// NOTE: These counters are never reset and nothing bounds them, so they are
+			// as wide as the stats fields they end up in rather than as wide as a
+			// pointer.
+			uint64_t packetsDiscarded{ 0 };
+			uint64_t packetsRetransmitted{ 0 };
+			uint64_t packetsRepaired{ 0 };
+			uint64_t nackCount{ 0 };
+			uint64_t nackPacketCount{ 0 };
+			uint64_t pliCount{ 0 };
+			uint64_t firCount{ 0 };
 			// Packets repaired at last interval for score calculation.
-			size_t repairedPriorScore{ 0 };
+			uint64_t repairedPriorScore{ 0 };
 			// Packets retransmitted at last interval for score calculation.
-			size_t retransmittedPriorScore{ 0 };
+			uint64_t retransmittedPriorScore{ 0 };
 			// Correspondence between wall clock and RTP timeline given by the last Sender
 			// Report.
 			std::optional<RTP::RtpStream::SenderReportMapping> lastSenderReportMapping;

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

@@ -77,9 +77,9 @@ namespace RTC
 
 				int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
 
-				size_t GetPacketCount() const;
+				uint64_t GetPacketCount() const;
 
-				size_t GetBytes() const;
+				uint64_t GetBytes() const;
 
 			private:
 				std::vector<std::vector<RTC::RtpDataCounter>> spatialLayerCounters;
@@ -227,6 +227,20 @@ namespace RTC
 			 */
 			std::optional<int64_t> GetRemoteCaptureAtUsFromAbsCaptureTime(uint32_t ts) const;
 
+			/**
+			 * Whether the 'abs-capture-time' RTP header extension has ever been received
+			 * on this stream.
+			 *
+			 * @remarks
+			 * - It is not the same as being able to tell a capture instant from it, which
+			 *   also depends on how far the wanted RTP timestamp falls from the one it
+			 *   referred to.
+			 */
+			bool HasAbsCaptureTime() const
+			{
+				return this->lastAbsCaptureTime.has_value();
+			}
+
 			/**
 			 * Capture instant of the given RTP timestamp, expressed in the remote sender's
 			 * wall clock, interpolated from the last received RTCP Sender Report.
@@ -306,13 +320,17 @@ namespace RTC
 			bool useRtpInactivityCheck{ false };
 			// Others.
 			// Packets expected at last interval.
+			// NOTE: As wide as GetExpectedPackets(), which wraps with the sequence
+			// number, so that the difference against it is taken in its own width.
 			uint32_t expectedPrior{ 0 };
 			// Packets expected at last interval for score calculation.
 			uint32_t expectedPriorScore{ 0 };
 			// Packets received at last interval.
-			uint32_t receivedPrior{ 0 };
+			// NOTE: As wide as the counter it snapshots, which does not wrap, so that
+			// the difference against it stays exact however long the stream runs.
+			uint64_t receivedPrior{ 0 };
 			// Packets received at last interval for score calculation.
-			uint32_t receivedPriorScore{ 0 };
+			uint64_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.

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

@@ -109,7 +109,7 @@ namespace RTC
 
 			int64_t GetBitrate(int64_t nowMs) override
 			{
-				return this->transmissionCounter.GetBitrate(nowMs);
+				return this->transmissionCounter.GetBitrate(nowMs).value_or(0);
 			}
 
 			int64_t GetBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
@@ -131,7 +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{ 0 };
+			// NOTE: As wide as the counter it snapshots, which does not wrap, so that
+			// the difference against it stays exact however long the stream runs.
+			uint64_t sentPriorScore{ 0 };
 			std::string mid;
 			uint16_t rtxSeq{ 0 };
 			RTC::RtpDataCounter transmissionCounter;

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

@@ -96,7 +96,7 @@ namespace RTC
 				return static_cast<float>(this->fractionLost) * 100 / 256;
 			}
 
-			size_t GetPacketsDiscarded() const
+			uint64_t GetPacketsDiscarded() const
 			{
 				return this->packetsDiscarded;
 			}
@@ -131,15 +131,21 @@ namespace RTC
 			uint32_t maxPacketTs{ 0 }; // Highest timestamp seen.
 			int32_t packetsLost{ 0 };
 			uint8_t fractionLost{ 0 };
-			size_t packetsDiscarded{ 0 };
-			size_t packetsCount{ 0 };
+			// NOTE: These counters are never reset and nothing bounds them, so they are
+			// as wide as the stats fields they end up in rather than as wide as a
+			// pointer.
+			uint64_t packetsDiscarded{ 0 };
+			uint64_t packetsCount{ 0 };
 
 		private:
 			// Whether at least a RTP packet has been received.
 			bool started{ false };
 			// Fields for generating Receiver Reports.
+			// NOTE: Each one is as wide as the counter it snapshots, so that the
+			// expected one follows the wrap of the sequence number while the received
+			// one, which does not wrap, stays exact however long the stream runs.
 			uint32_t expectedPrior{ 0 };
-			uint32_t receivedPrior{ 0 };
+			uint64_t receivedPrior{ 0 };
 			// Timing data of the most recent Sender Report received.
 			std::optional<SenderReportTiming> lastSenderReportTiming;
 			int32_t reportedPacketsLost{ 0 };