mediasoup 3.27.0 → 3.28.0

package/worker/src/RTC/RTP/RtpStreamRecv.cpp

@@ -8,6 +8,7 @@
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
 #include "RTC/RTP/Codecs/Tools.hpp"
 #include "Utils.hpp"
+#include <cmath> // std::round()
 
 namespace RTC
 {
@@ -72,7 +73,7 @@ namespace RTC
 			{
 				for (auto& temporalLayerCounter : spatialLayerCounter)
 				{
-					rate += temporalLayerCounter.GetBitrate(nowMs);
+					rate += temporalLayerCounter.GetBitrate(nowMs).value_or(0);
 				}
 			}
 
@@ -91,7 +92,7 @@ namespace RTC
 			// Return 0 if specified layers are not being received.
 			auto& counter = this->spatialLayerCounters[spatialLayer][temporalLayer];
 
-			if (counter.GetBitrate(nowMs) <= 0)
+			if (counter.GetBitrate(nowMs).value_or(0) <= 0)
 			{
 				return 0;
 			}
@@ -105,7 +106,7 @@ namespace RTC
 				{
 					auto& temporalLayerCounter = this->spatialLayerCounters[sIdx][tIdx];
 
-					rate += temporalLayerCounter.GetBitrate(nowMs);
+					rate += temporalLayerCounter.GetBitrate(nowMs).value_or(0);
 				}
 			}
 
@@ -114,7 +115,7 @@ namespace RTC
 			{
 				auto& temporalLayerCounter = this->spatialLayerCounters[spatialLayer][tIdx];
 
-				rate += temporalLayerCounter.GetBitrate(nowMs);
+				rate += temporalLayerCounter.GetBitrate(nowMs).value_or(0);
 			}
 
 			return rate;
@@ -132,7 +133,7 @@ namespace RTC
 			{
 				auto& temporalLayerCounter = this->spatialLayerCounters[spatialLayer][tIdx];
 
-				rate += temporalLayerCounter.GetBitrate(nowMs);
+				rate += temporalLayerCounter.GetBitrate(nowMs).value_or(0);
 			}
 
 			return rate;
@@ -149,14 +150,14 @@ namespace RTC
 
 			auto& counter = this->spatialLayerCounters[spatialLayer][temporalLayer];
 
-			return counter.GetBitrate(nowMs);
+			return counter.GetBitrate(nowMs).value_or(0);
 		}
 
-		size_t RtpStreamRecv::TransmissionCounter::GetPacketCount() const
+		uint64_t RtpStreamRecv::TransmissionCounter::GetPacketCount() const
 		{
 			MS_TRACE();
 
-			size_t packetCount{ 0 };
+			uint64_t packetCount{ 0 };
 
 			for (const auto& spatialLayerCounter : this->spatialLayerCounters)
 			{
@@ -169,11 +170,11 @@ namespace RTC
 			return packetCount;
 		}
 
-		size_t RtpStreamRecv::TransmissionCounter::GetBytes() const
+		uint64_t RtpStreamRecv::TransmissionCounter::GetBytes() const
 		{
 			MS_TRACE();
 
-			size_t bytes{ 0 };
+			uint64_t bytes{ 0 };
 
 			for (const auto& spatialLayerCounter : this->spatialLayerCounters)
 			{
@@ -281,7 +282,7 @@ namespace RTC
 			  this->transmissionCounter.GetPacketCount(),
 			  this->transmissionCounter.GetBytes(),
 			  static_cast<uint64_t>(this->transmissionCounter.GetBitrate(nowMs)),
-			  &bitrateByLayer);
+			  std::addressof(bitrateByLayer));
 
 			return FBS::RtpStream::CreateStats(builder, FBS::RtpStream::StatsData::RecvStats, stats.Union());
 		}
@@ -345,7 +346,7 @@ namespace RTC
 					//
 					//   capture NTP clock = sender NTP clock + capture clock offset
 					const auto captureAtUs =
-					  Utils::Time::Ntp2TimeUs(ntp) - Utils::Time::Q32x32ToTimeUs(estimatedCaptureClockOffset);
+					  Utils::Time::NtpToTimeUs(ntp) - Utils::Time::Q32x32ToTimeUs(estimatedCaptureClockOffset);
 
 					// NOTE: A capture instant that is not positive means a capture clock offset
 					// that cannot be true, so there is nothing to store.
@@ -532,9 +533,16 @@ namespace RTC
 			// Calculate packets expected and lost.
 			auto expected = GetExpectedPackets();
 
-			if (expected > this->mediaTransmissionCounter.GetPacketCount())
+			// NOTE: The expected count is the extended sequence number arithmetic of RFC
+			// 3550, so it wraps at 32 bits, whereas the received one does not wrap at
+			// all. Each subtraction below is therefore made in the width that keeps it
+			// right: this one truncates the received count so that both wrap together,
+			// and the interval further down is taken in full width, where it is exact.
+			const auto received = static_cast<uint32_t>(this->mediaTransmissionCounter.GetPacketCount());
+
+			if (expected > received)
 			{
-				this->packetsLost = expected - this->mediaTransmissionCounter.GetPacketCount();
+				this->packetsLost = static_cast<int32_t>(expected - received);
 			}
 			else
 			{
@@ -542,24 +550,31 @@ namespace RTC
 			}
 
 			// Calculate fraction lost.
-			const uint32_t expectedInterval = expected - this->expectedPrior;
+			//
+			// NOTE: Reading the difference of the expected count as signed makes a
+			// sequence number re-sync, which restarts the count, come out negative.
+			const int64_t expectedInterval = static_cast<int32_t>(expected - this->expectedPrior);
 
 			this->expectedPrior = expected;
 
-			const uint32_t receivedInterval =
-			  this->mediaTransmissionCounter.GetPacketCount() - this->receivedPrior;
+			const auto receivedInterval =
+			  static_cast<int64_t>(this->mediaTransmissionCounter.GetPacketCount() - this->receivedPrior);
 
 			this->receivedPrior = this->mediaTransmissionCounter.GetPacketCount();
 
-			const int32_t lostInterval = expectedInterval - receivedInterval;
+			const int64_t lostInterval = expectedInterval - receivedInterval;
 
-			if (expectedInterval == 0 || lostInterval <= 0)
+			if (expectedInterval <= 0 || lostInterval <= 0)
 			{
 				this->fractionLost = 0;
 			}
 			else
 			{
-				this->fractionLost = std::round((static_cast<double>(lostInterval << 8) / expectedInterval));
+				// A fixed point number with 8 bits of fraction, so a whole interval lost
+				// gives 256, one more than the field can hold.
+				const double fraction = std::round(static_cast<double>(lostInterval << 8) / expectedInterval);
+
+				this->fractionLost = static_cast<uint8_t>(std::min(fraction, 255.0));
 			}
 
 			// Worst remote fraction lost is not worse than local one.
@@ -573,7 +588,11 @@ namespace RTC
 			else
 			{
 				// Recalculate packetsLost.
-				const uint32_t newLostInterval = (worstRemoteFractionLost * expectedInterval) >> 8;
+				//
+				// NOTE: The expected interval is not positive when a sequence number
+				// re-sync restarted the count, and then nothing was expected to be lost.
+				const auto newLostInterval = static_cast<uint32_t>(
+				  (worstRemoteFractionLost * std::max<int64_t>(expectedInterval, 0)) >> 8);
 
 				this->reportedPacketsLost += newLostInterval;
 
@@ -644,7 +663,7 @@ namespace RTC
 				ntp.fractions = report->GetNtpFrac();
 
 				this->lastSenderReportMapping = RTP::RtpStream::SenderReportMapping{
-					.ntpUs = Utils::Time::Ntp2TimeUs(ntp),
+					.ntpUs = Utils::Time::NtpToTimeUs(ntp),
 					.ts    = report->GetRtpTs(),
 				};
 			}
@@ -672,7 +691,7 @@ namespace RTC
 
 			// Get the NTP representation of the time at which the report arrived, which
 			// is what the round trip is measured against.
-			auto ntp = Utils::Time::TimeUs2Ntp(receivedAtUs + this->shared->GetNtpOffsetUs());
+			auto ntp = Utils::Time::TimeUsToNtp(receivedAtUs + this->shared->GetNtpOffsetUs());
 
 			// Get the compact NTP representation of the arrival time.
 			uint32_t compactNtp = (ntp.seconds & 0x0000FFFF) << 16;
@@ -682,21 +701,17 @@ namespace RTC
 			const uint32_t lastRr = ssrcInfo->GetLastReceiverReport();
 			const uint32_t dlrr   = ssrcInfo->GetDelaySinceLastReceiverReport();
 
-			// RTT in 1/2^16 second fractions.
-			uint32_t rttCompactNtp{ 0 };
-
 			// If no Receiver Extended Report was received by the remote endpoint yet,
-			// ignore lastRr and dlrr values in the Sender Extended Report.
-			if (lastRr && dlrr && (compactNtp > dlrr + lastRr))
+			// the Sender Extended Report carries no RTT, so the last one is kept.
+			if (lastRr == 0)
 			{
-				rttCompactNtp = compactNtp - dlrr - lastRr;
+				return;
 			}
 
-			this->rttMs = static_cast<float>(rttCompactNtp >> 16) * 1000;
-			this->rttMs += (static_cast<float>(rttCompactNtp & 0x0000FFFF) / 65536) * 1000;
-
-			// Avoid negative RTT value since it doesn't make sense.
-			this->rttMs = std::max(this->rttMs, 0.0f);
+			// NOTE: The subtraction wraps around along with the compact NTP
+			// representation, which is what the conversion expects.
+			this->rttMs =
+			  static_cast<float>(Utils::Time::CompactNtpRttToTimeUs(compactNtp - dlrr - lastRr)) / 1000;
 
 			// Tell it to the NackGenerator.
 			if (this->params.useNack)
@@ -798,7 +813,7 @@ namespace RTC
 
 				// Notify the listener.
 				static_cast<RTP::RtpStreamRecv::Listener*>(this->listener)
-				  ->OnRtpStreamSendRtcpPacket(this, &packet);
+				  ->OnRtpStreamSendRtcpPacket(this, std::addressof(packet));
 			}
 			else if (this->params.useFir)
 			{
@@ -816,7 +831,7 @@ namespace RTC
 
 				// Notify the listener.
 				static_cast<RTP::RtpStreamRecv::Listener*>(this->listener)
-				  ->OnRtpStreamSendRtcpPacket(this, &packet);
+				  ->OnRtpStreamSendRtcpPacket(this, std::addressof(packet));
 			}
 		}
 
@@ -869,8 +884,10 @@ namespace RTC
 			  static_cast<uint32_t>(((receivedAtUs % 1000000) * GetClockRate()) / 1000000);
 
 			// NOTE: Based on https://github.com/versatica/mediasoup/issues/1018.
-			auto transit = static_cast<int>(arrivalTs - rtpTimestamp);
-			int d        = transit - this->transit;
+			const auto transit = static_cast<int32_t>(arrivalTs - rtpTimestamp);
+			// NOTE: Wider than its operands because the difference of two int32_t does
+			// not fit in an int32_t, and neither would negating its lowest value.
+			int64_t d = static_cast<int64_t>(transit) - this->transit;
 
 			// First transit calculation, save and return.
 			if (this->transit == 0)
@@ -902,12 +919,12 @@ namespace RTC
 
 			// Calculate number of packets received in this interval.
 			const auto totalReceived = this->mediaTransmissionCounter.GetPacketCount();
-			const uint32_t received  = totalReceived - this->receivedPriorScore;
+			const auto received      = totalReceived - this->receivedPriorScore;
 
 			this->receivedPriorScore = totalReceived;
 
 			// Calculate number of packets lost in this interval.
-			uint32_t lost;
+			uint64_t lost;
 
 			if (expected < received)
 			{
@@ -920,13 +937,15 @@ namespace RTC
 
 			// Calculate number of packets repaired in this interval.
 			const auto totalRepaired = this->packetsRepaired;
-			uint32_t repaired        = totalRepaired - this->repairedPriorScore;
+
+			auto repaired = totalRepaired - this->repairedPriorScore;
 
 			this->repairedPriorScore = totalRepaired;
 
 			// Calculate number of packets retransmitted in this interval.
 			const auto totatRetransmitted = this->packetsRetransmitted;
-			uint32_t retransmitted        = totatRetransmitted - this->retransmittedPriorScore;
+
+			auto retransmitted = totatRetransmitted - this->retransmittedPriorScore;
 
 			this->retransmittedPriorScore = totatRetransmitted;
 
@@ -958,8 +977,10 @@ namespace RTC
 			{
 				if (HasRtx())
 				{
-					repaired = lost;
+					// NOTE: The excess has to be discounted before clamping, since once
+					// `repaired` has been clamped there is no excess left to tell.
 					retransmitted -= repaired - lost;
+					repaired = lost;
 				}
 				else
 				{
@@ -970,15 +991,15 @@ namespace RTC
 #if MS_LOG_DEV_LEVEL == 3
 			MS_DEBUG_TAG(
 			  score,
-			  "[totalExpected:%" PRIu32 ", totalReceived:%zu, totalRepaired:%zu",
+			  "[totalExpected:%" PRIu32 ", totalReceived:%" PRIu64 ", totalRepaired:%" PRIu64,
 			  totalExpected,
 			  totalReceived,
 			  totalRepaired);
 
 			MS_DEBUG_TAG(
 			  score,
-			  "fixed values [expected:%" PRIu32 ", received:%" PRIu32 ", lost:%" PRIu32
-			  ", repaired:%" PRIu32 ", retransmitted:%" PRIu32,
+			  "fixed values [expected:%" PRIu32 ", received:%" PRIu64 ", lost:%" PRIu64
+			  ", repaired:%" PRIu64 ", retransmitted:%" PRIu64,
 			  expected,
 			  received,
 			  lost,
@@ -996,7 +1017,7 @@ namespace RTC
 				repairedWeight *= static_cast<float>(repaired) / retransmitted;
 			}
 
-			lost -= repaired * repairedWeight;
+			lost = static_cast<uint64_t>(lost - (repaired * repairedWeight));
 
 			auto deliveredRatio = static_cast<float>(received - lost) / static_cast<float>(received);
 			auto score          = static_cast<uint8_t>(std::round(std::pow(deliveredRatio, 4) * 10));
@@ -1004,7 +1025,7 @@ namespace RTC
 #if MS_LOG_DEV_LEVEL == 3
 			MS_DEBUG_TAG(
 			  score,
-			  "[deliveredRatio:%f, repairedRatio:%f, repairedWeight:%f, new lost:%" PRIu32
+			  "[deliveredRatio:%f, repairedRatio:%f, repairedWeight:%f, new lost:%" PRIu64
 			  ", score:%" PRIu8 "]",
 			  deliveredRatio,
 			  repairedRatio,

package/worker/src/RTC/RTP/RtpStreamSend.cpp

@@ -84,7 +84,7 @@ namespace RTC
 			  baseStats,
 			  this->transmissionCounter.GetPacketCount(),
 			  this->transmissionCounter.GetBytes(),
-			  static_cast<uint64_t>(this->transmissionCounter.GetBitrate(nowMs)));
+			  static_cast<uint64_t>(this->transmissionCounter.GetBitrate(nowMs).value_or(0)));
 
 			return FBS::RtpStream::CreateStats(builder, FBS::RtpStream::StatsData::SendStats, stats.Union());
 		}
@@ -280,7 +280,7 @@ namespace RTC
 
 			// Get the NTP representation of the time at which the Receiver Report
 			// arrived, which is what the round trip is measured against.
-			auto ntp = Utils::Time::TimeUs2Ntp(receivedAtUs + this->shared->GetNtpOffsetUs());
+			auto ntp = Utils::Time::TimeUsToNtp(receivedAtUs + this->shared->GetNtpOffsetUs());
 
 			// Get the compact NTP representation of the arrival time.
 			uint32_t compactNtp = (ntp.seconds & 0x0000FFFF) << 16;
@@ -290,22 +290,17 @@ namespace RTC
 			const uint32_t lastSr = report->GetLastSenderReport();
 			const uint32_t dlsr   = report->GetDelaySinceLastSenderReport();
 
-			// RTT in 1/2^16 second fractions.
-			uint32_t rttCompactNtp{ 0 };
-
-			// If no Sender Report was received by the remote endpoint yet, ignore lastSr
-			// and dlsr values in the Receiver Report.
-			if (lastSr && dlsr && (compactNtp > dlsr + lastSr))
+			// If no Sender Report was received by the remote endpoint yet, the Receiver
+			// Report carries no RTT, so the last one is kept.
+			//
+			// NOTE: The subtraction wraps around along with the compact NTP
+			// representation, which is what the conversion expects.
+			if (lastSr != 0)
 			{
-				rttCompactNtp = compactNtp - dlsr - lastSr;
+				this->rttMs =
+				  static_cast<float>(Utils::Time::CompactNtpRttToTimeUs(compactNtp - dlsr - lastSr)) / 1000;
 			}
 
-			this->rttMs = static_cast<float>(rttCompactNtp >> 16) * 1000;
-			this->rttMs += (static_cast<float>(rttCompactNtp & 0x0000FFFF) / 65536) * 1000;
-
-			// Avoid negative RTT value since it doesn't make sense.
-			this->rttMs = std::max(this->rttMs, 0.0f);
-
 			this->packetsLost  = report->GetTotalLost();
 			this->fractionLost = report->GetFractionLost();
 			this->jitter       = static_cast<float>(report->GetJitter());
@@ -345,7 +340,7 @@ namespace RTC
 				return nullptr;
 			}
 
-			auto ntp     = Utils::Time::TimeUs2Ntp(nowUs + this->shared->GetNtpOffsetUs());
+			auto ntp     = Utils::Time::TimeUsToNtp(nowUs + this->shared->GetNtpOffsetUs());
 			auto* report = new RTC::RTCP::SenderReport();
 
 			// Calculate TS difference between now and the instant at which the media in the
@@ -358,8 +353,10 @@ namespace RTC
 			const auto rtpTs     = static_cast<uint32_t>(this->maxPacketTs + diffTs);
 
 			report->SetSsrc(GetSsrc());
-			report->SetPacketCount(this->transmissionCounter.GetPacketCount());
-			report->SetOctetCount(this->transmissionCounter.GetBytes());
+			// NOTE: Both fields are 32 bits wide and are meant to wrap, so the counters
+			// are truncated into them on purpose.
+			report->SetPacketCount(static_cast<uint32_t>(this->transmissionCounter.GetPacketCount()));
+			report->SetOctetCount(static_cast<uint32_t>(this->transmissionCounter.GetBytes()));
 			report->SetNtpSec(ntp.seconds);
 			report->SetNtpFrac(ntp.fractions);
 			report->SetRtpTs(rtpTs);
@@ -486,7 +483,7 @@ namespace RTC
 
 			// Look for each requested packet.
 			const int64_t nowMs = this->shared->GetTimeMs();
-			const int64_t rttMs = (this->rttMs > 0.0f ? this->rttMs : DefaultRttMs);
+			const int64_t rttMs = (this->rttMs > 0.0f ? static_cast<int64_t>(this->rttMs) : DefaultRttMs);
 			uint16_t currentSeq = seq;
 			bool requested{ true };
 			size_t containerIdx{ 0 };
@@ -586,14 +583,15 @@ namespace RTC
 			MS_TRACE();
 
 			// Calculate number of packets sent in this interval.
-			auto totalSent = this->transmissionCounter.GetPacketCount();
-			auto sent      = totalSent - this->sentPriorScore;
+			const auto totalSent = this->transmissionCounter.GetPacketCount();
+			const auto sent      = totalSent - this->sentPriorScore;
 
 			this->sentPriorScore = totalSent;
 
 			// Calculate number of packets lost in this interval.
 			const int32_t totalLost = report->GetTotalLost() > 0 ? report->GetTotalLost() : 0;
-			uint32_t lost;
+
+			uint64_t lost;
 
 			if (totalLost < this->lostPriorScore)
 			{
@@ -607,14 +605,15 @@ namespace RTC
 			this->lostPriorScore = totalLost;
 
 			// Calculate number of packets repaired in this interval.
-			auto totalRepaired = this->packetsRepaired;
-			uint32_t repaired  = totalRepaired - this->repairedPriorScore;
+			const auto totalRepaired = this->packetsRepaired;
+
+			auto repaired = totalRepaired - this->repairedPriorScore;
 
 			this->repairedPriorScore = totalRepaired;
 
 			// Calculate number of packets retransmitted in this interval.
-			auto totatRetransmitted      = this->packetsRetransmitted;
-			const uint32_t retransmitted = totatRetransmitted - this->retransmittedPriorScore;
+			const auto totatRetransmitted = this->packetsRetransmitted;
+			const auto retransmitted      = totatRetransmitted - this->retransmittedPriorScore;
 
 			this->retransmittedPriorScore = totatRetransmitted;
 
@@ -626,20 +625,21 @@ namespace RTC
 				return;
 			}
 
-			lost     = std::min<size_t>(lost, sent);
+			lost     = std::min(lost, sent);
 			repaired = std::min(repaired, lost);
 
 #if MS_LOG_DEV_LEVEL == 3
 			MS_DEBUG_TAG(
 			  score,
-			  "[totalSent:%zu, totalLost:%" PRIi32 ", totalRepaired:%zu",
+			  "[totalSent:%" PRIu64 ", totalLost:%" PRIi32 ", totalRepaired:%" PRIu64,
 			  totalSent,
 			  totalLost,
 			  totalRepaired);
 
 			MS_DEBUG_TAG(
 			  score,
-			  "fixed values [sent:%zu, lost:%" PRIu32 ", repaired:%" PRIu32 ", retransmitted:%" PRIu32,
+			  "fixed values [sent:%" PRIu64 ", lost:%" PRIu64 ", repaired:%" PRIu64
+			  ", retransmitted:%" PRIu64,
 			  sent,
 			  lost,
 			  repaired,
@@ -656,7 +656,7 @@ namespace RTC
 				repairedWeight *= static_cast<float>(repaired) / retransmitted;
 			}
 
-			lost -= repaired * repairedWeight;
+			lost = static_cast<uint64_t>(lost - (repaired * repairedWeight));
 
 			auto deliveredRatio = static_cast<float>(sent - lost) / static_cast<float>(sent);
 			auto score          = static_cast<uint8_t>(std::round(std::pow(deliveredRatio, 4) * 10));
@@ -664,7 +664,7 @@ namespace RTC
 #if MS_LOG_DEV_LEVEL == 3
 			MS_DEBUG_TAG(
 			  score,
-			  "[deliveredRatio:%f, repairedRatio:%f, repairedWeight:%f, new lost:%" PRIu32
+			  "[deliveredRatio:%f, repairedRatio:%f, repairedWeight:%f, new lost:%" PRIu64
 			  ", score:%" PRIu8 "]",
 			  deliveredRatio,
 			  repairedRatio,

package/worker/src/RTC/RTP/RtxStream.cpp

@@ -4,6 +4,7 @@
 #include "RTC/RTP/RtxStream.hpp"
 #include "Logger.hpp"
 #include "Utils.hpp"
+#include <cmath> // std::round()
 
 namespace RTC
 {
@@ -96,9 +97,16 @@ namespace RTC
 			// Calculate packets xxpected and lost.
 			auto expected = GetExpectedPackets();
 
-			if (expected > this->packetsCount)
+			// NOTE: The expected count is the extended sequence number arithmetic of RFC
+			// 3550, so it wraps at 32 bits, whereas the received one does not wrap at
+			// all. Each subtraction below is therefore made in the width that keeps it
+			// right: this one truncates the received count so that both wrap together,
+			// and the interval further down is taken in full width, where it is exact.
+			const auto received = static_cast<uint32_t>(this->packetsCount);
+
+			if (expected > received)
 			{
-				this->packetsLost = expected - this->packetsCount;
+				this->packetsLost = static_cast<int32_t>(expected - received);
 			}
 			else
 			{
@@ -106,23 +114,30 @@ namespace RTC
 			}
 
 			// Calculate fraction lost.
-			const uint32_t expectedInterval = expected - this->expectedPrior;
+			//
+			// NOTE: Reading the difference of the expected count as signed makes a
+			// sequence number re-sync, which restarts the count, come out negative.
+			const int64_t expectedInterval = static_cast<int32_t>(expected - this->expectedPrior);
 
 			this->expectedPrior = expected;
 
-			const uint32_t receivedInterval = this->packetsCount - this->receivedPrior;
+			const auto receivedInterval = static_cast<int64_t>(this->packetsCount - this->receivedPrior);
 
 			this->receivedPrior = this->packetsCount;
 
-			const int32_t lostInterval = expectedInterval - receivedInterval;
+			const int64_t lostInterval = expectedInterval - receivedInterval;
 
-			if (expectedInterval == 0 || lostInterval <= 0)
+			if (expectedInterval <= 0 || lostInterval <= 0)
 			{
 				this->fractionLost = 0;
 			}
 			else
 			{
-				this->fractionLost = std::round((static_cast<double>(lostInterval << 8) / expectedInterval));
+				// A fixed point number with 8 bits of fraction, so a whole interval lost
+				// gives 256, one more than the field can hold.
+				const double fraction = std::round(static_cast<double>(lostInterval << 8) / expectedInterval);
+
+				this->fractionLost = static_cast<uint8_t>(std::min(fraction, 255.0));
 			}
 
 			this->reportedPacketsLost += (this->packetsLost - prevPacketsLost);