mediasoup 3.24.2 → 3.26.0

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

@@ -299,6 +299,40 @@ namespace RTC
 			// Calculate jitter.
 			CalculateJitter(packet->GetTimestamp());
 
+			// Store the capture instant if the packet carries it.
+			{
+				uint64_t absCaptureTimestamp{ 0 };
+				int64_t estimatedCaptureClockOffset{ 0 };
+
+				// NOTE: A zeroed capture timestamp gives no capture instant to store.
+				if (packet->ReadAbsCaptureTime(absCaptureTimestamp, estimatedCaptureClockOffset) && absCaptureTimestamp != 0)
+				{
+					Utils::Time::Ntp ntp{}; // NOLINT(cppcoreguidelines-pro-type-member-init)
+
+					ntp.seconds   = static_cast<uint32_t>(absCaptureTimestamp >> 32);
+					ntp.fractions = static_cast<uint32_t>(absCaptureTimestamp);
+
+					// The capture timestamp belongs to the clock of the capture system, which is
+					// not the clock of the sender of this stream when the media comes from
+					// somewhere else. The capture clock offset gives the instant back in the clock
+					// of the sender, which is the one this stream is estimated against:
+					//
+					//   capture NTP clock = sender NTP clock + capture clock offset
+					const auto captureMs = static_cast<int64_t>(Utils::Time::Ntp2TimeMs(ntp)) -
+					                       Utils::Time::Q32x32ToTimeMs(estimatedCaptureClockOffset);
+
+					// NOTE: A capture instant that is not positive means a capture clock offset
+					// that cannot be true, so there is nothing to store.
+					if (captureMs > 0)
+					{
+						this->lastAbsCaptureTime = AbsCaptureTime{
+							.ts    = packet->GetTimestamp(),
+							.ntpMs = static_cast<uint64_t>(captureMs),
+						};
+					}
+				}
+			}
+
 			// Increase transmission counter.
 			this->transmissionCounter.Update(packet);
 
@@ -452,18 +486,15 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			uint8_t worstRemoteFractionLost{ 0 };
+			// Ask the listener for the worst remote fraction lost.
+			const uint8_t worstRemoteFractionLost =
+			  this->params.useInBandFec ? static_cast<RTP::RtpStreamRecv::Listener*>(this->listener)
+			                                ->OnRtpStreamNeedWorstRemoteFractionLost(this)
+			                            : 0;
 
-			if (this->params.useInBandFec)
+			if (worstRemoteFractionLost > 0)
 			{
-				// Notify the listener so we'll get the worst remote fraction lost.
-				static_cast<RTP::RtpStreamRecv::Listener*>(this->listener)
-				  ->OnRtpStreamNeedWorstRemoteFractionLost(this, worstRemoteFractionLost);
-
-				if (worstRemoteFractionLost > 0)
-				{
-					MS_DEBUG_TAG(rtcp, "using worst remote fraction lost:%" PRIu8, worstRemoteFractionLost);
-				}
+				MS_DEBUG_TAG(rtcp, "using worst remote fraction lost:%" PRIu8, worstRemoteFractionLost);
 			}
 
 			auto* report = new RTC::RTCP::ReceiverReport();
@@ -528,17 +559,19 @@ namespace RTC
 			report->SetLastSeq(static_cast<uint32_t>(this->maxSeq) + this->cycles);
 			report->SetJitter(this->jitter);
 
-			if (this->lastSrReceived != 0)
+			if (this->lastSenderReportTiming.has_value())
 			{
+				const auto& senderReportTiming = this->lastSenderReportTiming.value();
 				// Get delay in milliseconds.
-				auto delayMs = static_cast<uint32_t>(this->shared->GetTimeMs() - this->lastSrReceived);
+				auto delayMs =
+				  static_cast<uint32_t>(this->shared->GetTimeMs() - senderReportTiming.receivedMs);
 				// Express delay in units of 1/65536 seconds.
 				uint32_t dlsr = (delayMs / 1000) << 16;
 
 				dlsr |= uint32_t{ (delayMs % 1000) * 65536 / 1000 };
 
 				report->SetDelaySinceLastSenderReport(dlsr);
-				report->SetLastSenderReport(this->lastSrTimestamp);
+				report->SetLastSenderReport(senderReportTiming.compactNtp);
 			}
 			else
 			{
@@ -565,18 +598,31 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			this->lastSrReceived  = this->shared->GetTimeMs();
-			this->lastSrTimestamp = report->GetNtpSec() << 16;
-			this->lastSrTimestamp += report->GetNtpFrac() >> 16;
-
 			// Update info about last Sender Report.
-			Utils::Time::Ntp ntp{}; // NOLINT(cppcoreguidelines-pro-type-member-init)
+			//
+			// NOTE: A sender with no wall clock may report a zeroed NTP timestamp, which
+			// gives nothing to store.
+			if (report->GetNtpSec() != 0 || report->GetNtpFrac() != 0)
+			{
+				uint32_t compactNtp = report->GetNtpSec() << 16;
+
+				compactNtp += report->GetNtpFrac() >> 16;
 
-			ntp.seconds   = report->GetNtpSec();
-			ntp.fractions = report->GetNtpFrac();
+				this->lastSenderReportTiming = SenderReportTiming{
+					.compactNtp = compactNtp,
+					.receivedMs = this->shared->GetTimeMs(),
+				};
 
-			this->lastSenderReportNtpMs = Utils::Time::Ntp2TimeMs(ntp);
-			this->lastSenderReportTs    = report->GetRtpTs();
+				Utils::Time::Ntp ntp{}; // NOLINT(cppcoreguidelines-pro-type-member-init)
+
+				ntp.seconds   = report->GetNtpSec();
+				ntp.fractions = report->GetNtpFrac();
+
+				this->lastSenderReportMapping = RTP::RtpStream::SenderReportMapping{
+					.ntpMs = Utils::Time::Ntp2TimeMs(ntp),
+					.ts    = report->GetRtpTs(),
+				};
+			}
 
 			// Update the score with the current RR.
 			UpdateScore();
@@ -600,7 +646,7 @@ namespace RTC
 
 			// Get the NTP representation of the current timestamp.
 			const uint64_t nowMs = this->shared->GetTimeMs();
-			auto ntp             = Utils::Time::TimeMs2Ntp(nowMs);
+			auto ntp             = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
 
 			// Get the compact NTP representation of the current timestamp.
 			uint32_t compactNtp = (ntp.seconds & 0x0000FFFF) << 16;
@@ -634,6 +680,78 @@ namespace RTC
 			}
 		}
 
+		std::optional<uint64_t> RtpStreamRecv::GetRemoteCaptureMsFromAbsCaptureTime(uint32_t ts) const
+		{
+			MS_TRACE();
+
+			if (!this->lastAbsCaptureTime.has_value())
+			{
+				return std::nullopt;
+			}
+
+			const auto& absCaptureTime = this->lastAbsCaptureTime.value();
+
+			return InterpolateRemoteCaptureMs(
+			  absCaptureTime.ntpMs, absCaptureTime.ts, ts, RtpStreamRecv::MaxAbsCaptureTimeInterpolationMs);
+		}
+
+		std::optional<uint64_t> RtpStreamRecv::GetRemoteCaptureMsFromSenderReport(uint32_t ts) const
+		{
+			MS_TRACE();
+
+			if (!this->lastSenderReportMapping.has_value())
+			{
+				return std::nullopt;
+			}
+
+			const auto& senderReportMapping = this->lastSenderReportMapping.value();
+
+			return InterpolateRemoteCaptureMs(
+			  senderReportMapping.ntpMs,
+			  senderReportMapping.ts,
+			  ts,
+			  RtpStreamRecv::MaxSenderReportInterpolationMs);
+		}
+
+		std::optional<uint64_t> RtpStreamRecv::InterpolateRemoteCaptureMs(
+		  uint64_t referenceNtpMs, uint32_t referenceTs, uint32_t ts, uint64_t maxDistanceMs) const
+		{
+			MS_TRACE();
+
+			const auto clockRate = GetClockRate();
+
+			if (clockRate == 0)
+			{
+				return std::nullopt;
+			}
+
+			// Distance in RTP timestamp units, taking wrap around into account.
+			const auto distanceTs    = static_cast<int64_t>(static_cast<int32_t>(ts - referenceTs));
+			const int64_t distanceMs = (distanceTs * 1000) / static_cast<int64_t>(clockRate);
+			// NOTE: The negation is safe since `distanceMs` comes from a 32 bits
+			// distance scaled down by the clock rate.
+			const auto absDistanceMs = static_cast<uint64_t>(distanceMs < 0 ? -distanceMs : distanceMs);
+
+			if (absDistanceMs > maxDistanceMs)
+			{
+				return std::nullopt;
+			}
+
+			const int64_t captureMs = static_cast<int64_t>(referenceNtpMs) + distanceMs;
+
+			// The reference does not map into a valid capture instant, so the remote
+			// endpoint is reporting nonsense.
+			if (captureMs < 0)
+			{
+				MS_WARN_2TAGS(
+				  rtp, rtcp, "invalid interpolated capture instant [distanceMs:%" PRIi64 "]", distanceMs);
+
+				return std::nullopt;
+			}
+
+			return static_cast<uint64_t>(captureMs);
+		}
+
 		void RtpStreamRecv::RequestKeyFrame()
 		{
 			MS_TRACE();
@@ -788,6 +906,15 @@ namespace RTC
 				return;
 			}
 
+			// We expected packets but received none of them, so there is nothing to
+			// compute (and ratios below would divide by zero).
+			if (received == 0)
+			{
+				RTP::RtpStream::UpdateScore(0);
+
+				return;
+			}
+
 			lost = std::min(lost, received);
 
 			if (repaired > lost)

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

@@ -21,11 +21,6 @@ namespace RTC
 		  MaxRequestedPackets + 1);
 		static constexpr uint32_t DefaultRtt{ 100u };
 
-		/* Class Static. */
-
-		const uint32_t RtpStreamSend::MaxRetransmissionDelayForVideoMs{ 2000u };
-		const uint32_t RtpStreamSend::MaxRetransmissionDelayForAudioMs{ 1000u };
-
 		/* Instance methods. */
 
 		RtpStreamSend::RtpStreamSend(
@@ -283,7 +278,7 @@ namespace RTC
 
 			// Get the NTP representation of the current timestamp.
 			const uint64_t nowMs = this->shared->GetTimeMs();
-			auto ntp             = Utils::Time::TimeMs2Ntp(nowMs);
+			auto ntp             = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
 
 			// Get the compact NTP representation of the current timestamp.
 			uint32_t compactNtp = (ntp.seconds & 0x0000FFFF) << 16;
@@ -322,9 +317,14 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			this->lastRrReceivedMs = this->shared->GetTimeMs();
-			this->lastRrTimestamp  = report->GetNtpSec() << 16;
-			this->lastRrTimestamp += report->GetNtpFrac() >> 16;
+			uint32_t compactNtp = report->GetNtpSec() << 16;
+
+			compactNtp += report->GetNtpFrac() >> 16;
+
+			this->lastReceiverReferenceTime = ReceiverReferenceTime{
+				.compactNtp = compactNtp,
+				.receivedMs = this->shared->GetTimeMs(),
+			};
 		}
 
 		RTC::RTCP::SenderReport* RtpStreamSend::GetRtcpSenderReport(uint64_t nowMs)
@@ -336,23 +336,37 @@ namespace RTC
 				return nullptr;
 			}
 
-			auto ntp     = Utils::Time::TimeMs2Ntp(nowMs);
+			// A stream that stopped sending cannot tell where its RTP timeline is now, and
+			// extrapolating would claim RTP timestamps of packets never sent.
+			if (nowMs - this->maxPacketMs > RtpStreamSend::MaxSenderReportReferenceAgeMs)
+			{
+				return nullptr;
+			}
+
+			auto ntp     = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
 			auto* report = new RTC::RTCP::SenderReport();
 
-			// Calculate TS difference between now and maxPacketMs.
-			auto diffMs = nowMs - this->maxPacketMs;
-			auto diffTs = diffMs * GetClockRate() / 1000;
+			// Calculate TS difference between now and the instant at which the media in the
+			// packet holding the highest RTP timestamp was captured, falling back to the
+			// instant that packet was seen while the capture instant cannot be told.
+			const uint64_t referenceMs = this->maxPacketCaptureMs.value_or(this->maxPacketMs);
+			// NOTE: The capture instant is an estimation, so it may land ahead of now.
+			const uint64_t diffMs = nowMs > referenceMs ? nowMs - referenceMs : 0;
+			const uint64_t diffTs = diffMs * GetClockRate() / 1000;
+			const auto rtpTs      = static_cast<uint32_t>(this->maxPacketTs + diffTs);
 
 			report->SetSsrc(GetSsrc());
 			report->SetPacketCount(this->transmissionCounter.GetPacketCount());
 			report->SetOctetCount(this->transmissionCounter.GetBytes());
 			report->SetNtpSec(ntp.seconds);
 			report->SetNtpFrac(ntp.fractions);
-			report->SetRtpTs(this->maxPacketTs + diffTs);
+			report->SetRtpTs(rtpTs);
 
 			// Update info about last Sender Report.
-			this->lastSenderReportNtpMs = nowMs;
-			this->lastSenderReportTs    = this->maxPacketTs + diffTs;
+			this->lastSenderReportMapping = RTP::RtpStream::SenderReportMapping{
+				.ntpMs = nowMs,
+				.ts    = rtpTs,
+			};
 
 			return report;
 		}
@@ -361,13 +375,14 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			if (this->lastRrReceivedMs == 0u)
+			if (!this->lastReceiverReferenceTime.has_value())
 			{
 				return nullptr;
 			}
 
+			const auto& receiverReferenceTime = this->lastReceiverReferenceTime.value();
 			// Get delay in milliseconds.
-			auto delayMs = static_cast<uint32_t>(nowMs - this->lastRrReceivedMs);
+			auto delayMs = static_cast<uint32_t>(nowMs - receiverReferenceTime.receivedMs);
 			// Express delay in units of 1/65536 seconds.
 			uint32_t dlrr = (delayMs / 1000) << 16;
 
@@ -377,7 +392,7 @@ namespace RTC
 
 			ssrcInfo->SetSsrc(GetSsrc());
 			ssrcInfo->SetDelaySinceLastReceiverReport(dlrr);
-			ssrcInfo->SetLastReceiverReport(this->lastRrTimestamp);
+			ssrcInfo->SetLastReceiverReport(receiverReferenceTime.compactNtp);
 
 			return ssrcInfo;
 		}

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

@@ -138,17 +138,18 @@ namespace RTC
 			// NOTE: Do not calculate any jitter.
 			report->SetJitter(0);
 
-			if (this->lastSrReceived != 0)
+			if (this->lastSenderReportTiming.has_value())
 			{
+				const auto& senderReportTiming = this->lastSenderReportTiming.value();
 				// Get delay in milliseconds.
-				const uint32_t delayMs = this->shared->GetTimeMs() - this->lastSrReceived;
+				const uint32_t delayMs = this->shared->GetTimeMs() - senderReportTiming.receivedMs;
 				// Express delay in units of 1/65536 seconds.
 				uint32_t dlsr = (delayMs / 1000) << 16;
 
 				dlsr |= uint32_t{ (delayMs % 1000) * 65536 / 1000 };
 
 				report->SetDelaySinceLastSenderReport(dlsr);
-				report->SetLastSenderReport(this->lastSrTimestamp);
+				report->SetLastSenderReport(senderReportTiming.compactNtp);
 			}
 			else
 			{
@@ -163,9 +164,14 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			this->lastSrReceived  = this->shared->GetTimeMs();
-			this->lastSrTimestamp = report->GetNtpSec() << 16;
-			this->lastSrTimestamp += report->GetNtpFrac() >> 16;
+			uint32_t compactNtp = report->GetNtpSec() << 16;
+
+			compactNtp += report->GetNtpFrac() >> 16;
+
+			this->lastSenderReportTiming = SenderReportTiming{
+				.compactNtp = compactNtp,
+				.receivedMs = this->shared->GetTimeMs(),
+			};
 		}
 
 		bool RtxStream::UpdateSeq(const RTP::Packet* packet)

package/worker/src/RTC/RemoteCaptureTimeEstimator.cpp

@@ -0,0 +1,77 @@
+#define MS_CLASS "RTC::RemoteCaptureTimeEstimator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/RemoteCaptureTimeEstimator.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	/* Instance methods. */
+
+	void RemoteCaptureTimeEstimator::UpdateSource(bool absCaptureTimeNegotiated)
+	{
+		MS_TRACE();
+
+		// Once the Sender Report source has been chosen there is no way back.
+		if (this->source == RemoteCaptureTimeEstimator::Source::SENDER_REPORT)
+		{
+			if (absCaptureTimeNegotiated)
+			{
+				MS_WARN_2TAGS(rtp, rtcp, "cannot move capture instant source back to abs-capture-time");
+			}
+
+			return;
+		}
+
+		this->source = absCaptureTimeNegotiated ? RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME
+		                                        : RemoteCaptureTimeEstimator::Source::SENDER_REPORT;
+
+		MS_DEBUG_2TAGS(
+		  rtp,
+		  rtcp,
+		  "capture instant source set to %s",
+		  this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME ? "abs-capture-time"
+		                                                                       : "Sender Report");
+	}
+
+	void RemoteCaptureTimeEstimator::SenderReportReceived(const RTC::RTP::RtpStreamRecv* rtpStream)
+	{
+		MS_TRACE();
+
+		const auto senderReportMapping    = rtpStream->GetSenderReportMapping();
+		const auto senderReportReceivedMs = rtpStream->GetSenderReportReceivedMs();
+
+		// Both are stored together, so either both are set or none of them is.
+		if (!senderReportMapping.has_value() || !senderReportReceivedMs.has_value())
+		{
+			return;
+		}
+
+		this->clockOffsetEstimator.AddSenderReport(
+		  senderReportMapping.value().ntpMs,
+		  senderReportReceivedMs.value(),
+		  static_cast<uint32_t>(rtpStream->GetRtt()));
+	}
+
+	std::optional<uint64_t> RemoteCaptureTimeEstimator::GetLocalCaptureMs(
+	  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const
+	{
+		MS_TRACE();
+
+		if (!this->source.has_value())
+		{
+			return std::nullopt;
+		}
+
+		const auto remoteCaptureMs = this->source == RemoteCaptureTimeEstimator::Source::ABS_CAPTURE_TIME
+		                               ? rtpStream->GetRemoteCaptureMsFromAbsCaptureTime(ts)
+		                               : rtpStream->GetRemoteCaptureMsFromSenderReport(ts);
+
+		if (!remoteCaptureMs.has_value())
+		{
+			return std::nullopt;
+		}
+
+		return this->clockOffsetEstimator.RemoteMsToLocalMs(remoteCaptureMs.value());
+	}
+} // namespace RTC

package/worker/src/RTC/RemoteClockOffsetEstimator.cpp

@@ -0,0 +1,106 @@
+#define MS_CLASS "RTC::RemoteClockOffsetEstimator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/RemoteClockOffsetEstimator.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	/* Instance methods. */
+
+	RemoteClockOffsetEstimator::RemoteClockOffsetEstimator()
+	{
+		MS_TRACE();
+
+		this->samples.reserve(RemoteClockOffsetEstimator::WindowSize);
+	}
+
+	void RemoteClockOffsetEstimator::AddSenderReport(
+	  uint64_t remoteNtpMs, uint64_t localArrivalMs, uint32_t rttMs)
+	{
+		MS_TRACE();
+
+		// Ignore Sender Reports with no NTP timestamp.
+		if (remoteNtpMs == 0)
+		{
+			MS_DEBUG_DEV("ignoring Sender Report with no NTP timestamp");
+
+			return;
+		}
+
+		// Ignore a Sender Report belonging to a compound packet already accounted
+		// for. Otherwise a single delayed compound packet would contribute as many
+		// samples as streams it reports about, and hence bias the median.
+		if (localArrivalMs == this->lastLocalArrivalMs)
+		{
+			return;
+		}
+
+		this->lastLocalArrivalMs = localArrivalMs;
+
+		// The sample holds the clock offset plus the one way delay of this Sender
+		// Report. Assume a symmetric path and remove half of the RTT.
+		const int64_t sample = static_cast<int64_t>(localArrivalMs) -
+		                       static_cast<int64_t>(remoteNtpMs) - (static_cast<int64_t>(rttMs) / 2);
+
+		if (this->samples.size() == RemoteClockOffsetEstimator::WindowSize)
+		{
+			this->samples.erase(this->samples.begin());
+		}
+
+		this->samples.push_back(sample);
+
+		UpdateOffsetMs();
+	}
+
+	std::optional<uint64_t> RemoteClockOffsetEstimator::RemoteMsToLocalMs(uint64_t remoteMs) const
+	{
+		MS_TRACE();
+
+		if (!this->offsetMs.has_value())
+		{
+			return std::nullopt;
+		}
+
+		const int64_t localMs = static_cast<int64_t>(remoteMs) + this->offsetMs.value();
+
+		// The given time does not map into our clock, so the input is bogus.
+		if (localMs < 0)
+		{
+			MS_WARN_2TAGS(
+			  rtp, rtcp, "remote time does not map into our clock [remoteMs:%" PRIu64 "]", remoteMs);
+
+			return std::nullopt;
+		}
+
+		return static_cast<uint64_t>(localMs);
+	}
+
+	void RemoteClockOffsetEstimator::Reset()
+	{
+		MS_TRACE();
+
+		this->samples.clear();
+		this->lastLocalArrivalMs = 0;
+		this->offsetMs.reset();
+	}
+
+	void RemoteClockOffsetEstimator::UpdateOffsetMs()
+	{
+		MS_TRACE();
+
+		if (this->samples.size() < RemoteClockOffsetEstimator::MinSampleCount)
+		{
+			return;
+		}
+
+		// Take the median of the window. While the window is not full its size may
+		// be even, in which case the upper of the two middle samples is taken.
+		std::vector<int64_t> sortedSamples(this->samples);
+		const auto middle = sortedSamples.begin() + (sortedSamples.size() / 2);
+
+		std::nth_element(sortedSamples.begin(), middle, sortedSamples.end());
+
+		this->offsetMs = *middle;
+	}
+} // namespace RTC

package/worker/src/RTC/Router.cpp

@@ -701,20 +701,22 @@ namespace RTC
 		}
 	}
 
-	void Router::OnTransportNeedWorstRemoteFractionLost(
-	  RTC::Transport* /*transport*/,
-	  RTC::Producer* producer,
-	  uint32_t mappedSsrc,
-	  uint8_t& worstRemoteFractionLost)
+	uint8_t Router::OnTransportNeedWorstRemoteFractionLost(
+	  RTC::Transport* /*transport*/, RTC::Producer* producer, uint32_t mappedSsrc)
 	{
 		MS_TRACE();
 
-		auto& consumers = this->mapProducerConsumers.at(producer);
+		const auto& consumers = this->mapProducerConsumers.at(producer);
 
-		for (auto* consumer : consumers)
+		uint8_t worstRemoteFractionLost{ 0 };
+
+		for (const auto* consumer : consumers)
 		{
-			consumer->NeedWorstRemoteFractionLost(mappedSsrc, worstRemoteFractionLost);
+			worstRemoteFractionLost =
+			  std::max(consumer->GetWorstRemoteFractionLost(mappedSsrc), worstRemoteFractionLost);
 		}
+
+		return worstRemoteFractionLost;
 	}
 
 	void Router::OnTransportNewConsumer(

package/worker/src/RTC/RtpDictionaries/RtcpParameters.cpp

@@ -2,6 +2,7 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
 #include "RTC/RtpDictionaries.hpp"
 
 namespace RTC
@@ -12,10 +13,19 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		// cname is optional.
-		if (flatbuffers::IsFieldPresent(data, FBS::RtpParameters::RtcpParameters::VT_CNAME))
+		// cname is mandatory. It is what identifies the streams that come from a same
+		// sender, and hence share its clock, so media of a sender that comes with no CNAME
+		// cannot be synchronized against the rest of the media of that same sender.
+		if (!flatbuffers::IsFieldPresent(data, FBS::RtpParameters::RtcpParameters::VT_CNAME))
 		{
-			this->cname = data->cname()->str();
+			MS_THROW_TYPE_ERROR("missing cname");
+		}
+
+		this->cname = data->cname()->str();
+
+		if (this->cname.empty())
+		{
+			MS_THROW_TYPE_ERROR("empty cname");
 		}
 
 		// reducedSize is optional, default value is true.

package/worker/src/RTC/SCTP/packet/chunks/SackChunk.cpp

@@ -204,14 +204,18 @@ namespace RTC
 				const uint16_t start = GetAckBlockStartAt(idx);
 				const uint16_t end   = GetAckBlockEndAt(idx);
 
-				if (end > start)
+				// NOTE: A block with `end == start` is a legal single TSN block, so it
+				// must be kept. dcSCTP's `ChunkValidators::Clean()` uses `end > start`
+				// here, which contradicts its own `ChunkValidators::Validate()` (it
+				// accepts `end == start`) and needlessly discards valid ack information.
+				if (end >= start)
 				{
 					gapAckBlocks.emplace_back(start, end);
 				}
 			}
 
 			// Not more than at most one remaining? Exit early.
-			if (gapAckBlocks.size() == 1)
+			if (gapAckBlocks.size() <= 1)
 			{
 				return gapAckBlocks;
 			}