mediasoup 3.26.0 → 3.27.0

package/worker/test/src/RTC/RTCP/TestFeedbackRtpTransport.cpp

@@ -1,5 +1,4 @@
 #include "common.hpp"
-#include "Logger.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memcmp()
@@ -8,13 +7,13 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 {
 	struct TestFeedbackRtpTransportInput
 	{
-		TestFeedbackRtpTransportInput(uint16_t sequenceNumber, uint64_t timestamp, size_t maxPacketSize)
-		  : sequenceNumber(sequenceNumber), timestamp(timestamp), maxPacketSize(maxPacketSize)
+		TestFeedbackRtpTransportInput(uint16_t sequenceNumber, int64_t timestampUs, size_t maxPacketSize)
+		  : sequenceNumber(sequenceNumber), timestampUs(timestampUs), maxPacketSize(maxPacketSize)
 		{
 		}
 
 		uint16_t sequenceNumber{ 0u };
-		uint64_t timestamp{ 0u };
+		int64_t timestampUs{ 0 };
 		size_t maxPacketSize{ 0u };
 	};
 
@@ -26,43 +25,53 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 	auto verify =
 	  [](
 	    const std::vector<struct TestFeedbackRtpTransportInput>& inputs,
-	    std::vector<struct RTC::RTCP::FeedbackRtpTransportPacket::PacketResult> packetResults)
+	    const std::vector<struct RTC::RTCP::FeedbackRtpTransportPacket::PacketStatus>& packetStatuses)
 	{
-		auto inputsIterator        = inputs.begin();
-		auto packetResultsIterator = packetResults.begin();
-		auto lastInput             = *inputsIterator;
-
-		for (++inputsIterator; inputsIterator != inputs.end(); ++inputsIterator, ++packetResultsIterator)
+		// The reference time only carries whole base time ticks and wraps around,
+		// so the reconstructed times sit in a frame shifted a constant amount from
+		// the given ones. The shift comes from the timestamp the base was set with,
+		// which is the first input.
+		const int64_t baseTimeTicks =
+		  inputs.front().timestampUs / RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs;
+		const int64_t maskedBaseTimeTicks = baseTimeTicks & 0xFFFFFF;
+		// The reference time is a 24 bits signed integer.
+		const int64_t referenceTime =
+		  maskedBaseTimeTicks >= (1 << 23) ? maskedBaseTimeTicks - (1 << 24) : maskedBaseTimeTicks;
+		const int64_t frameOffsetUs =
+		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs +
+		  ((referenceTime - baseTimeTicks) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs);
+
+		auto packetStatusesIterator = packetStatuses.begin();
+		auto lastInput              = inputs.front();
+
+		for (auto inputsIterator = inputs.begin() + 1; inputsIterator != inputs.end(); ++inputsIterator)
 		{
 			const auto& input             = *inputsIterator;
-			auto& packetResult            = *packetResultsIterator;
 			const uint16_t missingPackets = input.sequenceNumber - lastInput.sequenceNumber - 1;
 
-			if (missingPackets > 0)
+			// All missing packets must be represented in packetStatuses.
+			for (uint16_t i{ 0u }; i < missingPackets; ++i)
 			{
-				// All missing packets must be represented in packetResults.
-				for (uint16_t i{ 0u }; i < missingPackets; ++i)
-				{
-					packetResult = *packetResultsIterator;
-
-					REQUIRE(packetResult.sequenceNumber == lastInput.sequenceNumber + i + 1);
-					REQUIRE(packetResult.received == false);
+				REQUIRE(packetStatusesIterator != packetStatuses.end());
+				REQUIRE(packetStatusesIterator->sequenceNumber == lastInput.sequenceNumber + i + 1);
+				REQUIRE(packetStatusesIterator->received == false);
 
-					packetResultsIterator++;
-				}
-			}
-			else
-			{
-				REQUIRE(packetResult.sequenceNumber == lastInput.sequenceNumber + 1);
-				REQUIRE(packetResult.sequenceNumber == input.sequenceNumber);
-				REQUIRE(packetResult.received == true);
-				REQUIRE(
-				  static_cast<int32_t>(packetResult.receivedAtMs & 0x1FFFFFC0) / 64 ==
-				  static_cast<int32_t>(input.timestamp & 0x1FFFFFC0) / 64);
+				++packetStatusesIterator;
 			}
 
+			REQUIRE(packetStatusesIterator != packetStatuses.end());
+			REQUIRE(packetStatusesIterator->sequenceNumber == input.sequenceNumber);
+			REQUIRE(packetStatusesIterator->received == true);
+			// Deltas carry the arrival times with no loss as long as the given ones
+			// are multiples of a delta tick.
+			REQUIRE(packetStatusesIterator->receivedAtUs == input.timestampUs + frameOffsetUs);
+
+			++packetStatusesIterator;
+
 			lastInput = input;
 		}
+
+		REQUIRE(packetStatusesIterator == packetStatuses.end());
 	};
 
 	SECTION(
@@ -75,21 +84,21 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		/* clang-format off */
 		std::vector<struct TestFeedbackRtpTransportInput> inputs =
 		{
-			{ 999, 1000000000, RtcpMtu },  // Pre base.
-			{ 1000, 1000000000, RtcpMtu }, // Base.
-			{ 1001, 1000000001, RtcpMtu },
-			{ 1002, 1000000012, RtcpMtu },
-			{ 1003, 1000000015, RtcpMtu },
-			{ 1004, 1000000017, RtcpMtu },
-			{ 1005, 1000000018, RtcpMtu },
-			{ 1006, 1000000018, RtcpMtu },
-			{ 1007, 1000000018, RtcpMtu },
-			{ 1008, 1000000018, RtcpMtu },
-			{ 1009, 1000000019, RtcpMtu },
-			{ 1010, 1000000010, RtcpMtu },
-			{ 1011, 1000000011, RtcpMtu },
-			{ 1012, 1000000011, RtcpMtu },
-			{ 1013, 1000000013, RtcpMtu }
+			{ 999, 1000000000000, RtcpMtu },  // Pre base.
+			{ 1000, 1000000000000, RtcpMtu }, // Base.
+			{ 1001, 1000000001000, RtcpMtu },
+			{ 1002, 1000000012000, RtcpMtu },
+			{ 1003, 1000000015000, RtcpMtu },
+			{ 1004, 1000000017000, RtcpMtu },
+			{ 1005, 1000000018000, RtcpMtu },
+			{ 1006, 1000000018000, RtcpMtu },
+			{ 1007, 1000000018000, RtcpMtu },
+			{ 1008, 1000000018000, RtcpMtu },
+			{ 1009, 1000000019000, RtcpMtu },
+			{ 1010, 1000000010000, RtcpMtu },
+			{ 1011, 1000000011000, RtcpMtu },
+			{ 1012, 1000000011000, RtcpMtu },
+			{ 1013, 1000000013000, RtcpMtu }
 		};
 		/* clang-format on */
 
@@ -99,32 +108,32 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs.front()))
 			{
-				packet->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		REQUIRE(packet->GetLatestSequenceNumber() == 1013);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000013);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000013000);
 
 		// Add a packet with greater seq number but older timestamp.
-		packet->AddPacket(1014, 1000000013 - 128, RtcpMtu);
-		inputs.emplace_back(1014, 1000000013 - 128, RtcpMtu);
+		packet->AddPacket(1014, 1000000013000 - 128000, RtcpMtu);
+		inputs.emplace_back(1014, 1000000013000 - 128000, RtcpMtu);
 
 		REQUIRE(packet->GetLatestSequenceNumber() == 1014);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000013 - 128);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000013000 - 128000);
 
-		packet->AddPacket(1015, 1000000015, RtcpMtu);
-		inputs.emplace_back(1015, 1000000015, RtcpMtu);
+		packet->AddPacket(1015, 1000000015000, RtcpMtu);
+		inputs.emplace_back(1015, 1000000015000, RtcpMtu);
 
 		REQUIRE(packet->GetLatestSequenceNumber() == 1015);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000015);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000015000);
 
 		packet->Finish();
-		verify(inputs, packet->GetPacketResults());
+		verify(inputs, packet->GetPacketStatuses());
 
 		REQUIRE(packet->GetBaseSequenceNumber() == 1000);
 		REQUIRE(packet->GetPacketStatusCount() == 16);
@@ -150,6 +159,11 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 				REQUIRE(packet2->GetFeedbackPacketCount() == 1);
 				REQUIRE(packet2->GetPacketFractionLost() == 0);
 
+				// The reference time survives the round trip, so a parsed packet tells
+				// the very same arrival times as the one it was serialized from.
+				REQUIRE(packet2->GetReferenceTime() == packet->GetReferenceTime());
+				verify(inputs, packet2->GetPacketStatuses());
+
 				alignas(4) uint8_t buffer2[1024];
 				auto len2 = packet2->Serialize(buffer2);
 
@@ -160,16 +174,16 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		}
 	}
 
-	SECTION("create FeedbackRtpTransportPacket, run length chunk (2)")
+	SECTION("create FeedbackRtpTransportPacket, not received run length chunk and large delta")
 	{
 		auto packet = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
 
 		/* clang-format off */
 		std::vector<TestFeedbackRtpTransportInput> inputs =
 		{
-			{ 999, 1000000000, RtcpMtu }, // Pre base.
-			{ 1000, 1000000000, RtcpMtu }, // Base.
-			{ 1050, 1000000216, RtcpMtu }
+			{ 999, 1000000000000, RtcpMtu }, // Pre base.
+			{ 1000, 1000000000000, RtcpMtu }, // Base.
+			{ 1050, 1000000216000, RtcpMtu }
 		};
 		/* clang-format on */
 
@@ -179,23 +193,23 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs.front()))
 			{
-				packet->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		packet->Finish();
-		verify(inputs, packet->GetPacketResults());
+		verify(inputs, packet->GetPacketStatuses());
 
 		REQUIRE(packet->GetBaseSequenceNumber() == 1000);
 		REQUIRE(packet->GetPacketStatusCount() == 51);
 		REQUIRE(packet->GetFeedbackPacketCount() == 10);
 		REQUIRE(packet->GetPacketFractionLost() > 0);
 		REQUIRE(packet->GetLatestSequenceNumber() == 1050);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000216);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000216000);
 
 		SECTION("serialize packet instance")
 		{
@@ -231,13 +245,13 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		/* clang-format off */
 		std::vector<TestFeedbackRtpTransportInput> inputs =
 		{
-			{ 999, 1000000000, RtcpMtu },  // Pre base.
-			{ 1000, 1000000000, RtcpMtu }, // Base.
-			{ 1001, 1000000100, RtcpMtu },
-			{ 1002, 1000000200, RtcpMtu },
-			{ 1015, 1000000300, RtcpMtu },
-			{ 1016, 1000000400, RtcpMtu },
-			{ 1017, 1000000500, RtcpMtu }
+			{ 999, 1000000000000, RtcpMtu },  // Pre base.
+			{ 1000, 1000000000000, RtcpMtu }, // Base.
+			{ 1001, 1000000100000, RtcpMtu },
+			{ 1002, 1000000200000, RtcpMtu },
+			{ 1015, 1000000300000, RtcpMtu },
+			{ 1016, 1000000400000, RtcpMtu },
+			{ 1017, 1000000500000, RtcpMtu }
 		};
 		/* clang-format on */
 
@@ -249,23 +263,23 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs.front()))
 			{
-				packet->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		packet->Finish();
-		verify(inputs, packet->GetPacketResults());
+		verify(inputs, packet->GetPacketStatuses());
 
 		REQUIRE(packet->GetBaseSequenceNumber() == 1000);
 		REQUIRE(packet->GetPacketStatusCount() == 18);
 		REQUIRE(packet->GetFeedbackPacketCount() == 1);
 		REQUIRE(packet->GetPacketFractionLost() > 0);
 		REQUIRE(packet->GetLatestSequenceNumber() == 1017);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000500);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000500000);
 
 		SECTION("serialize packet instance")
 		{
@@ -299,9 +313,9 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 	SECTION("create FeedbackRtpTransportPacket, incomplete two bit vector chunk")
 	{
 		std::vector<TestFeedbackRtpTransportInput> inputs = {
-			{ 999,  1000000000, RtcpMtu }, // Pre base.
-			{ 1000, 1000000100, RtcpMtu }, // Base.
-			{ 1001, 1000000700, RtcpMtu },
+			{ 999,  1000000000000, RtcpMtu }, // Pre base.
+			{ 1000, 1000000100000, RtcpMtu }, // Base.
+			{ 1001, 1000000700000, RtcpMtu },
 		};
 
 		auto packet = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
@@ -312,23 +326,23 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs.front()))
 			{
-				packet->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		packet->Finish();
-		verify(inputs, packet->GetPacketResults());
+		verify(inputs, packet->GetPacketStatuses());
 
 		REQUIRE(packet->GetBaseSequenceNumber() == 1000);
 		REQUIRE(packet->GetPacketStatusCount() == 2);
 		REQUIRE(packet->GetFeedbackPacketCount() == 1);
 		REQUIRE(packet->GetPacketFractionLost() == 0);
 		REQUIRE(packet->GetLatestSequenceNumber() == 1001);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000700);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000700000);
 
 		SECTION("serialize packet instance")
 		{
@@ -364,15 +378,15 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		/* clang-format off */
 		std::vector<TestFeedbackRtpTransportInput> inputs =
 		{
-			{ 999, 1000000000, RtcpMtu },  // Pre base.
-			{ 1000, 1000000000, RtcpMtu }, // Base.
-			{ 1001, 1000000003, RtcpMtu },
-			{ 1002, 1000000003, RtcpMtu },
-			{ 1003, 1000000003, RtcpMtu },
-			{ 1004, 1000000004, RtcpMtu },
-			{ 1005, 1000000005, RtcpMtu },
-			{ 1006, 1000000005, RtcpMtu },
-			{ 1007, 1000000007, RtcpMtu }
+			{ 999, 1000000000000, RtcpMtu },  // Pre base.
+			{ 1000, 1000000000000, RtcpMtu }, // Base.
+			{ 1001, 1000000003000, RtcpMtu },
+			{ 1002, 1000000003000, RtcpMtu },
+			{ 1003, 1000000003000, RtcpMtu },
+			{ 1004, 1000000004000, RtcpMtu },
+			{ 1005, 1000000005000, RtcpMtu },
+			{ 1006, 1000000005000, RtcpMtu },
+			{ 1007, 1000000007000, RtcpMtu }
 		};
 		/* clang-format on */
 
@@ -384,23 +398,23 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs.front()))
 			{
-				packet->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		packet->Finish();
-		verify(inputs, packet->GetPacketResults());
+		verify(inputs, packet->GetPacketStatuses());
 
 		REQUIRE(packet->GetBaseSequenceNumber() == 1000);
 		REQUIRE(packet->GetPacketStatusCount() == 8);
 		REQUIRE(packet->GetFeedbackPacketCount() == 1);
 		REQUIRE(packet->GetPacketFractionLost() == 0);
 		REQUIRE(packet->GetLatestSequenceNumber() == 1007);
-		REQUIRE(packet->GetLatestTimestamp() == 1000000007);
+		REQUIRE(packet->GetLatestTimestampUs() == 1000000007000);
 
 		alignas(4) uint8_t buffer[1024];
 		auto len = packet->Serialize(buffer);
@@ -428,19 +442,19 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		}
 
 		auto latestWideSeqNumber = packet->GetLatestSequenceNumber();
-		auto latestTimestamp     = packet->GetLatestTimestamp();
+		auto latestTimestampUs   = packet->GetLatestTimestampUs();
 
 		/* clang-format off */
 		std::vector<TestFeedbackRtpTransportInput> inputs2 =
 		{
-			{ latestWideSeqNumber, latestTimestamp, RtcpMtu },
-			{ 1008, 1000000008, RtcpMtu },
-			{ 1009, 1000000009, RtcpMtu },
-			{ 1010, 1000000010, RtcpMtu },
-			{ 1011, 1000000010, RtcpMtu },
-			{ 1012, 1000000010, RtcpMtu },
-			{ 1013, 1000000014, RtcpMtu },
-			{ 1014, 1000000014, RtcpMtu }
+			{ latestWideSeqNumber, latestTimestampUs, RtcpMtu },
+			{ 1008, 1000000008000, RtcpMtu },
+			{ 1009, 1000000009000, RtcpMtu },
+			{ 1010, 1000000010000, RtcpMtu },
+			{ 1011, 1000000010000, RtcpMtu },
+			{ 1012, 1000000010000, RtcpMtu },
+			{ 1013, 1000000014000, RtcpMtu },
+			{ 1014, 1000000014000, RtcpMtu }
 		};
 		/* clang-format on */
 
@@ -452,23 +466,23 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		{
 			if (std::addressof(input) == std::addressof(inputs2.front()))
 			{
-				packet2->SetBase(input.sequenceNumber + 1, input.timestamp);
+				packet2->SetBase(input.sequenceNumber + 1, input.timestampUs);
 			}
 			else
 			{
-				packet2->AddPacket(input.sequenceNumber, input.timestamp, input.maxPacketSize);
+				packet2->AddPacket(input.sequenceNumber, input.timestampUs, input.maxPacketSize);
 			}
 		}
 
 		packet2->Finish();
-		verify(inputs2, packet2->GetPacketResults());
+		verify(inputs2, packet2->GetPacketStatuses());
 
 		REQUIRE(packet2->GetBaseSequenceNumber() == 1008);
 		REQUIRE(packet2->GetPacketStatusCount() == 7);
 		REQUIRE(packet2->GetFeedbackPacketCount() == 2);
 		REQUIRE(packet2->GetPacketFractionLost() == 0);
 		REQUIRE(packet2->GetLatestSequenceNumber() == 1014);
-		REQUIRE(packet2->GetLatestTimestamp() == 1000000014);
+		REQUIRE(packet2->GetLatestTimestampUs() == 1000000014000);
 
 		len = packet2->Serialize(buffer);
 
@@ -521,9 +535,9 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		REQUIRE(packet->GetPacketStatusCount() == 13);
 		REQUIRE(packet->GetReferenceTime() == 6275825); // 0x5FC2F1 (signed 24 bits)
 		REQUIRE(
-		  packet->GetReferenceTimestamp() ==
-		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriod +
-		    (static_cast<int64_t>(6275825) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick));
+		  packet->GetReferenceTimestampUs() ==
+		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs +
+		    (static_cast<int64_t>(6275825) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs));
 		REQUIRE(packet->GetFeedbackPacketCount() == 3);
 
 		SECTION("serialize packet")
@@ -559,9 +573,9 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		REQUIRE(packet->GetPacketStatusCount() == 0);
 		REQUIRE(packet->GetReferenceTime() == -2); // 0xFFFFFE = -2 (signed 24 bits)
 		REQUIRE(
-		  packet->GetReferenceTimestamp() ==
-		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriod +
-		    (static_cast<int64_t>(-2) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick));
+		  packet->GetReferenceTimestampUs() ==
+		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs +
+		    (static_cast<int64_t>(-2) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs));
 		REQUIRE(packet->GetFeedbackPacketCount() == 1);
 
 		SECTION("serialize packet")
@@ -598,9 +612,9 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		REQUIRE(packet->GetPacketStatusCount() == 2);
 		REQUIRE(packet->GetReferenceTime() == -4368470);
 		REQUIRE(
-		  packet->GetReferenceTimestamp() ==
-		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriod +
-		    (static_cast<int64_t>(-4368470) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick));
+		  packet->GetReferenceTimestampUs() ==
+		  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs +
+		    (static_cast<int64_t>(-4368470) * RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs));
 
 		REQUIRE(packet->GetFeedbackPacketCount() == 0);
 
@@ -619,9 +633,10 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		using FeedbackPacketsMeta = struct
 		{
 			int32_t baseTimeRaw;
-			int64_t baseTimeMs;
+			int64_t baseTimeUs;
 			uint16_t baseSequence;
 			size_t packetStatusCount;
+			// In DeltaTickUs units, so these are the delta bytes of the buffer below.
 			std::vector<int16_t> deltas;
 			std::vector<uint8_t> buffer;
 		};
@@ -630,124 +645,124 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 		// were generated by chrome in direction of mediasoup.
 		const std::vector<FeedbackPacketsMeta> feedbackPacketsMeta = {
 			{ .baseTimeRaw       = 35504,
-       .baseTimeMs        = 1076014080,
-       .baseSequence      = 13,
-       .packetStatusCount = 1,
-       .deltas            = std::vector<int16_t>{ 57 },
-       .buffer = std::vector<uint8_t>{ 0xaf, 0xcd, 0x00, 0x05, 0xfa, 0x17, 0xfa, 0x17,
+			 .baseTimeUs        = 1076014080000,
+			 .baseSequence      = 13,
+			 .packetStatusCount = 1,
+			 .deltas            = std::vector<int16_t>{ 228 },
+			 .buffer = std::vector<uint8_t>{ 0xaf, 0xcd, 0x00, 0x05, 0xfa, 0x17, 0xfa, 0x17,
 			                                  0x00, 0x00, 0x04, 0xd2, 0x00, 0x0d, 0x00, 0x01,
 			                                  0x00, 0x8A, 0xB0, 0x00, 0x20, 0x01, 0xE4, 0x01 }     },
 			{ .baseTimeRaw       = 35504,
-       .baseTimeMs        = 1076014080,
-       .baseSequence      = 14,
-       .packetStatusCount = 4,
-       .deltas            = std::vector<int16_t>{ 58, 2, 3, 55 },
-       .buffer = std::vector<uint8_t>{ 0xaf, 0xcd, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x1C, 0xB7,
+			 .baseTimeUs        = 1076014080000,
+			 .baseSequence      = 14,
+			 .packetStatusCount = 4,
+			 .deltas            = std::vector<int16_t>{ 232, 8, 12, 220 },
+			 .buffer = std::vector<uint8_t>{ 0xaf, 0xcd, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x1C, 0xB7,
 			                                  0xDA, 0xF3, 0x00, 0x0E, 0x00, 0x04, 0x00, 0x8A, 0xB0, 0x01,
 			                                  0x20, 0x04, 0xE8, 0x08, 0x0C, 0xDC, 0x00, 0x02 }     },
 			{ .baseTimeRaw       = 35505,
-       .baseTimeMs        = 1076014144,
-       .baseSequence      = 18,
-       .packetStatusCount = 5,
-       .deltas            = std::vector<int16_t>{ 60, 6, 5, 9, 22 },
-       .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x1C, 0xB7,
+			 .baseTimeUs        = 1076014144000,
+			 .baseSequence      = 18,
+			 .packetStatusCount = 5,
+			 .deltas            = std::vector<int16_t>{ 240, 24, 20, 36, 88 },
+			 .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x1C, 0xB7,
 			                                  0xDA, 0xF3, 0x00, 0x12, 0x00, 0x05, 0x00, 0x8A, 0xB1, 0x02,
 			                                  0x20, 0x05, 0xF0, 0x18, 0x14, 0x24, 0x58, 0x01 }     },
 
 			{ .baseTimeRaw       = 617873,
-       .baseTimeMs        = 1113285696,
-       .baseSequence      = 2924,
-       .packetStatusCount = 22,
-       .deltas =
-			    std::vector<int16_t>{ 3, 5, 5, 0, 10, 0, 0, 4, 0, 1, 0, 2, 0, 2, 0, 2, 0, 2, 0, 1, 0, 4 },
-       .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x0A, 0xFA, 0x17, 0xFA, 0x17, 0x06,
+			 .baseTimeUs        = 1113285696000,
+			 .baseSequence      = 2924,
+			 .packetStatusCount = 22,
+			 .deltas            = std::vector<int16_t>{ 12, 20, 20, 0, 40, 0, 0, 16, 0, 4, 0,
+			                                             8,  0,  8,  0, 8,  0, 8, 0,  4, 0, 16 },
+			 .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x0A, 0xFA, 0x17, 0xFA, 0x17, 0x06,
 			                                  0xF5, 0x11, 0x4C, 0x0B, 0x6C, 0x00, 0x16, 0x09, 0x6D,
 			                                  0x91, 0xEE, 0x20, 0x16, 0x0C, 0x14, 0x14, 0x00, 0x28,
 			                                  0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08,
 			                                  0x00, 0x08, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10 }     },
 
 			{ .baseTimeRaw       = -4368470,
-       .baseTimeMs        = 794159744,
-       .baseSequence      = 1,
-       .packetStatusCount = 2,
-       .deltas            = std::vector<int16_t>{ 35, 17 },
-       .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
+			 .baseTimeUs        = 794159744000,
+			 .baseSequence      = 1,
+			 .packetStatusCount = 2,
+			 .deltas            = std::vector<int16_t>{ 140, 68 },
+			 .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
 			                                  0x39, 0xE9, 0x42, 0x38, 0x00, 0x01, 0x00, 0x02,
 			                                  0xBD, 0x57, 0xAA, 0x00, 0x20, 0x02, 0x8C, 0x44 }     },
 
 			{ .baseTimeRaw       = 818995,
-       .baseTimeMs        = 1126157504,
-       .baseSequence      = 930,
-       .packetStatusCount = 5,
-       .deltas            = std::vector<int16_t>{ 62, 18, 5, 6, 19 },
-       .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x26, 0x9E,
+			 .baseTimeUs        = 1126157504000,
+			 .baseSequence      = 930,
+			 .packetStatusCount = 5,
+			 .deltas            = std::vector<int16_t>{ 248, 72, 20, 24, 76 },
+			 .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x26, 0x9E,
 			                                  0x8E, 0x50, 0x03, 0xA2, 0x00, 0x05, 0x0C, 0x7F, 0x33, 0x9F,
 			                                  0x20, 0x05, 0xF8, 0x48, 0x14, 0x18, 0x4C, 0x01 }     },
 			{ .baseTimeRaw       = 818996,
-       .baseTimeMs        = 1126157568,
-       .baseSequence      = 921,
-       .packetStatusCount = 7,
-       .deltas            = std::vector<int16_t>{ 14, 5, 6, 6, 7, 14, 5 },
-       .buffer =
+			 .baseTimeUs        = 1126157568000,
+			 .baseSequence      = 921,
+			 .packetStatusCount = 7,
+			 .deltas            = std::vector<int16_t>{ 56, 20, 24, 24, 28, 56, 20 },
+			 .buffer =
 			    std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x07, 0xFA, 0x17, 0xFA, 0x17, 0x33, 0xB0, 0x4A,
 			                          0xE8, 0x03, 0x99, 0x00, 0x07, 0x0C, 0x7F, 0x34, 0x9F, 0x20, 0x07,
 			                          0x38, 0x14, 0x18, 0x18, 0x1C, 0x38, 0x14, 0x00, 0x00, 0x03 } },
 			{ .baseTimeRaw       = 818996,
-       .baseTimeMs        = 1126157568,
-       .baseSequence      = 935,
-       .packetStatusCount = 7,
-       .deltas            = std::vector<int16_t>{ 57, 0, 6, 5, 5, 24, 0 },
-       .buffer =
+			 .baseTimeUs        = 1126157568000,
+			 .baseSequence      = 935,
+			 .packetStatusCount = 7,
+			 .deltas            = std::vector<int16_t>{ 228, 0, 24, 20, 20, 96, 0 },
+			 .buffer =
 			    std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x07, 0xFA, 0x17, 0xFA, 0x17, 0x26, 0x9E, 0x8E,
 			                          0x50, 0x03, 0xA7, 0x00, 0x07, 0x0C, 0x7F, 0x34, 0xA0, 0x20, 0x07,
 			                          0xE4, 0x00, 0x18, 0x14, 0x14, 0x60, 0x00, 0x00, 0x00, 0x03 } },
 			{ .baseTimeRaw       = 818996,
-       .baseTimeMs        = 1126157568,
-       .baseSequence      = 928,
-       .packetStatusCount = 5,
-       .deltas            = std::vector<int16_t>{ 63, 11, 21, 6, 0 },
-       .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x33, 0xB0,
+			 .baseTimeUs        = 1126157568000,
+			 .baseSequence      = 928,
+			 .packetStatusCount = 5,
+			 .deltas            = std::vector<int16_t>{ 252, 44, 84, 24, 0 },
+			 .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x33, 0xB0,
 			                                  0x4A, 0xE8, 0x03, 0xA0, 0x00, 0x05, 0x0C, 0x7F, 0x34, 0xA0,
 			                                  0x20, 0x05, 0xFC, 0x2C, 0x54, 0x18, 0x00, 0x01 }     },
 			{ .baseTimeRaw       = 818997,
-       .baseTimeMs        = 1126157632,
-       .baseSequence      = 942,
-       .packetStatusCount = 6,
-       .deltas            = std::vector<int16_t>{ 39, 13, 9, 5, 4, 13 },
-       .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x26, 0x9E,
+			 .baseTimeUs        = 1126157632000,
+			 .baseSequence      = 942,
+			 .packetStatusCount = 6,
+			 .deltas            = std::vector<int16_t>{ 156, 52, 36, 20, 16, 52 },
+			 .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x26, 0x9E,
 			                                  0x8E, 0x50, 0x03, 0xAE, 0x00, 0x06, 0x0C, 0x7F, 0x35, 0xA1,
 			                                  0x20, 0x06, 0x9C, 0x34, 0x24, 0x14, 0x10, 0x34 }     },
 			{ .baseTimeRaw       = 821523,
-       .baseTimeMs        = 1126319296,
-       .baseSequence      = 10,
-       .packetStatusCount = 7,
-       .deltas            = std::vector<int16_t>{ 25, 2, 2, 3, 1, 1, 3 },
-       .buffer =
+			 .baseTimeUs        = 1126319296000,
+			 .baseSequence      = 10,
+			 .packetStatusCount = 7,
+			 .deltas            = std::vector<int16_t>{ 100, 8, 8, 12, 4, 4, 12 },
+			 .buffer =
 			    std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x07, 0xFA, 0x17, 0xFA, 0x17, 0x00, 0x00, 0x04,
 			                          0xD2, 0x00, 0x0A, 0x00, 0x07, 0x0C, 0x89, 0x13, 0x00, 0x20, 0x07,
 			                          0x64, 0x08, 0x08, 0x0C, 0x04, 0x04, 0x0C, 0x00, 0x00, 0x03 } },
 			{ .baseTimeRaw       = 821524,
-       .baseTimeMs        = 1126319360,
-       .baseSequence      = 17,
-       .packetStatusCount = 2,
-       .deltas            = std::vector<int16_t>{ 44, 18 },
-       .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
+			 .baseTimeUs        = 1126319360000,
+			 .baseSequence      = 17,
+			 .packetStatusCount = 2,
+			 .deltas            = std::vector<int16_t>{ 176, 72 },
+			 .buffer = std::vector<uint8_t>{ 0x8F, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
 			                                  0x08, 0xEB, 0x06, 0xD7, 0x00, 0x11, 0x00, 0x02,
 			                                  0x0C, 0x89, 0x14, 0x01, 0x20, 0x02, 0xB0, 0x48 }     },
 			{ .baseTimeRaw       = 821524,
-       .baseTimeMs        = 1126319360,
-       .baseSequence      = 17,
-       .packetStatusCount = 1,
-       .deltas            = std::vector<int16_t>{ 62 },
-       .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
+			 .baseTimeUs        = 1126319360000,
+			 .baseSequence      = 17,
+			 .packetStatusCount = 1,
+			 .deltas            = std::vector<int16_t>{ 248 },
+			 .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x05, 0xFA, 0x17, 0xFA, 0x17,
 			                                  0x20, 0x92, 0x5E, 0xB7, 0x00, 0x11, 0x00, 0x01,
 			                                  0x0C, 0x89, 0x14, 0x00, 0x20, 0x01, 0xF8, 0x01 }     },
 			{ .baseTimeRaw       = 821526,
-       .baseTimeMs        = 1126319488,
-       .baseSequence      = 19,
-       .packetStatusCount = 4,
-       .deltas            = std::vector<int16_t>{ 4, 0, 4, 0 },
-       .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x08, 0xEB,
+			 .baseTimeUs        = 1126319488000,
+			 .baseSequence      = 19,
+			 .packetStatusCount = 4,
+			 .deltas            = std::vector<int16_t>{ 16, 0, 16, 0 },
+			 .buffer = std::vector<uint8_t>{ 0xAF, 0xCD, 0x00, 0x06, 0xFA, 0x17, 0xFA, 0x17, 0x08, 0xEB,
 			                                  0x06, 0xD7, 0x00, 0x13, 0x00, 0x04, 0x0C, 0x89, 0x16, 0x02,
 			                                  0x20, 0x04, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02 }     }
 		};
@@ -761,48 +776,71 @@ SCENARIO("RTCP Feedback RTP Transport", "[rtcp][feedback-rtp][transport]")
 			};
 
 			REQUIRE(feedback->GetReferenceTime() == packetMeta.baseTimeRaw);
-			REQUIRE(feedback->GetReferenceTimestamp() == packetMeta.baseTimeMs);
+			REQUIRE(feedback->GetReferenceTimestampUs() == packetMeta.baseTimeUs);
 			REQUIRE(feedback->GetBaseSequenceNumber() == packetMeta.baseSequence);
 			REQUIRE(feedback->GetPacketStatusCount() == packetMeta.packetStatusCount);
 
-			auto packetsResults = feedback->GetPacketResults();
+			auto packetStatuses = feedback->GetPacketStatuses();
 
 			int deltasIt = 0;
 			for (const auto& delta : packetMeta.deltas)
 			{
-				auto resultDelta = packetsResults[deltasIt].delta;
-				REQUIRE(static_cast<int16_t>(resultDelta / 4) == delta);
+				REQUIRE(packetStatuses[deltasIt].delta == delta);
 				deltasIt++;
 			}
 		}
 	}
 
-	SECTION("check GetBaseDelta() wraparound")
+	SECTION("check GetBaseDeltaUs() wraparound")
 	{
-		static const auto MaxBaseTime = RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriod -
-		                                RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick;
+		static constexpr int64_t MaxBaseTimeUs{ RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs -
+		                                        RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs };
 
 		auto packet1 = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
 		auto packet2 = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
 		auto packet3 = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
 
-		packet1->SetReferenceTime(MaxBaseTime);
-		packet2->SetReferenceTime(MaxBaseTime + RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick);
-		packet3->SetReferenceTime(
-		  MaxBaseTime + RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick +
-		  RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTick);
+		packet1->SetReferenceTimeUs(MaxBaseTimeUs);
+		packet2->SetReferenceTimeUs(MaxBaseTimeUs + RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs);
+		packet3->SetReferenceTimeUs(
+		  MaxBaseTimeUs + RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs +
+		  RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs);
 
-		REQUIRE(packet1->GetReferenceTime() == 16777215);
+		REQUIRE(packet1->GetReferenceTime() == -1);
 		REQUIRE(packet2->GetReferenceTime() == 0);
 		REQUIRE(packet3->GetReferenceTime() == 1);
 
-		REQUIRE(packet1->GetReferenceTimestamp() == 2147483584);
-		REQUIRE(packet2->GetReferenceTimestamp() == 1073741824);
-		REQUIRE(packet3->GetReferenceTimestamp() == 1073741888);
+		REQUIRE(packet1->GetReferenceTimestampUs() == 1073741760000);
+		REQUIRE(packet2->GetReferenceTimestampUs() == 1073741824000);
+		REQUIRE(packet3->GetReferenceTimestampUs() == 1073741888000);
+
+		REQUIRE(packet1->GetBaseDeltaUs(packet1->GetReferenceTimestampUs()) == 0);
+		REQUIRE(packet2->GetBaseDeltaUs(packet1->GetReferenceTimestampUs()) == 64000);
+		REQUIRE(packet3->GetBaseDeltaUs(packet2->GetReferenceTimestampUs()) == 64000);
+		REQUIRE(packet3->GetBaseDeltaUs(packet1->GetReferenceTimestampUs()) == 128000);
+	}
+
+	SECTION("SetBase() wraps the reference time over the whole period GetBaseDeltaUs() compensates for")
+	{
+		// Timestamp sitting on the last whole base time tick before the reference
+		// time wraps around.
+		static constexpr int64_t LastTickUs{ RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs -
+		                                     RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs };
+
+		auto packet1 = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
+		auto packet2 = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(senderSsrc, mediaSsrc);
+
+		packet1->SetBase(1000, LastTickUs);
+		packet2->SetBase(1001, LastTickUs + RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs);
 
-		REQUIRE(packet1->GetBaseDelta(packet1->GetReferenceTimestamp()) == 0);
-		REQUIRE(packet2->GetBaseDelta(packet1->GetReferenceTimestamp()) == 64);
-		REQUIRE(packet3->GetBaseDelta(packet2->GetReferenceTimestamp()) == 64);
-		REQUIRE(packet3->GetBaseDelta(packet1->GetReferenceTimestamp()) == 128);
+		REQUIRE(packet1->GetReferenceTime() == -1);
+		REQUIRE(packet2->GetReferenceTime() == 0);
+
+		// Both packets are a single tick apart, so the wrap around must be
+		// compensated. It would not be if the reference time wrapped sooner than
+		// the period GetBaseDeltaUs() knows about.
+		REQUIRE(
+		  packet2->GetBaseDeltaUs(packet1->GetReferenceTimestampUs()) ==
+		  RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs);
 	}
 }