mediasoup 3.26.0 → 3.27.0

package/worker/test/src/RTC/SCTP/tx/TestStreamScheduler.cpp

@@ -11,7 +11,7 @@ namespace
 {
 	constexpr uint64_t Mtu{ 1000 };
 	constexpr size_t PayloadLength{ 4 };
-	constexpr uint64_t NowMs{ 0 };
+	constexpr int64_t NowUs{ 0 };
 
 	bool checkDataToSendHasMid(
 	  std::optional<RTC::SCTP::SendQueueInterface::DataToSend> dataToSend, uint32_t mid)
@@ -29,11 +29,10 @@ namespace
 		return true;
 	}
 
-	std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(uint64_t, size_t)> createChunk(
+	std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(int64_t, size_t)> createChunk(
 	  uint32_t outgoingMessageId, uint16_t streamId, uint32_t mid, size_t payloadLength = PayloadLength)
 	{
-		return
-		  [streamId, mid, payloadLength, outgoingMessageId](uint64_t /*nowMs*/, size_t /*maxLength*/)
+		return [streamId, mid, payloadLength, outgoingMessageId](int64_t /*nowUs*/, size_t /*maxLength*/)
 		{
 			return RTC::SCTP::SendQueueInterface::DataToSend(
 			  outgoingMessageId,
@@ -58,7 +57,7 @@ namespace
 		for (size_t i{ 0 }; i < packetsToGenerate; ++i)
 		{
 			const std::optional<RTC::SCTP::SendQueueInterface::DataToSend> dataToSend =
-			  scheduler.Produce(NowMs, Mtu);
+			  scheduler.Produce(NowUs, Mtu);
 
 			if (dataToSend.has_value())
 			{
@@ -77,7 +76,7 @@ namespace
 		 * in dcsctp.
 		 */
 		void PushProduce(
-		  std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(uint64_t, size_t)> fn)
+		  std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(int64_t, size_t)> fn)
 		{
 			this->produceQueue.push_back(std::move(fn));
 		}
@@ -91,7 +90,7 @@ namespace
 			this->bytesQueue.push_back(bytes);
 		}
 
-		std::optional<RTC::SCTP::SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength) override
+		std::optional<RTC::SCTP::SendQueueInterface::DataToSend> Produce(int64_t nowUs, size_t maxLength) override
 		{
 			REQUIRE(!this->produceQueue.empty());
 
@@ -99,7 +98,7 @@ namespace
 
 			this->produceQueue.pop_front();
 
-			return fn(nowMs, maxLength);
+			return fn(nowUs, maxLength);
 		}
 
 		size_t GetBytesToSendInNextMessage() const override
@@ -114,7 +113,7 @@ namespace
 		}
 
 	private:
-		std::deque<std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(uint64_t, size_t)>>
+		std::deque<std::function<std::optional<RTC::SCTP::SendQueueInterface::DataToSend>(int64_t, size_t)>>
 		  produceQueue;
 		mutable std::deque<size_t> bytesQueue;
 	};
@@ -159,7 +158,7 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 	{
 		RTC::SCTP::StreamScheduler scheduler(Mtu);
 
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Stream properties can be set and retrieved.
@@ -190,8 +189,8 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 0));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 0));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// A scheduler with a single stream produced packets from it.
@@ -226,13 +225,13 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream2->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Switches between two streams after every packet.
@@ -267,13 +266,13 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream2->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Switches between two streams after every packet, but keeps producing from
@@ -291,21 +290,21 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 		// 2. beginning:false, end:false
 		// 3. beginning:false, end:true
 		producer1.PushProduce(
-		  [](uint64_t, size_t)
+		  [](int64_t, size_t)
 		  {
 			  return RTC::SCTP::SendQueueInterface::DataToSend(
 			    1, RTC::SCTP::UserData(1, 0, 101, 0, 42, std::vector<uint8_t>(4), true, false, true));
 		  });
 		producer1.PushBytesToSend(PayloadLength);
 		producer1.PushProduce(
-		  [](uint64_t, size_t)
+		  [](int64_t, size_t)
 		  {
 			  return RTC::SCTP::SendQueueInterface::DataToSend(
 			    1, RTC::SCTP::UserData(1, 0, 101, 0, 42, std::vector<uint8_t>(4), false, false, true));
 		  });
 		producer1.PushBytesToSend(PayloadLength);
 		producer1.PushProduce(
-		  [](uint64_t, size_t)
+		  [](int64_t, size_t)
 		  {
 			  return RTC::SCTP::SendQueueInterface::DataToSend(
 			    1, RTC::SCTP::UserData(1, 0, 101, 0, 42, std::vector<uint8_t>(4), false, true, true));
@@ -332,16 +331,16 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream2->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200));
 		// MID(101) is fully produced before giving up on stream2.
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Resumes a paused stream - makes a stream active after inactivating it.
@@ -363,17 +362,17 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream1->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
 
 		stream1->MakeInactive();
 
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 
 		stream1->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Iterates between streams, where one is suddenly paused and later resumed.
@@ -409,18 +408,18 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream2->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200));
 
 		stream1->MakeInactive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202));
 
 		stream1->MayMakeActive();
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101));
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102));
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101));
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102));
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Verifies that packet counts are evenly distributed in round robin
@@ -514,13 +513,13 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream2->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100)); // t = 30
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101)); // t = 60
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200)); // t = 70
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102)); // t = 90
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201)); // t = 140
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202)); // t = 210
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100)); // t = 30
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101)); // t = 60
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200)); // t = 70
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102)); // t = 90
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201)); // t = 140
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202)); // t = 210
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Will do weighted fair queuing with three streams having different priority.
@@ -575,16 +574,16 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream3->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 300)); // t ~= 20
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 301)); // t ~= 40
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200)); // t ~= 50
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 302)); // t ~= 60
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100)); // t ~= 80
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201)); // t ~= 100
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202)); // t ~= 150
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101)); // t ~= 160
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102)); // t ~= 240
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 300)); // t ~= 20
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 301)); // t ~= 40
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200)); // t ~= 50
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 302)); // t ~= 60
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100)); // t ~= 80
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201)); // t ~= 100
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202)); // t ~= 150
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101)); // t ~= 160
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102)); // t ~= 240
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Will do weighted fair queuing with three streams having different priority
@@ -644,16 +643,16 @@ SCENARIO("SCTP StreamScheduler", "[sctp][streamscheduler]")
 
 		stream3->MayMakeActive();
 
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 300)); // t ~= 400
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 301)); // t ~= 1400
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 200)); // t ~= 2500
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 302)); // t ~= 2800
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 100)); // t ~= 4000
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 101)); // t ~= 5600
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 201)); // t ~= 6000
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 202)); // t ~= 7000
-		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowMs, Mtu), 102)); // t ~= 11200
-		REQUIRE(!scheduler.Produce(NowMs, Mtu).has_value());
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 300)); // t ~= 400
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 301)); // t ~= 1400
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 200)); // t ~= 2500
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 302)); // t ~= 2800
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 100)); // t ~= 4000
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 101)); // t ~= 5600
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 201)); // t ~= 6000
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 202)); // t ~= 7000
+		REQUIRE(checkDataToSendHasMid(scheduler.Produce(NowUs, Mtu), 102)); // t ~= 11200
+		REQUIRE(!scheduler.Produce(NowUs, Mtu).has_value());
 	}
 
 	// Two streams of different priority, identical packet size: ratio of packets

package/worker/test/src/RTC/TestConsumer.cpp

@@ -14,10 +14,10 @@ namespace
 {
 	// NOLINTBEGIN(readability-identifier-naming)
 	const uint8_t payloadType = 111;
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 	// NOLINTEND(readability-identifier-naming)
 
@@ -37,6 +37,11 @@ namespace
 		{
 			return 0;
 		}
+
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/) override
+		{
+		}
 	};
 
 	class ConsumerListener : public RTC::Consumer::Listener

package/worker/test/src/RTC/TestKeyFrameRequestManager.cpp

@@ -23,10 +23,10 @@ SCENARIO("KeyFrameRequestManager", "[rtp][keyframe]")
 	};
 
 	TestKeyFrameRequestManagerListener listener;
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 
 	SECTION("key frame requested once, not received on time")

package/worker/test/src/RTC/TestNackGenerator.cpp

@@ -125,10 +125,10 @@ SCENARIO("NackGenerator generator", "[rtp][rtcp][nack]")
 		bool keyFrameRequiredTriggered{ false };
 	};
 
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 
 	auto validate =

package/worker/test/src/RTC/TestPipeProducerStreamManager.cpp

@@ -96,10 +96,10 @@ namespace
 	};
 
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return DepLibUV::GetTimeMs();
+		                         return DepLibUV::GetTimeUs();
 	                         });
 
 	std::unique_ptr<RTC::PipeProducerStreamManager> createManager(
@@ -454,7 +454,7 @@ SCENARIO("PipeProducerStreamManager", "[rtp][producerstreammanager][pipe]")
 
 		manager->SetExternallyManagedBitrate();
 
-		const auto used = manager->IncreaseLayer(1000000u, false, 0.0f, DepLibUV::GetTimeMs());
+		const auto used = manager->IncreaseLayer(1000000, false, 0.0f, DepLibUV::GetTimeMs());
 
 		REQUIRE(used == 0u);
 	}
@@ -466,6 +466,6 @@ SCENARIO("PipeProducerStreamManager", "[rtp][producerstreammanager][pipe]")
 
 		manager->SetExternallyManagedBitrate();
 
-		REQUIRE(manager->GetDesiredBitrate(DepLibUV::GetTimeMs()) == 0u);
+		REQUIRE(manager->GetDesiredBitrate(DepLibUV::GetTimeMs()) == 0);
 	}
 }

package/worker/test/src/RTC/TestRateCalculator.cpp

@@ -14,7 +14,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	};
 
 	auto validate =
-	  [](RTC::RateCalculator& rate, uint64_t timeBaseMs, const std::vector<TestRateCalculatorData>& input)
+	  [](RTC::RateCalculator& rate, int64_t timeBaseMs, const std::vector<TestRateCalculatorData>& input)
 	{
 		for (const auto& item : input)
 		{
@@ -23,28 +23,22 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 			REQUIRE(rate.GetRate(timeBaseMs + item.offset) == item.rate);
 		}
 
-		// Repeat forcing nowMs to be 0.
+		// Repeat asking for the rate at a time older than the whole window, which
+		// must leave it untouched.
 		rate.Reset();
 
 		for (const auto& item : input)
 		{
 			rate.Update(item.size, timeBaseMs + item.offset);
 
-			REQUIRE(rate.GetRate(0 + item.offset) == item.rate);
+			REQUIRE(rate.GetRate(item.offset) == item.rate);
 		}
 
-		// Repeat forcing nowMs to be std::numeric_limits<uint64_t>::max() - 100.
-		rate.Reset();
-
-		for (const auto& item : input)
-		{
-			rate.Update(item.size, timeBaseMs + item.offset);
-
-			REQUIRE(rate.GetRate(std::numeric_limits<uint64_t>::max() - 100 + item.offset) == item.rate);
-		}
+		// Asking for the rate far in the future expires every item.
+		REQUIRE(rate.GetRate(std::numeric_limits<int64_t>::max()) == 0);
 	};
 
-	const uint64_t nowMs = 12345678;
+	const int64_t nowMs = 12345678;
 
 	SECTION("receive single item per 1000 ms")
 	{
@@ -163,7 +157,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	//   https://github.com/versatica/mediasoup/issues/1316
 	SECTION("buffer overflow should not crash")
 	{
-		// window: 1000ms, items: 3 (granularity: 333ms)
+		// window: 1000ms, items: 3 (granularity: 334ms)
 		RTC::RateCalculator rate(1000, 8000, 3);
 
 		// clang-format off
@@ -178,4 +172,106 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 
 		validate(rate, nowMs, input);
 	}
+
+	// NOTE: This pins the item grid alignment. Items must advance by whole
+	// itemSizeMs steps so that a full ring always spans the window size. If the
+	// newest item start time jumped to nowMs instead, items would absorb the
+	// elapsed time remainder, the ring would span more time than the window, and
+	// the rate would be over-reported.
+	SECTION("item boundaries do not drift with traffic timing")
+	{
+		// window: 1000ms, items: 100 (granularity: 10ms)
+		RTC::RateCalculator rate(1000, 8000, 100);
+
+		// 11ms spacing, deliberately not a multiple of the 10ms granularity.
+		for (int64_t i{ 0 }; i <= 100; ++i)
+		{
+			rate.Update(1, nowMs + (i * 11));
+		}
+
+		// The ring spans the items starting at [110, 1100], which hold the 91
+		// packets sent at 110, 121 ... 1100.
+		REQUIRE(rate.GetRate(nowMs + 1100) == 91 * 8);
+	}
+
+	// NOTE: This pins the GetRate() memoization key, which is both nowMs and the
+	// total count. Keying it on nowMs alone would return a stale rate.
+	SECTION("rate is recalculated after Update() with the same now")
+	{
+		RTC::RateCalculator rate(1000, 8000, 100);
+
+		rate.Update(5, nowMs);
+
+		REQUIRE(rate.GetRate(nowMs) == 40);
+
+		rate.Update(5, nowMs);
+
+		REQUIRE(rate.GetRate(nowMs) == 80);
+
+		rate.Update(5, nowMs);
+
+		REQUIRE(rate.GetRate(nowMs) == 120);
+
+		// Repeated reads with no Update() in between must be stable.
+		REQUIRE(rate.GetRate(nowMs) == 120);
+		REQUIRE(rate.GetRate(nowMs) == 120);
+	}
+
+	// NOTE: This pins the item size rounding for a window size which is not a
+	// multiple of it. Rounding the item size down would make a full ring span more
+	// time than the window, over-reporting the rate.
+	SECTION("window not divisible by items spans the window size")
+	{
+		// window: 1000ms, items: 3 (granularity: 334ms)
+		RTC::RateCalculator rate(1000, 8000, 3);
+
+		// Feed way past the ring size, so that any extra span accumulates.
+		for (int64_t i{ 0 }; i < 100; ++i)
+		{
+			rate.Update(1, nowMs + (i * 334));
+		}
+
+		// Steady state is a full ring of 3 items holding 1 byte each.
+		REQUIRE(rate.GetRate(nowMs + (99 * 334)) == 24);
+	}
+
+	// NOTE: This pins that the GetRate() memoization needs no "not calculated yet"
+	// mark. Its zeroed initial state is a valid entry, so a read at time 0 must be
+	// neither a stale hit nor a miss returning something else than 0.
+	SECTION("rate at time 0 on a fresh and on a reset calculator")
+	{
+		RTC::RateCalculator rate(1000, 8000, 100);
+
+		REQUIRE(rate.GetRate(0) == 0);
+
+		rate.Update(5, 0);
+
+		REQUIRE(rate.GetRate(0) == 40);
+
+		rate.Reset();
+
+		REQUIRE(rate.GetRate(0) == 0);
+
+		rate.Update(5, 0);
+
+		REQUIRE(rate.GetRate(0) == 40);
+	}
+
+	// NOTE: This pins the constructor clamping. A zero number of items used to
+	// divide by zero, and a zero window size to leave an empty buffer.
+	SECTION("degenerate constructor arguments are clamped")
+	{
+		RTC::RateCalculator noItems(1000, 8000, 0);
+		RTC::RateCalculator oneItem(1000, 8000, 1);
+		RTC::RateCalculator noWindow(0, 8000, 100);
+
+		noItems.Update(5, nowMs);
+		oneItem.Update(5, nowMs);
+		noWindow.Update(5, nowMs);
+
+		REQUIRE(noItems.GetRate(nowMs) == 40);
+		REQUIRE(oneItem.GetRate(nowMs) == 40);
+		// The window size is clamped to 1ms.
+		REQUIRE(noWindow.GetRate(nowMs) == 40000);
+	}
 }

package/worker/test/src/RTC/TestRemoteCaptureTimeEstimator.cpp

@@ -13,7 +13,7 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 	// RTP timestamp that first Sender Report reports about.
 	constexpr uint32_t RemoteBaseTs{ 1000000 };
 	// Our own monotonic clock when that first Sender Report arrives.
-	constexpr uint64_t LocalBaseMs{ 1000000 };
+	constexpr int64_t LocalBaseUs{ 1000000 * 1000 };
 	constexpr uint32_t ClockRate{ 90000 };
 	constexpr uint32_t Ssrc{ 1111 };
 
@@ -34,14 +34,19 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		{
 			return 0;
 		}
+
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/) override
+		{
+		}
 	};
 
-	uint64_t nowMs{ LocalBaseMs };
+	int64_t nowUs{ LocalBaseUs };
 
-	mocks::MockShared shared(/*getTimeMs*/
-	                         [&nowMs]() -> uint64_t
+	mocks::MockShared shared(/*getTimeUs*/
+	                         [&nowUs]() -> int64_t
 	                         {
-		                         return nowMs;
+		                         return nowUs;
 	                         });
 
 	RTC::RTP::RtpStream::Params params;
@@ -61,9 +66,9 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 	// Makes the Sender Report about `RemoteBaseTs` plus `idx` seconds of media reach
 	// us with no delay at all, and feeds it to the estimator.
-	auto receiveSenderReport = [&nowMs, &rtpStream, &estimator](uint32_t idx) -> void
+	auto receiveSenderReport = [&nowUs, &shared, &rtpStream, &estimator](uint32_t idx) -> void
 	{
-		nowMs = LocalBaseMs + (idx * 1000);
+		nowUs = LocalBaseUs + (idx * 1000000);
 
 		RTC::RTCP::SenderReport report;
 
@@ -72,14 +77,14 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		report.SetNtpFrac(0);
 		report.SetRtpTs(RemoteBaseTs + (idx * ClockRate));
 
-		rtpStream.ReceiveRtcpSenderReport(std::addressof(report));
+		rtpStream.ReceiveRtcpSenderReport(std::addressof(report), shared.GetTimeUs());
 		estimator.SenderReportReceived(std::addressof(rtpStream));
 	};
 
 	SECTION("no source until the first Producer has been taken into account")
 	{
 		REQUIRE_FALSE(estimator.GetSource().has_value());
-		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
 	}
 
 	SECTION("the first Producer chooses abs-capture-time when it negotiated it")
@@ -120,7 +125,7 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		// A single Sender Report is not enough for the clock offset to be estimated.
 		receiveSenderReport(0);
 
-		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
 
 		for (uint32_t idx{ 1 }; idx < RTC::RemoteClockOffsetEstimator::MinSampleCount; ++idx)
 		{
@@ -132,20 +137,20 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 		const auto lastIdx = RTC::RemoteClockOffsetEstimator::MinSampleCount - 1;
 		const auto lastTs  = static_cast<uint32_t>(RemoteBaseTs + (lastIdx * ClockRate));
 
-		REQUIRE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), lastTs).has_value());
+		REQUIRE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs).has_value());
 		REQUIRE(
 		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		  estimator.GetLocalCaptureMs(std::addressof(rtpStream), lastTs).value() ==
-		  LocalBaseMs + (lastIdx * 1000));
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), lastTs).value() ==
+		  LocalBaseUs + (lastIdx * 1000000));
 
 		// One second of media later maps one second later in our clock too.
 		const auto nextTs = static_cast<uint32_t>(RemoteBaseTs + ((lastIdx + 1) * ClockRate));
 
-		REQUIRE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), nextTs).has_value());
+		REQUIRE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs).has_value());
 		REQUIRE(
 		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		  estimator.GetLocalCaptureMs(std::addressof(rtpStream), nextTs).value() ==
-		  LocalBaseMs + ((lastIdx + 1) * 1000));
+		  estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), nextTs).value() ==
+		  LocalBaseUs + ((lastIdx + 1) * 1000000));
 	}
 
 	SECTION("no capture instant while the abs-capture-time source has nothing to offer")
@@ -159,6 +164,6 @@ SCENARIO("RemoteCaptureTimeEstimator", "[rtp][rtcp][remotecapturetimeestimator]"
 
 		// Sender Reports have been received, but the source in use is not allowed to
 		// fall back to them.
-		REQUIRE_FALSE(estimator.GetLocalCaptureMs(std::addressof(rtpStream), RemoteBaseTs).has_value());
+		REQUIRE_FALSE(estimator.GetLocalCaptureAtUs(std::addressof(rtpStream), RemoteBaseTs).has_value());
 	}
 }