mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/Producer.cpp

@@ -20,7 +20,7 @@ namespace RTC
 
 	static constexpr size_t ProducerSendBufferSize{ 65536 };
 	static thread_local uint8_t ProducerSendBuffer[ProducerSendBufferSize];
-	static constexpr uint32_t SendNackDelay{ 10u }; // In ms.
+	static constexpr int64_t SendNackDelayMs{ 10 };
 
 	/* Instance methods. */
 
@@ -195,20 +195,20 @@ namespace RTC
 		// Set the RTCP report generation interval.
 		if (this->kind == RTC::Media::Kind::AUDIO)
 		{
-			this->maxRtcpInterval = RTC::RTCP::MaxAudioIntervalMs;
+			this->maxRtcpIntervalMs = RTC::RTCP::MaxAudioIntervalMs;
 		}
 		else
 		{
-			this->maxRtcpInterval = RTC::RTCP::MaxVideoIntervalMs;
+			this->maxRtcpIntervalMs = RTC::RTCP::MaxVideoIntervalMs;
 		}
 
 		// Create a KeyFrameRequestManager.
 		if (this->kind == RTC::Media::Kind::VIDEO)
 		{
-			auto keyFrameRequestDelay = data->keyFrameRequestDelay();
+			const int64_t keyFrameRequestDelayMs = data->keyFrameRequestDelay();
 
 			this->keyFrameRequestManager =
-			  new RTC::KeyFrameRequestManager(this, this->shared, keyFrameRequestDelay);
+			  new RTC::KeyFrameRequestManager(this, this->shared, keyFrameRequestDelayMs);
 		}
 
 		// NOTE: This may throw.
@@ -270,8 +270,7 @@ namespace RTC
 			    builder,
 			    encodingMapping.rid.c_str(),
 			    encodingMapping.ssrc != 0u ? flatbuffers::Optional<uint32_t>(encodingMapping.ssrc)
-			                               : flatbuffers::nullopt,
-			    nullptr, /* capability mode. NOTE: Present in NODE*/
+					                           : flatbuffers::nullopt,
 			    encodingMapping.mappedSsrc));
 		}
 
@@ -319,7 +318,7 @@ namespace RTC
 		  builder,
 		  this->id.c_str(),
 		  this->kind == RTC::Media::Kind::AUDIO ? FBS::RtpParameters::MediaKind::AUDIO
-		                                        : FBS::RtpParameters::MediaKind::VIDEO,
+			                                      : FBS::RtpParameters::MediaKind::VIDEO,
 		  RTC::RtpParameters::TypeToFbs(this->type),
 		  rtpParameters,
 		  rtpMapping,
@@ -509,7 +508,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		switch (notification->event)
+		switch (notification->data->event())
 		{
 			case Channel::ChannelNotification::Event::PRODUCER_SEND:
 			{
@@ -539,7 +538,7 @@ namespace RTC
 				}
 
 				// Pass the packet to the parent transport.
-				this->listener->OnProducerReceiveRtpPacket(this, packet);
+				this->listener->OnProducerReceiveRtpPacket(this, packet, notification->receivedAtUs);
 
 				break;
 			}
@@ -551,7 +550,8 @@ namespace RTC
 		}
 	}
 
-	Producer::ReceiveRtpPacketResult Producer::ReceiveRtpPacket(RTC::RTP::Packet* packet)
+	Producer::ReceiveRtpPacketResult Producer::ReceiveRtpPacket(
+	  RTC::RTP::Packet* packet, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -590,7 +590,7 @@ namespace RTC
 			result = ReceiveRtpPacketResult::MEDIA;
 
 			// Process the packet.
-			if (!rtpStream->ReceivePacket(packet))
+			if (!rtpStream->ReceivePacket(packet, receivedAtUs))
 			{
 				// May have to announce a new RTP stream to the listener.
 				if (this->mapSsrcRtpStream.size() > numRtpStreamsBefore)
@@ -688,7 +688,7 @@ namespace RTC
 		return result;
 	}
 
-	void Producer::ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report)
+	void Producer::ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -699,7 +699,7 @@ namespace RTC
 			auto* rtpStream  = it->second;
 			const bool first = !rtpStream->GetSenderReportMapping().has_value();
 
-			rtpStream->ReceiveRtcpSenderReport(report);
+			rtpStream->ReceiveRtcpSenderReport(report, receivedAtUs);
 
 			this->listener->OnProducerRtcpSenderReport(this, rtpStream, first);
 
@@ -715,7 +715,7 @@ namespace RTC
 		{
 			auto* rtpStream = it2->second;
 
-			rtpStream->ReceiveRtxRtcpSenderReport(report);
+			rtpStream->ReceiveRtxRtcpSenderReport(report, receivedAtUs);
 
 			return;
 		}
@@ -723,7 +723,8 @@ namespace RTC
 		MS_DEBUG_TAG(rtcp, "RtpStream not found [ssrc:%" PRIu32 "]", report->GetSsrc());
 	}
 
-	void Producer::ReceiveRtcpXrDelaySinceLastRr(RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo)
+	void Producer::ReceiveRtcpXrDelaySinceLastRr(
+	  RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -738,14 +739,18 @@ namespace RTC
 
 		auto* rtpStream = it->second;
 
-		rtpStream->ReceiveRtcpXrDelaySinceLastRr(ssrcInfo);
+		rtpStream->ReceiveRtcpXrDelaySinceLastRr(ssrcInfo, receivedAtUs);
 	}
 
-	bool Producer::GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs)
+	bool Producer::GetRtcp(RTC::RTCP::CompoundPacket* packet, int64_t nowUs)
 	{
 		MS_TRACE();
 
-		if (static_cast<float>((nowMs - this->lastRtcpSentTime) * 1.15) < this->maxRtcpInterval)
+		// NOTE: The interval is in milliseconds, being it given to a timer, so the
+		// elapsed time is truncated here.
+		const int64_t elapsedMs = (nowUs - this->lastRtcpSentAtUs) / 1000;
+
+		if (static_cast<float>(elapsedMs * 1.15) < this->maxRtcpIntervalMs)
 		{
 			return true;
 		}
@@ -771,7 +776,7 @@ namespace RTC
 		// Add a receiver reference time report if no present in the packet.
 		if (!packet->HasReceiverReferenceTime())
 		{
-			auto ntp = Utils::Time::TimeMs2Ntp(nowMs + this->shared->GetNtpOffsetMs());
+			auto ntp = Utils::Time::TimeUs2Ntp(nowUs + this->shared->GetNtpOffsetUs());
 
 			receiverReferenceTimeReport = new RTC::RTCP::ReceiverReferenceTime();
 
@@ -785,7 +790,7 @@ namespace RTC
 			return false;
 		}
 
-		this->lastRtcpSentTime = nowMs;
+		this->lastRtcpSentAtUs = nowUs;
 
 		return true;
 	}
@@ -1137,8 +1142,8 @@ namespace RTC
 		  this->type == RtpParameters::Type::SIMULCAST && this->rtpMapping.encodings.size() > 1;
 
 		// Create a RtpStreamRecv for receiving a media stream.
-		auto* rtpStream =
-		  new RTC::RTP::RtpStreamRecv(this, this->shared, params, SendNackDelay, useRtpInactivityCheck);
+		auto* rtpStream = new RTC::RTP::RtpStreamRecv(
+		  this, this->shared, params, SendNackDelayMs, useRtpInactivityCheck);
 
 		// Insert into the maps.
 		this->mapSsrcRtpStream[ssrc]              = rtpStream;
@@ -1252,9 +1257,9 @@ namespace RTC
 				// RTCP at all, both clocks are taken to be the same. Our own clock is real NTP
 				// and so is the one of any sender that fills this extension, so no offset is
 				// the most likely case rather than a wild guess.
-				const auto remoteClockOffsetMs = this->listener->OnProducerNeedRemoteClockOffsetMs(this);
+				const auto remoteClockOffsetUs = this->listener->OnProducerNeedRemoteClockOffsetUs(this);
 				const auto remoteClockOffsetQ32x32 =
-				  Utils::Time::TimeMs2Q32x32(remoteClockOffsetMs.value_or(0));
+				  Utils::Time::TimeUs2Q32x32(remoteClockOffsetUs.value_or(0));
 
 				// NOTE: An offset that does not fit in the extension means a sender whose clock
 				// is decades away from ours, and there is no value to write that would not be a
@@ -1470,16 +1475,16 @@ namespace RTC
 		// stream, which is the one the Sender Reports we send are built upon.
 		if (maxPacketTsChanged)
 		{
-			const auto captureMs =
-			  this->listener->OnProducerNeedLocalCaptureMs(this, rtpStream, packet->GetTimestamp());
+			const auto captureAtUs =
+			  this->listener->OnProducerNeedLocalCaptureAtUs(this, rtpStream, packet->GetTimestamp());
 
-			if (captureMs.has_value())
+			if (captureAtUs.has_value())
 			{
-				packet->SetCaptureMs(captureMs.value());
+				packet->SetCaptureAtUs(captureAtUs.value());
 
 				// Also let the stream remember it, since this is the only place where the
 				// capture instant of a received packet can be told.
-				rtpStream->SetCaptureMapping(captureMs.value(), packet->GetTimestamp());
+				rtpStream->SetCaptureMapping(captureAtUs.value(), packet->GetTimestamp());
 			}
 		}
 
@@ -1563,7 +1568,7 @@ namespace RTC
 			auto notification = FBS::Producer::CreateTraceNotification(
 			  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 			  FBS::Producer::TraceEventType::KEYFRAME,
-			  this->shared->GetTimeMs(),
+			  static_cast<uint64_t>(this->shared->GetTimeMs()),
 			  FBS::Common::TraceDirection::DIRECTION_IN,
 			  FBS::Producer::TraceInfo::KeyFrameTraceInfo,
 			  traceInfo.Union());
@@ -1579,7 +1584,7 @@ namespace RTC
 			auto notification = FBS::Producer::CreateTraceNotification(
 			  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 			  FBS::Producer::TraceEventType::RTP,
-			  this->shared->GetTimeMs(),
+			  static_cast<uint64_t>(this->shared->GetTimeMs()),
 			  FBS::Common::TraceDirection::DIRECTION_IN,
 			  FBS::Producer::TraceInfo::RtpTraceInfo,
 			  traceInfo.Union());
@@ -1603,7 +1608,7 @@ namespace RTC
 		auto notification = FBS::Producer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Producer::TraceEventType::PLI,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_OUT,
 		  FBS::Producer::TraceInfo::PliTraceInfo,
 		  traceInfo.Union());
@@ -1626,7 +1631,7 @@ namespace RTC
 		auto notification = FBS::Producer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Producer::TraceEventType::FIR,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_OUT,
 		  FBS::Producer::TraceInfo::FirTraceInfo,
 		  traceInfo.Union());
@@ -1646,7 +1651,7 @@ namespace RTC
 		auto notification = FBS::Producer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Producer::TraceEventType::NACK,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_OUT);
 
 		EmitTraceEvent(notification);
@@ -1673,7 +1678,7 @@ namespace RTC
 		auto notification = FBS::Producer::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Producer::TraceEventType::SR,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_IN,
 		  FBS::Producer::TraceInfo::SrTraceInfo,
 		  traceInfo.Union());
@@ -1777,6 +1782,15 @@ namespace RTC
 		return this->listener->OnProducerNeedWorstRemoteFractionLost(this, mappedSsrc);
 	}
 
+	inline void Producer::OnRtpStreamSpatialLayerActivityChanged(
+	  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive)
+	{
+		MS_TRACE();
+
+		// Notify the listener.
+		this->listener->OnProducerSpatialLayerActivityChanged(this, rtpStream, spatialLayer, isActive);
+	}
+
 	inline void Producer::OnKeyFrameNeeded(
 	  RTC::KeyFrameRequestManager* /*keyFrameRequestManager*/, uint32_t ssrc)
 	{

package/worker/src/RTC/RTCP/FeedbackPsRemb.cpp

@@ -85,9 +85,14 @@ namespace RTC
 			const uint64_t mantissa =
 			  (static_cast<uint32_t>(data[5] & 0x03) << 16) | Utils::Byte::Get2Bytes(data, 6);
 
-			this->bitrate = (mantissa << exponent);
-
-			if ((this->bitrate >> exponent) != mantissa)
+			// NOTE: The exponent is 6 bits wide, so a remote endpoint can craft a shift
+			// that overflows. The checks below reject both an overflowing shift and a
+			// value that does not fit in the signed 64 bits bitrate.
+			const uint64_t rawBitrate = (mantissa << exponent);
+
+			if (
+			  (rawBitrate >> exponent) != mantissa ||
+			  rawBitrate > static_cast<uint64_t>(std::numeric_limits<int64_t>::max()))
 			{
 				MS_WARN_TAG(rtcp, "invalid REMB bitrate value: %" PRIu64 " *2^%u", mantissa, exponent);
 
@@ -96,6 +101,8 @@ namespace RTC
 				return;
 			}
 
+			this->bitrate = static_cast<int64_t>(rawBitrate);
+
 			// Make index point to the first SSRC feedback item.
 			size_t index{ 8 };
 
@@ -113,8 +120,8 @@ namespace RTC
 			MS_TRACE();
 
 			// NOLINTNEXTLINE(bugprone-parent-virtual-call)
-			size_t offset     = FeedbackPsPacket::Serialize(buffer);
-			uint64_t mantissa = this->bitrate;
+			size_t offset = FeedbackPsPacket::Serialize(buffer);
+			auto mantissa = static_cast<uint64_t>(std::max<int64_t>(this->bitrate, 0));
 			uint8_t exponent{ 0u };
 
 			while (mantissa > 0x3FFFF /* max mantissa (18 bits) */)
@@ -151,7 +158,7 @@ namespace RTC
 			MS_DUMP_CLEAN(indentation, "<FeedbackPsRembPacket>");
 			// NOLINTNEXTLINE(bugprone-parent-virtual-call)
 			FeedbackPsPacket::Dump();
-			MS_DUMP_CLEAN(indentation, "  bitrate (bps): %" PRIu64, this->bitrate);
+			MS_DUMP_CLEAN(indentation, "  bitrate (bps): %" PRIi64, this->bitrate);
 			for (auto ssrc : this->ssrcs)
 			{
 				MS_DUMP_CLEAN(indentation, "  ssrc: %" PRIu32, ssrc);

package/worker/src/RTC/RTCP/FeedbackRtpTmmb.cpp

@@ -32,14 +32,23 @@ namespace RTC
 
 			this->overhead = compact & 0x1ff; // 9 bits.
 			// Get the bitrate out of exponent and mantissa.
-			this->bitrate = (mantissa << exponent);
-
-			if ((this->bitrate >> exponent) != mantissa)
+			// NOTE: The exponent is 6 bits wide, so a remote endpoint can craft a shift
+			// that overflows. The checks below reject both an overflowing shift and a
+			// value that does not fit in the signed 64 bits bitrate.
+			const uint64_t rawBitrate = (mantissa << exponent);
+
+			if (
+			  (rawBitrate >> exponent) != mantissa ||
+			  rawBitrate > static_cast<uint64_t>(std::numeric_limits<int64_t>::max()))
 			{
 				MS_WARN_TAG(rtcp, "invalid TMMB bitrate value : %" PRIu64 " x 2^%" PRIu8, mantissa, exponent);
 
 				this->isCorrect = false;
+
+				return;
 			}
+
+			this->bitrate = static_cast<int64_t>(rawBitrate);
 		}
 
 		template<typename T>
@@ -49,7 +58,7 @@ namespace RTC
 
 			static constexpr uint32_t MaxMantissa{ 0x1ffff }; // 17 bits.
 
-			uint64_t mantissa = this->bitrate;
+			auto mantissa = static_cast<uint64_t>(std::max<int64_t>(this->bitrate, 0));
 			uint32_t exponent{ 0 };
 
 			while (mantissa > MaxMantissa)
@@ -74,7 +83,7 @@ namespace RTC
 
 			MS_DUMP_CLEAN(indentation, "<FeedbackRtpTmmbItem>");
 			MS_DUMP_CLEAN(indentation, "  ssrc: %" PRIu32, this->GetSsrc());
-			MS_DUMP_CLEAN(indentation, "  bitrate: %" PRIu64, this->GetBitrate());
+			MS_DUMP_CLEAN(indentation, "  bitrate: %" PRIi64, this->GetBitrate());
 			MS_DUMP_CLEAN(indentation, "  overhead: %" PRIu16, this->GetOverhead());
 			MS_DUMP_CLEAN(indentation, "</FeedbackRtpTmmbItem>");
 		}

package/worker/src/RTC/RTCP/FeedbackRtpTransport.cpp

@@ -54,6 +54,16 @@ namespace RTC
 			return packet.release();
 		}
 
+		int32_t FeedbackRtpTransportPacket::TicksToReferenceTime(int64_t baseTimeTicks)
+		{
+			MS_TRACE();
+
+			const int64_t maskedBaseTimeTicks = baseTimeTicks & 0xFFFFFF;
+
+			return static_cast<int32_t>(
+			  maskedBaseTimeTicks >= (1 << 23) ? maskedBaseTimeTicks - (1 << 24) : maskedBaseTimeTicks);
+		}
+
 		/* Instance methods. */
 
 		FeedbackRtpTransportPacket::FeedbackRtpTransportPacket(CommonHeader* commonHeader, size_t availableLen)
@@ -190,33 +200,27 @@ namespace RTC
 				chunk->Dump(indentation + 1);
 			}
 
-			MS_DUMP_CLEAN(indentation + 1, "<Deltas>");
-			for (auto delta : this->deltas)
-			{
-				MS_DUMP_CLEAN(indentation + 1, "  %" PRIi16 " ms", static_cast<int16_t>(delta / 4));
-			}
-			MS_DUMP_CLEAN(indentation + 1, "</Deltas>");
-
-			auto packetResults = GetPacketResults();
+			auto packetStatuses = GetPacketStatuses();
 
-			MS_DUMP_CLEAN(indentation + 1, "<PacketResults>");
-			for (auto& packetResult : packetResults)
+			MS_DUMP_CLEAN(indentation + 1, "<PacketStatuses>");
+			for (auto& packetStatus : packetStatuses)
 			{
-				if (packetResult.received)
+				if (packetStatus.received)
 				{
 					MS_DUMP_CLEAN(
 					  indentation + 1,
-					  "  seq:%" PRIu16 ", received:yes, receivedAtMs:%" PRIi64,
-					  packetResult.sequenceNumber,
-					  packetResult.receivedAtMs);
+					  "  seq:%" PRIu16 ", received:yes, delta:%" PRIi64 " us, receivedAtUs:%" PRIi64,
+					  packetStatus.sequenceNumber,
+					  static_cast<int64_t>(packetStatus.delta) * DeltaTickUs,
+					  packetStatus.receivedAtUs);
 				}
 				else
 				{
 					MS_DUMP_CLEAN(
-					  indentation + 1, "  seq:%" PRIu16 ", received:no", packetResult.sequenceNumber);
+					  indentation + 1, "  seq:%" PRIu16 ", received:no", packetStatus.sequenceNumber);
 				}
 			}
-			MS_DUMP_CLEAN(indentation + 1, "</PacketResults>");
+			MS_DUMP_CLEAN(indentation + 1, "</PacketStatuses>");
 			MS_DUMP_CLEAN(indentation, "</FeedbackRtpTransportPacket>");
 		}
 
@@ -279,21 +283,38 @@ namespace RTC
 			return offset;
 		}
 
-		void FeedbackRtpTransportPacket::SetBase(uint16_t sequenceNumber, uint64_t timestamp)
+		void FeedbackRtpTransportPacket::SetBase(uint16_t sequenceNumber, int64_t timestampUs)
 		{
 			MS_TRACE();
 
 			MS_ASSERT(!this->baseSet, "base already set");
 
-			this->baseSet              = true;
-			this->baseSequenceNumber   = sequenceNumber;
-			this->referenceTime        = static_cast<int32_t>((timestamp & 0x1FFFFFC0) / 64);
+			// Number of whole base time ticks elapsed.
+			const int64_t baseTimeTicks = timestampUs / BaseTimeTickUs;
+
+			this->baseSet            = true;
+			this->baseSequenceNumber = sequenceNumber;
+			// NOTE: The reference time is a 24 bits field that wraps around, which is
+			// what GetBaseDeltaUs() compensates for. Keeping fewer bits than that
+			// would make it wrap sooner than the compensation expects.
+			this->referenceTime        = TicksToReferenceTime(baseTimeTicks);
 			this->latestSequenceNumber = sequenceNumber - 1;
-			this->latestTimestamp      = (timestamp >> 6) * 64; // IMPORTANT: Loose precision.
+			// IMPORTANT: The reference time only carries whole base time ticks, so
+			// the remainder is lost here and recovered by the delta of the first
+			// added packet.
+			this->latestTimestampUs = baseTimeTicks * BaseTimeTickUs;
+		}
+
+		void FeedbackRtpTransportPacket::SetReferenceTimeUs(int64_t referenceTimeUs)
+		{
+			MS_TRACE();
+
+			this->referenceTime =
+			  TicksToReferenceTime((referenceTimeUs % TimeWrapPeriodUs) / BaseTimeTickUs);
 		}
 
 		FeedbackRtpTransportPacket::AddPacketResult FeedbackRtpTransportPacket::AddPacket(
-		  uint16_t sequenceNumber, uint64_t timestamp, size_t maxRtcpPacketLen)
+		  uint16_t sequenceNumber, int64_t timestampUs, size_t maxRtcpPacketLen)
 		{
 			MS_TRACE();
 
@@ -323,24 +344,27 @@ namespace RTC
 				}
 			}
 
-			// Deltas are represented as multiples of 250 us.
+			// Deltas are represented as multiples of DeltaTickUs, rounded to the
+			// nearest tick.
 			// NOTE: Read it as int 64 to detect long elapsed times.
-			const int64_t delta64 = (timestamp - this->latestTimestamp) * 4;
+			const int64_t elapsedUs = timestampUs - this->latestTimestampUs;
+			const int64_t delta64   = elapsedUs >= 0 ? (elapsedUs + (DeltaTickUs / 2)) / DeltaTickUs
+			                                         : (elapsedUs - (DeltaTickUs / 2)) / DeltaTickUs;
 
 			if (
 			  delta64 > FeedbackRtpTransportPacket::maxPacketDelta ||
 			  delta64 < -1 * static_cast<int64_t>(FeedbackRtpTransportPacket::maxPacketDelta))
 			{
 				MS_WARN_DEV(
-				  "RTP packet delta exceeded [latestTimestamp:%" PRIu64 ", timestamp:%" PRIu64 "]",
-				  this->latestTimestamp,
-				  timestamp);
+				  "RTP packet delta exceeded [latestTimestampUs:%" PRIi64 ", timestampUs:%" PRIi64 "]",
+				  this->latestTimestampUs,
+				  timestampUs);
 
 				return AddPacketResult::FATAL;
 			}
 
 			// Delta in 16 bits signed.
-			auto delta = static_cast<int16_t>(delta64);
+			const auto delta = static_cast<int16_t>(delta64);
 
 			// Check whether another chunks and corresponding delta infos could be
 			// added.
@@ -370,8 +394,11 @@ namespace RTC
 			FillChunk(this->latestSequenceNumber, sequenceNumber, delta);
 
 			// Update latest seen sequence number and timestamp.
+			// NOTE: The timestamp is advanced by the quantized delta rather than set
+			// to the given one so that the rounding above doesn't accumulate along
+			// the packet.
 			this->latestSequenceNumber = sequenceNumber;
-			this->latestTimestamp      = timestamp;
+			this->latestTimestampUs += delta * DeltaTickUs;
 
 			return AddPacketResult::SUCCESS;
 		}
@@ -383,39 +410,38 @@ namespace RTC
 			AddPendingChunks();
 		}
 
-		std::vector<struct FeedbackRtpTransportPacket::PacketResult> FeedbackRtpTransportPacket::GetPacketResults() const
+		std::vector<struct FeedbackRtpTransportPacket::PacketStatus> FeedbackRtpTransportPacket::GetPacketStatuses() const
 		{
 			MS_TRACE();
 
-			std::vector<struct PacketResult> packetResults;
+			std::vector<struct PacketStatus> packetStatuses;
 
 			uint16_t currentSequenceNumber = this->baseSequenceNumber - 1;
 
 			for (auto* chunk : this->chunks)
 			{
-				chunk->FillResults(packetResults, currentSequenceNumber);
+				chunk->FillStatuses(packetStatuses, currentSequenceNumber);
 			}
 
 			size_t deltaIdx{ 0u };
-			// NOLINTNEXTLINE(bugprone-misplaced-widening-cast)
-			auto currentReceivedAtMs = static_cast<int64_t>(this->referenceTime * 64);
+			auto currentReceivedAtUs = GetReferenceTimestampUs();
 
-			for (size_t idx{ 0u }; idx < packetResults.size(); ++idx)
+			for (size_t idx{ 0u }; idx < packetStatuses.size(); ++idx)
 			{
-				auto& packetResult = packetResults[idx];
+				auto& packetStatus = packetStatuses[idx];
 
-				if (!packetResult.received)
+				if (!packetStatus.received)
 				{
 					continue;
 				}
 
-				currentReceivedAtMs += this->deltas.at(deltaIdx) / 4;
-				packetResult.delta        = this->deltas.at(deltaIdx);
-				packetResult.receivedAtMs = currentReceivedAtMs;
+				currentReceivedAtUs += this->deltas.at(deltaIdx) * DeltaTickUs;
+				packetStatus.delta        = this->deltas.at(deltaIdx);
+				packetStatus.receivedAtUs = currentReceivedAtUs;
 				deltaIdx++;
 			}
 
-			return packetResults;
+			return packetStatuses;
 		}
 
 		uint8_t FeedbackRtpTransportPacket::GetPacketFractionLost() const
@@ -752,8 +778,8 @@ namespace RTC
 			}
 		}
 
-		void FeedbackRtpTransportPacket::RunLengthChunk::FillResults(
-		  std::vector<struct FeedbackRtpTransportPacket::PacketResult>& packetResults,
+		void FeedbackRtpTransportPacket::RunLengthChunk::FillStatuses(
+		  std::vector<struct FeedbackRtpTransportPacket::PacketStatus>& packetStatuses,
 		  uint16_t& currentSequenceNumber) const
 		{
 			MS_TRACE();
@@ -763,7 +789,7 @@ namespace RTC
 
 			for (uint16_t count{ 1u }; count <= this->count; ++count)
 			{
-				packetResults.emplace_back(++currentSequenceNumber, received);
+				packetStatuses.emplace_back(++currentSequenceNumber, received);
 			}
 		}
 
@@ -876,8 +902,8 @@ namespace RTC
 			return count;
 		}
 
-		void FeedbackRtpTransportPacket::OneBitVectorChunk::FillResults(
-		  std::vector<struct FeedbackRtpTransportPacket::PacketResult>& packetResults,
+		void FeedbackRtpTransportPacket::OneBitVectorChunk::FillStatuses(
+		  std::vector<struct FeedbackRtpTransportPacket::PacketStatus>& packetStatuses,
 		  uint16_t& currentSequenceNumber) const
 		{
 			MS_TRACE();
@@ -886,7 +912,7 @@ namespace RTC
 			{
 				const bool received = (status == Status::SmallDelta || status == Status::LargeDelta);
 
-				packetResults.emplace_back(++currentSequenceNumber, received);
+				packetStatuses.emplace_back(++currentSequenceNumber, received);
 			}
 		}
 
@@ -1016,8 +1042,8 @@ namespace RTC
 			return count;
 		}
 
-		void FeedbackRtpTransportPacket::TwoBitVectorChunk::FillResults(
-		  std::vector<struct FeedbackRtpTransportPacket::PacketResult>& packetResults,
+		void FeedbackRtpTransportPacket::TwoBitVectorChunk::FillStatuses(
+		  std::vector<struct FeedbackRtpTransportPacket::PacketStatus>& packetStatuses,
 		  uint16_t& currentSequenceNumber) const
 		{
 			MS_TRACE();
@@ -1026,7 +1052,7 @@ namespace RTC
 			{
 				const bool received = (status == Status::SmallDelta || status == Status::LargeDelta);
 
-				packetResults.emplace_back(++currentSequenceNumber, received);
+				packetStatuses.emplace_back(++currentSequenceNumber, received);
 			}
 		}
 

package/worker/src/RTC/RTP/Codecs/VP8.cpp

@@ -316,7 +316,7 @@ namespace RTC
 					if (
 					  this->payloadDescriptor->tlIndex > context->GetTargetTemporalLayer() ||
 					  (this->payloadDescriptor->tlIndex > context->GetCurrentTemporalLayer() &&
-					   !this->payloadDescriptor->y))
+						 !this->payloadDescriptor->y))
 					{
 						context->pictureIdManager.Drop(this->payloadDescriptor->pictureId);
 

package/worker/src/RTC/RTP/Codecs/VP9.cpp

@@ -215,7 +215,7 @@ namespace RTC
 
 				const bool isOldPacket =
 				  (this->payloadDescriptor->hasPictureId &&
-				   RTC::SeqManager<uint16_t, 15>::IsSeqLowerThan(
+					 RTC::SeqManager<uint16_t, 15>::IsSeqLowerThan(
 				     this->payloadDescriptor->pictureId, context->pictureIdManager.GetMaxInput()));
 
 				if (!isOldPacket)
@@ -283,12 +283,12 @@ namespace RTC
 				// (interframe p bit = 1)
 				const uint16_t spatialLayerForPictureId =
 				  isOldPacket ? context->GetSpatialLayerForPictureId(this->payloadDescriptor->pictureId)
-				              : tmpSpatialLayer;
+					            : tmpSpatialLayer;
 
 				if (
 				  packetSpatialLayer > spatialLayerForPictureId ||
 				  (context->IsKSvc() && this->payloadDescriptor->p &&
-				   packetSpatialLayer != spatialLayerForPictureId))
+					 packetSpatialLayer != spatialLayerForPictureId))
 				{
 					return false;
 				}
@@ -336,7 +336,7 @@ namespace RTC
 				// Filter temporal layers higher than current one.
 				const uint16_t temporalLayerForPictureId =
 				  isOldPacket ? context->GetTemporalLayerForPictureId(this->payloadDescriptor->pictureId)
-				              : tmpTemporalLayer;
+					            : tmpTemporalLayer;
 
 				if (packetTemporalLayer > temporalLayerForPictureId)
 				{