mediasoup 3.26.0 → 3.27.1

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

@@ -13,14 +13,14 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 	struct TestTransportCongestionControlServerInput
 	{
 		uint16_t wideSeqNumber;
-		uint64_t nowMs;
+		int64_t nowUs;
 	};
 
 	struct TestTransportCongestionControlServerResult
 	{
 		uint16_t wideSeqNumber;
 		bool received;
-		uint64_t timestamp;
+		int64_t timestampUs;
 	};
 
 	using TestResults = std::deque<std::vector<TestTransportCongestionControlServerResult>>;
@@ -39,27 +39,32 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 				return;
 			}
 
-			auto packetResults = tccPacket->GetPacketResults();
+			auto packetStatuses = tccPacket->GetPacketStatuses();
 
 			REQUIRE(!this->results.empty());
 
 			auto testResults = this->results.front();
 			this->results.pop_front();
 
-			REQUIRE(testResults.size() == packetResults.size());
+			REQUIRE(testResults.size() == packetStatuses.size());
 
-			auto packetResultIt = packetResults.begin();
+			auto packetStatusIt = packetStatuses.begin();
 			auto testResultIt   = testResults.begin();
 
-			for (; packetResultIt != packetResults.end() && testResultIt != testResults.end();
-			     ++packetResultIt, ++testResultIt)
+			for (; packetStatusIt != packetStatuses.end() && testResultIt != testResults.end();
+			     ++packetStatusIt, ++testResultIt)
 			{
-				REQUIRE(packetResultIt->sequenceNumber == testResultIt->wideSeqNumber);
-				REQUIRE(packetResultIt->received == testResultIt->received);
+				REQUIRE(packetStatusIt->sequenceNumber == testResultIt->wideSeqNumber);
+				REQUIRE(packetStatusIt->received == testResultIt->received);
 
-				if (packetResultIt->received)
+				if (packetStatusIt->received)
 				{
-					REQUIRE(packetResultIt->receivedAtMs == static_cast<int64_t>(testResultIt->timestamp));
+					// The reconstructed times sit in the frame of the reference time,
+					// which is shifted by a whole wrap period so that it's positive
+					// regardless of the sign of the reference time on the wire.
+					REQUIRE(
+					  packetStatusIt->receivedAtUs ==
+					  RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs + testResultIt->timestampUs);
 				}
 			}
 		}
@@ -79,10 +84,10 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		TestResults results;
 	};
 
-	mocks::MockShared shared(/*getTimeMs*/
-	                         []()
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
 	                         {
-		                         return 1000;
+		                         return 1000 * 1000;
 	                         });
 
 	// clang-format off
@@ -98,7 +103,7 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 
 	auto validate =
 	  [&buffer,
-	   &shared](std::vector<TestTransportCongestionControlServerInput>& inputs, TestResults& results)
+		 &shared](std::vector<TestTransportCongestionControlServerInput>& inputs, TestResults& results)
 	{
 		TestTransportCongestionControlServerListener listener;
 		auto tccServer = RTC::TransportCongestionControlServer(
@@ -122,22 +127,23 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// Save results.
 		listener.SetResults(results);
 
-		uint64_t startTs = inputs[0].nowMs;
-		uint64_t TransportCcFeedbackSendInterval{ 100u }; // In ms.
+		static constexpr int64_t TransportCcFeedbackSendIntervalUs{ 100 * 1000 };
+
+		int64_t startTsUs = inputs[0].nowUs;
 
 		for (auto input : inputs)
 		{
 			// Periodic sending TCC packets.
-			uint64_t diffTs = input.nowMs - startTs;
+			const int64_t diffTsUs = input.nowUs - startTsUs;
 
-			if (diffTs >= TransportCcFeedbackSendInterval)
+			if (diffTsUs >= TransportCcFeedbackSendIntervalUs)
 			{
 				tccServer.FillAndSendTransportCcFeedback();
-				startTs = input.nowMs;
+				startTsUs = input.nowUs;
 			}
 
 			packet->UpdateTransportWideCc01(input.wideSeqNumber);
-			tccServer.IncomingPacket(input.nowMs, packet.get());
+			tccServer.IncomingPacket(input.nowUs, packet.get());
 		}
 
 		tccServer.FillAndSendTransportCcFeedback();
@@ -149,25 +155,25 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{ 1u, 1000u },
-			{ 2u, 1050u },
-			{ 3u, 1100u },
-			{ 4u, 1150u },
-			{ 5u, 1200u },
+			{ 1u, 1000000 },
+			{ 2u, 1050000 },
+			{ 3u, 1100000 },
+			{ 4u, 1150000 },
+			{ 5u, 1200000 },
 		};
 
 		TestResults results
 		{
 			{
-				{ 1u, true, 1000u },
-				{ 2u, true, 1050u },
+				{ 1u, true, 1000000 },
+				{ 2u, true, 1050000 },
 			},
 			{
-				{ 3u, true, 1100u },
-				{ 4u, true, 1150u },
+				{ 3u, true, 1100000 },
+				{ 4u, true, 1150000 },
 			},
 			{
-				{ 5u, true, 1200u },
+				{ 5u, true, 1200000 },
 			},
 		};
 		// clang-format on
@@ -180,23 +186,23 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{  1u, 1000u },
-			{  3u, 1050u },
-			{  5u, 1100u },
-			{  6u, 1150u },
+			{  1u, 1000000 },
+			{  3u, 1050000 },
+			{  5u, 1100000 },
+			{  6u, 1150000 },
 		};
 
 		TestResults results
 		{
 			{
-				{ 1u,  true, 1000u },
-				{ 2u, false,    0u },
-				{ 3u,  true, 1050u },
+				{ 1u,  true, 1000000 },
+				{ 2u, false,       0 },
+				{ 3u,  true, 1050000 },
 			},
 			{
-				{ 4u, false,    0u },
-				{ 5u,  true, 1100u },
-				{ 6u,  true, 1150u },
+				{ 4u, false,       0 },
+				{ 5u,  true, 1100000 },
+				{ 6u,  true, 1150000 },
 			},
 		};
 		// clang-format on
@@ -209,25 +215,25 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{  1u, 1000u },
-			{  1u, 1050u },
-			{  2u, 1100u },
-			{  3u, 1150u },
-			{  3u, 1200u },
-			{  4u, 1250u },
+			{  1u, 1000000 },
+			{  1u, 1050000 },
+			{  2u, 1100000 },
+			{  3u, 1150000 },
+			{  3u, 1200000 },
+			{  4u, 1250000 },
 		};
 
 		TestResults results
 		{
 			{
-				{ 1u,  true, 1000u },
+				{ 1u,  true, 1000000 },
 			},
 			{
-				{ 2u,  true, 1100u },
-				{ 3u,  true, 1150u },
+				{ 2u,  true, 1100000 },
+				{ 3u,  true, 1150000 },
 			},
 			{
-				{ 4u,  true, 1250u },
+				{ 4u,  true, 1250000 },
 			},
 		};
 		// clang-format on
@@ -240,30 +246,30 @@ SCENARIO("TransportCongestionControlServer", "[rtp]")
 		// clang-format off
 		std::vector<TestTransportCongestionControlServerInput> inputs
 		{
-			{ 1u, 1000u },
-			{ 2u, 1050u },
-			{ 4u, 1100u },
-			{ 5u, 1150u },
-			{ 3u, 1200u }, // Out of order
-			{ 6u, 1250u },
+			{ 1u, 1000000 },
+			{ 2u, 1050000 },
+			{ 4u, 1100000 },
+			{ 5u, 1150000 },
+			{ 3u, 1200000 }, // Out of order
+			{ 6u, 1250000 },
 		};
 
 		TestResults results
 		{
 			{
-				{ 1u, true, 1000u },
-				{ 2u, true, 1050u },
+				{ 1u, true, 1000000 },
+				{ 2u, true, 1050000 },
 			},
 			{
-				{ 3u, false,    0u },
-				{ 4u,  true, 1100u },
-				{ 5u,  true, 1150u },
+				{ 3u, false,       0 },
+				{ 4u,  true, 1100000 },
+				{ 5u,  true, 1150000 },
 			},
 			{
-				{ 3u, true, 1200u },
-				{ 4u, true, 1100u },
-				{ 5u, true, 1150u },
-				{ 6u, true, 1250u },
+				{ 3u, true, 1200000 },
+				{ 4u, true, 1100000 },
+				{ 5u, true, 1150000 },
+				{ 6u, true, 1250000 },
 			},
 		};
 		// clang-format on

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

@@ -3,6 +3,7 @@
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
 #include "RTC/UdpSocket.hpp"
+#include "mocks/include/MockShared.hpp"
 #include <uv.h>
 #include <catch2/catch_test_macros.hpp>
 
@@ -16,18 +17,32 @@ SCENARIO("TransportTuple", "[transporttuple]")
 		  const uint8_t* /*data*/,
 		  size_t /*len*/,
 		  size_t /*bufferLen*/,
-		  const struct sockaddr* /*remoteAddr*/) override
+		  const struct sockaddr* /*remoteAddr*/,
+		  int64_t /*receivedAtUs*/) override
 		{
 		}
 	};
 
-	auto makeUdpSocket = [](const std::string& ip, uint16_t minPort, uint16_t maxPort)
+	// NOTE: These outlive the sockets created below, which hold pointers to them.
+	UdpSocketListener listener;
+	mocks::MockShared shared(/*getTimeUs*/
+	                         []() -> int64_t
+	                         {
+		                         return 1000 * 1000;
+	                         });
+
+	auto makeUdpSocket = [&listener, &shared](const std::string& ip, uint16_t minPort, uint16_t maxPort)
 	{
-		UdpSocketListener listener;
 		auto flags = RTC::Transport::SocketFlags{ .ipv6Only = false, .udpReusePort = false };
 		RTC::PortManager::PortRangeKey portRangeKey{};
 		auto* udpSocket = new RTC::UdpSocket(
-		  std::addressof(listener), const_cast<std::string&>(ip), minPort, maxPort, flags, portRangeKey);
+		  std::addressof(listener),
+		  std::addressof(shared),
+		  const_cast<std::string&>(ip),
+		  minPort,
+		  maxPort,
+		  flags,
+		  portRangeKey);
 
 		return std::unique_ptr<RTC::UdpSocket>(udpSocket);
 	};

package/worker/test/src/TestDepLibUV.cpp

@@ -0,0 +1,19 @@
+#include "common.hpp"
+#include "DepLibUV.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("DepLibUV", "[deplibuv]")
+{
+	SECTION("GetNtpOffsetUs()")
+	{
+		// Added to our own clock it must give an NTP instant of the current era, so
+		// past the moment this test was written.
+		//
+		// Seconds since Jan 1, 1900 at Jan 1, 2026.
+		constexpr int64_t Jan2026NtpSec{ 3976214400 };
+
+		const int64_t ntpUs = DepLibUV::GetTimeUs() + DepLibUV::GetNtpOffsetUs();
+
+		REQUIRE(ntpUs / 1000000 > Jan2026NtpSec);
+	}
+}

package/worker/test/src/Utils/TestTime.cpp

@@ -5,64 +5,95 @@
 
 SCENARIO("Utils::Time", "[utils][time]")
 {
-	SECTION("Ntp2TimeMs()")
+	SECTION("Ntp2TimeUs()")
 	{
-		const auto nowMs  = DepLibUV::GetTimeMs();
-		const auto ntp    = Utils::Time::TimeMs2Ntp(nowMs);
-		const auto nowMs2 = Utils::Time::Ntp2TimeMs(ntp);
-		const auto ntp2   = Utils::Time::TimeMs2Ntp(nowMs2);
+		const auto nowUs  = DepLibUV::GetTimeUs();
+		const auto ntp    = Utils::Time::TimeUs2Ntp(nowUs);
+		const auto nowUs2 = Utils::Time::Ntp2TimeUs(ntp);
+		const auto ntp2   = Utils::Time::TimeUs2Ntp(nowUs2);
 
-		REQUIRE(nowMs2 == nowMs);
+		REQUIRE(nowUs2 == nowUs);
 		REQUIRE(ntp2.seconds == ntp.seconds);
 		REQUIRE(ntp2.fractions == ntp.fractions);
 	}
 
-	SECTION("TimeMs2Ntp()")
+	SECTION("TimeUs2Ntp()")
 	{
-		auto ntp = Utils::Time::TimeMs2Ntp(1500);
+		auto ntp = Utils::Time::TimeUs2Ntp(1500000);
 
 		REQUIRE(ntp.seconds == 1);
 		// Half a second in NTP fractional units.
 		REQUIRE(ntp.fractions == 2147483648);
 
 		// A real NTP instant, seconds since Jan 1, 1900, which still fits in 32 bits.
-		ntp = Utils::Time::TimeMs2Ntp(3990000000750);
+		ntp = Utils::Time::TimeUs2Ntp(3990000000750000);
 
 		REQUIRE(ntp.seconds == 3990000000);
-		REQUIRE(Utils::Time::Ntp2TimeMs(ntp) == 3990000000750);
+		REQUIRE(Utils::Time::Ntp2TimeUs(ntp) == 3990000000750000);
+
+		// Sub-millisecond times are kept.
+		REQUIRE(Utils::Time::TimeUs2Ntp(1000500).fractions > Utils::Time::TimeUs2Ntp(1000000).fractions);
+		REQUIRE(Utils::Time::TimeUs2Ntp(1000500).fractions < Utils::Time::TimeUs2Ntp(1001000).fractions);
+		REQUIRE(Utils::Time::Ntp2TimeUs(Utils::Time::TimeUs2Ntp(1000500)) == 1000500);
+	}
+
+	SECTION("TimeUsToAbsSendTime()")
+	{
+		// A whole second is the fractional unit itself, being the format 6.18 fixed
+		// point seconds.
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(1000000) == 262144);
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(1500000) == 393216);
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(0) == 0);
+		// Resolution is 1/262144 of a second, so a couple of microseconds already
+		// move the value.
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(2) == 1);
+
+		// Only 6 bits of seconds are kept, so the value wraps every 64 seconds.
+		constexpr int64_t WrapPeriodUs{ 64 * 1000000 };
+
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(WrapPeriodUs) == 0);
+		REQUIRE(
+		  Utils::Time::TimeUsToAbsSendTime(WrapPeriodUs + 1000000) ==
+		  Utils::Time::TimeUsToAbsSendTime(1000000));
+
+		// A negative time yields the value of the positive time it's congruent with.
+		REQUIRE(
+		  Utils::Time::TimeUsToAbsSendTime(-1000000) ==
+		  Utils::Time::TimeUsToAbsSendTime(WrapPeriodUs - 1000000));
+		REQUIRE(Utils::Time::TimeUsToAbsSendTime(-WrapPeriodUs) == 0);
 	}
 
-	SECTION("TimeMs2Q32x32()")
+	SECTION("TimeUs2Q32x32()")
 	{
 		// A whole second is the fractional unit itself.
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeMs2Q32x32(1000).value() == 4294967296);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(1000000).value() == 4294967296);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeMs2Q32x32(-1000).value() == -4294967296);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(-1000000).value() == -4294967296);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeMs2Q32x32(0).value() == 0);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(0).value() == 0);
 		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-		REQUIRE(Utils::Time::TimeMs2Q32x32(1).value() == 4294967);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(1000).value() == 4294967);
 
 		// Seconds are 32 bits wide in the format, so 2^31 seconds no longer fit.
-		constexpr int64_t OutOfRangeMs{ (1LL << 31) * 1000 };
+		constexpr int64_t OutOfRangeUs{ (1LL << 31) * 1000000 };
 
-		REQUIRE(Utils::Time::TimeMs2Q32x32(OutOfRangeMs) == std::nullopt);
-		REQUIRE(Utils::Time::TimeMs2Q32x32(-OutOfRangeMs) == std::nullopt);
-		REQUIRE(Utils::Time::TimeMs2Q32x32(OutOfRangeMs - 1).has_value());
-		REQUIRE(Utils::Time::TimeMs2Q32x32(-OutOfRangeMs + 1).has_value());
+		REQUIRE(Utils::Time::TimeUs2Q32x32(OutOfRangeUs) == std::nullopt);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(-OutOfRangeUs) == std::nullopt);
+		REQUIRE(Utils::Time::TimeUs2Q32x32(OutOfRangeUs - 1).has_value());
+		REQUIRE(Utils::Time::TimeUs2Q32x32(-OutOfRangeUs + 1).has_value());
 	}
 
-	SECTION("Q32x32ToTimeMs()")
+	SECTION("Q32x32ToTimeUs()")
 	{
-		REQUIRE(Utils::Time::Q32x32ToTimeMs(4294967296) == 1000);
-		REQUIRE(Utils::Time::Q32x32ToTimeMs(-4294967296) == -1000);
-		REQUIRE(Utils::Time::Q32x32ToTimeMs(0) == 0);
+		REQUIRE(Utils::Time::Q32x32ToTimeUs(4294967296) == 1000000);
+		REQUIRE(Utils::Time::Q32x32ToTimeUs(-4294967296) == -1000000);
+		REQUIRE(Utils::Time::Q32x32ToTimeUs(0) == 0);
 
-		for (const int64_t ms : { 1, -1, 1000, -1000, 123456, -123456 })
+		for (const int64_t us : { 1, -1, 1000, -1000, 1000000, -1000000, 123456789, -123456789 })
 		{
 			// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-			REQUIRE(Utils::Time::Q32x32ToTimeMs(Utils::Time::TimeMs2Q32x32(ms).value()) == ms);
+			REQUIRE(Utils::Time::Q32x32ToTimeUs(Utils::Time::TimeUs2Q32x32(us).value()) == us);
 		}
 	}
 }

package/worker/test/src/testHelpers.cpp

@@ -1,4 +1,4 @@
-#define MS_CLASS "TEST::HELPERS"
+#define MS_CLASS "test::helpers"
 
 #include "test/include/testHelpers.hpp"
 #include "Logger.hpp"

package/worker/test/src/tests.cpp

@@ -1,7 +1,9 @@
 #include "common.hpp"
 #include "DepLibSRTP.hpp"
 #include "DepLibUV.hpp"
+#ifndef MS_USE_BUILTIN_BWE
 #include "DepLibWebRTC.hpp"
+#endif
 #include "DepOpenSSL.hpp"
 #include "Settings.hpp"
 #include "Utils.hpp"
@@ -46,7 +48,9 @@ int main(int argc, char* argv[])
 	DepLibUV::ClassInit();
 	DepOpenSSL::ClassInit();
 	DepLibSRTP::ClassInit();
+#ifndef MS_USE_BUILTIN_BWE
 	DepLibWebRTC::ClassInit();
+#endif
 	Utils::Crypto::ClassInit();
 
 	Catch::Session session;
@@ -56,7 +60,9 @@ int main(int argc, char* argv[])
 	// Free static stuff.
 	DepLibSRTP::ClassDestroy();
 	Utils::Crypto::ClassDestroy();
+#ifndef MS_USE_BUILTIN_BWE
 	DepLibWebRTC::ClassDestroy();
+#endif
 	DepLibUV::ClassDestroy();
 
 	return status;

package/worker/include/RTC/SenderBandwidthEstimator.hpp

@@ -1,118 +0,0 @@
-#ifndef MS_RTC_SENDER_BANDWIDTH_ESTIMATOR_HPP
-#define MS_RTC_SENDER_BANDWIDTH_ESTIMATOR_HPP
-
-#include "common.hpp"
-#include "RTC/RTCP/FeedbackRtpTransport.hpp"
-#include "RTC/RateCalculator.hpp"
-#include "RTC/SeqManager.hpp"
-#include "RTC/TrendCalculator.hpp"
-#include "SharedInterface.hpp"
-#include <map>
-
-namespace RTC
-{
-	class SenderBandwidthEstimator
-	{
-	public:
-		class Listener
-		{
-		public:
-			virtual ~Listener() = default;
-
-		public:
-			virtual void OnSenderBandwidthEstimatorAvailableBitrate(
-			  RTC::SenderBandwidthEstimator* senderBwe,
-			  uint32_t availableBitrate,
-			  uint32_t previousAvailableBitrate) = 0;
-		};
-
-	public:
-		struct SentInfo
-		{
-			uint16_t wideSeq{ 0u };
-			size_t size{ 0u };
-			bool isProbation{ false };
-			uint64_t sendingAtMs{ 0u };
-			uint64_t sentAtMs{ 0u };
-		};
-
-	private:
-		class CummulativeResult
-		{
-		public:
-			CummulativeResult() = default;
-
-		public:
-			uint64_t GetStartedAtMs() const
-			{
-				return this->firstPacketSentAtMs;
-			}
-			size_t GetNumPackets() const
-			{
-				return this->numPackets;
-			}
-			size_t GetTotalSize() const
-			{
-				return this->totalSize;
-			}
-			uint32_t GetSendBitrate() const
-			{
-				auto sendIntervalMs =
-				  std::max<uint64_t>(this->lastPacketSentAtMs - this->firstPacketSentAtMs, 1u);
-
-				return static_cast<uint32_t>(this->totalSize / sendIntervalMs) * 8 * 1000;
-			}
-			uint32_t GetReceiveBitrate() const
-			{
-				auto recvIntervalMs =
-				  std::max<uint64_t>(this->lastPacketReceivedAtMs - this->firstPacketReceivedAtMs, 1u);
-
-				return static_cast<uint32_t>(this->totalSize / recvIntervalMs) * 8 * 1000;
-			}
-			void AddPacket(size_t size, int64_t sentAtMs, int64_t receivedAtMs);
-			void Reset();
-
-		private:
-			size_t numPackets{ 0u };
-			size_t totalSize{ 0u };
-			int64_t firstPacketSentAtMs{ 0u };
-			int64_t lastPacketSentAtMs{ 0u };
-			int64_t firstPacketReceivedAtMs{ 0u };
-			int64_t lastPacketReceivedAtMs{ 0u };
-		};
-
-	public:
-		SenderBandwidthEstimator(
-		  RTC::SenderBandwidthEstimator::Listener* listener,
-		  SharedInterface* shared,
-		  uint32_t initialAvailableBitrate);
-		virtual ~SenderBandwidthEstimator();
-
-	public:
-		void TransportConnected();
-		void TransportDisconnected();
-		void RtpPacketSent(const SentInfo& sentInfo);
-		void ReceiveRtcpTransportFeedback(const RTC::RTCP::FeedbackRtpTransportPacket* feedback);
-		void EstimateAvailableBitrate(CummulativeResult& cummulativeResult);
-		void UpdateRtt(float rtt);
-		uint32_t GetAvailableBitrate() const;
-		void RescheduleNextAvailableBitrateEvent();
-
-	private:
-		// Passed by argument.
-		Listener* listener{ nullptr };
-		SharedInterface* shared{ nullptr };
-		// Others.
-		uint32_t initialAvailableBitrate{ 0u };
-		uint32_t availableBitrate{ 0u };
-		uint64_t lastAvailableBitrateEventAtMs{ 0u };
-		std::map<uint16_t, SentInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> sentInfos;
-		float rtt{ 0 }; // Round trip time in ms.
-		CummulativeResult cummulativeResult;
-		CummulativeResult probationCummulativeResult;
-		RTC::RateCalculator sendTransmission;
-		RTC::TrendCalculator sendTransmissionTrend;
-	};
-} // namespace RTC
-
-#endif