mediasoup 3.26.0 → 3.27.0

package/worker/fuzzer/src/RTC/FuzzerDtlsTransport.cpp

@@ -9,10 +9,10 @@
 namespace
 {
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local mocks::MockShared shared(/*getTimeMs*/
-	                                      []()
+	thread_local mocks::MockShared shared(/*getTimeUs*/
+	                                      []() -> int64_t
 	                                      {
-		                                      return 1000;
+		                                      return 1000 * 1000;
 	                                      });
 
 	// DtlsTransport instance. It's reset every time DTLS handshake fails or DTLS
@@ -70,7 +70,7 @@ void FuzzerRtcDtlsTransport::Fuzz(const uint8_t* data, size_t len)
 		dtlsTransportSingleton->SetRemoteFingerprint(dtlsRemoteFingerprint);
 	}
 
-	dtlsTransportSingleton->ProcessDtlsData(data, len);
+	dtlsTransportSingleton->ProcessDtlsData(data, len, shared.GetTimeUs());
 
 	// DTLS may have failed or closed after ProcessDtlsData(). If so, unset it.
 	if (
@@ -125,7 +125,10 @@ void FuzzerRtcDtlsTransport::DtlsTransportListener::OnDtlsTransportSendData(
 }
 
 void FuzzerRtcDtlsTransport::DtlsTransportListener::OnDtlsTransportApplicationDataReceived(
-  const RTC::DtlsTransport* /*dtlsTransport*/, const uint8_t* /*data*/, size_t /*len*/)
+  const RTC::DtlsTransport* /*dtlsTransport*/,
+  const uint8_t* /*data*/,
+  size_t /*len*/,
+  int64_t /*receivedAtUs*/)
 {
 	MS_DEBUG_DEV("DtlsTransport singleton received application data");
 }

package/worker/fuzzer/src/RTC/FuzzerRateCalculator.cpp

@@ -8,7 +8,7 @@ namespace
 {
 	// NOLINTBEGIN(readability-identifier-naming)
 	RTC::RateCalculator rateCalculator;
-	uint64_t nowMs;
+	int64_t nowMs;
 	// NOLINTEND(readability-identifier-naming)
 
 	int init()
@@ -34,9 +34,9 @@ void FuzzerRtcRateCalculator::Fuzz(const uint8_t* data, size_t len)
 		return;
 	}
 
-	auto size = Utils::Crypto::GetRandomUInt<size_t>(0u, static_cast<uint32_t>(RTC::Consts::MtuSize));
+	auto size = Utils::Crypto::GetRandomUInt<size_t>(0, static_cast<uint32_t>(RTC::Consts::MtuSize));
 
-	nowMs += Utils::Crypto::GetRandomUInt<uint64_t>(0u, 1000u);
+	nowMs += static_cast<int64_t>(Utils::Crypto::GetRandomUInt<uint64_t>(0, 1000));
 
 	rateCalculator.Update(size, nowMs);
 

package/worker/fuzzer/src/RTC/FuzzerTrendCalculator.cpp

@@ -6,20 +6,20 @@
 void FuzzerRtcTrendCalculator::Fuzz(const uint8_t* data, size_t len)
 {
 	RTC::TrendCalculator trend;
-	auto nowMs = DepLibUV::GetTimeMs();
-	size_t offset{ 0u };
+	int64_t nowMs = DepLibUV::GetTimeMs();
+	size_t offset{ 0 };
 
-	while (len >= 4u)
+	while (len >= 4)
 	{
 		const auto value = Utils::Byte::Get4Bytes(data, offset);
 
 		trend.Update(value, nowMs);
 		trend.GetValue();
-		trend.Update(value, nowMs - 1000u);
+		trend.Update(value, nowMs - 1000);
 		trend.GetValue();
 
-		len -= 4u;
+		len -= 4;
 		offset += 4;
-		nowMs += 500u;
+		nowMs += 500;
 	}
 }

package/worker/fuzzer/src/RTC/RTCP/FuzzerFeedbackRtpTransport.cpp

@@ -10,11 +10,11 @@ void FuzzerRtcRtcpFeedbackRtpTransport::Fuzz(RTC::RTCP::FeedbackRtpTransportPack
 	packet->GetBaseSequenceNumber();
 	packet->GetPacketStatusCount();
 	packet->GetReferenceTime();
-	packet->GetReferenceTimestamp();
+	packet->GetReferenceTimestampUs();
 	packet->GetFeedbackPacketCount();
 	packet->GetLatestSequenceNumber();
-	packet->GetLatestTimestamp();
-	packet->GetPacketResults();
+	packet->GetLatestTimestampUs();
+	packet->GetPacketStatuses();
 	packet->GetPacketFractionLost();
 	packet->Serialize(RTC::RTCP::SerializationBuffer);
 }

package/worker/fuzzer/src/RTC/RTP/FuzzerPacket.cpp

@@ -91,7 +91,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->HasExtension(3);
 	packet->GetExtensionValue(3, extenLen);
 	packet->ReadAbsSendTime(absSendTime);
-	packet->UpdateAbsSendTime(12345678u);
+	packet->UpdateAbsSendTime(12345678);
 
 	packet->HasExtension(4);
 	packet->GetExtensionValue(4, extenLen);
@@ -150,7 +150,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::Auto, extensions);
 
 	uint8_t value3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
-		                   0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 };
+	                     0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 };
 
 	extensions.emplace_back(
 	  RTC::RtpHeaderExtensionUri::Type::MID, // type

package/worker/fuzzer/src/RTC/RTP/FuzzerRetransmissionBuffer.cpp

@@ -6,8 +6,8 @@
 
 void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 {
-	const uint16_t maxItems{ 2500u };
-	const uint32_t maxRetransmissionDelayMs{ 2000u };
+	const uint16_t maxItems{ 2500 };
+	const int64_t maxRetransmissionDelayMs{ 2000 };
 	const uint32_t clockRate{ 90000 };
 
 	// Trick to initialize our stuff just once (use static).
@@ -25,9 +25,9 @@ void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 
 	// Create base RtpPacket instance.
 	auto* packet = RTC::RTP::Packet::Parse(buffer, 12);
-	size_t offset{ 0u };
+	size_t offset{ 0 };
 
-	while (len >= 4u)
+	while (len >= 4)
 	{
 		const RTC::RTP::SharedPacket sharedPacket;
 
@@ -37,7 +37,7 @@ void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 
 		retransmissionBuffer.Insert(packet, sharedPacket);
 
-		len -= 4u;
+		len -= 4;
 		offset += 4;
 	}
 

package/worker/fuzzer/src/RTC/RTP/FuzzerRtpStreamSend.cpp

@@ -6,10 +6,10 @@
 namespace
 {
 	// NOLINTNEXTLINE(readability-identifier-naming)
-	thread_local mocks::MockShared shared(/*getTimeMs*/
-	                                      []()
+	thread_local mocks::MockShared shared(/*getTimeUs*/
+	                                      []() -> int64_t
 	                                      {
-		                                      return 1000;
+		                                      return 1000 * 1000;
 	                                      });
 } // namespace
 

package/worker/fuzzer/src/fuzzer.cpp

@@ -3,7 +3,9 @@
 #include "common.hpp"
 #include "DepLibSRTP.hpp"
 #include "DepLibUV.hpp"
+#ifndef MS_USE_BUILTIN_BWE
 #include "DepLibWebRTC.hpp"
+#endif
 #include "DepOpenSSL.hpp"
 #include "FuzzerUtils.hpp"
 #include "RTC/DtlsTransport.hpp"
@@ -144,7 +146,9 @@ namespace
 		DepLibUV::ClassInit();
 		DepOpenSSL::ClassInit();
 		DepLibSRTP::ClassInit();
+#ifndef MS_USE_BUILTIN_BWE
 		DepLibWebRTC::ClassInit();
+#endif
 		Utils::Crypto::ClassInit();
 		RTC::DtlsTransport::ClassInit();
 

package/worker/include/Channel/ChannelNotification.hpp

@@ -12,16 +12,16 @@ namespace Channel
 		using Event = FBS::Notification::Event;
 
 	public:
-		explicit ChannelNotification(const FBS::Notification::Notification* notification);
+		ChannelNotification(const FBS::Notification::Notification* notification, int64_t receivedAtUs);
 		~ChannelNotification() = default;
 
 	public:
 		// Passed by argument.
-		Event event;
+		const FBS::Notification::Notification* data{ nullptr };
+		int64_t receivedAtUs{ 0 };
 		// Others.
 		const char* eventCStr;
 		std::string handlerId;
-		const FBS::Notification::Notification* data{ nullptr };
 	};
 } // namespace Channel
 

package/worker/include/Channel/ChannelRequest.hpp

@@ -68,7 +68,7 @@ namespace Channel
 		Channel::ChannelSocket* channel{ nullptr };
 		const FBS::Request::Request* data{ nullptr };
 		// Others.
-		uint32_t id{ 0u };
+		uint32_t id{ 0 };
 		Method method;
 		const char* methodCStr;
 		std::string handlerId;

package/worker/include/Channel/ChannelSocket.hpp

@@ -6,6 +6,10 @@
 #include "Channel/ChannelRequest.hpp"
 #include "handles/UnixStreamSocketHandle.hpp"
 
+// Avoid cyclic #include problem by declaring the class instead of including the
+// corresponding header file.
+class SharedInterface;
+
 namespace Channel
 {
 	class ConsumerSocket : public UnixStreamSocketHandle
@@ -96,6 +100,12 @@ namespace Channel
 	public:
 		void Close();
 		void SetListener(Listener* listener);
+		/**
+		 * @remarks
+		 * - Must be called before the libuv loop runs, since notifications take
+		 *   their arrival time from it.
+		 */
+		void SetShared(SharedInterface* shared);
 		void Send(const uint8_t* data, uint32_t dataLen);
 		void SendLog(const char* data, uint32_t dataLen);
 		bool CallbackRead();
@@ -111,6 +121,7 @@ namespace Channel
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Others.
 		bool closed{ false };
 		ConsumerSocket* consumerSocket{ nullptr };

package/worker/include/DepLibUV.hpp

@@ -20,57 +20,40 @@ public:
 		return DepLibUV::loop;
 	}
 
-	static uint64_t GetTimeMs()
-	{
-		return static_cast<uint64_t>(uv_hrtime() / 1000000u);
-	}
-
 	/**
-	 * Offset between our own monotonic clock and the NTP epoch (ms).
-	 *
-	 * @remarks
-	 * - It is taken just once, in ClassInit(), so that the NTP timestamps we generate
-	 *   never step when the system clock is adjusted. They just drift away from the real
-	 *   wall clock as much as our monotonic clock does.
+	 * Current value of the monotonic clock (ms).
 	 */
-	static uint64_t GetNtpOffsetMs()
+	static int64_t GetTimeMs()
 	{
-		return DepLibUV::ntpOffsetMs;
-	}
-
-	static uint64_t GetTimeUs()
-	{
-		return static_cast<uint64_t>(uv_hrtime() / 1000u);
-	}
-
-	static uint64_t GetTimeNs()
-	{
-		return uv_hrtime();
+		return static_cast<int64_t>(uv_hrtime() / 1000000);
 	}
 
 	/**
-	 * Used within libwebrtc dependency which uses int64_t values for time
-	 * representation.
+	 * Current value of the monotonic clock (us).
 	 */
-	static int64_t GetTimeMsInt64()
+	static int64_t GetTimeUs()
 	{
-		return static_cast<int64_t>(DepLibUV::GetTimeMs());
+		return static_cast<int64_t>(uv_hrtime() / 1000);
 	}
 
 	/**
-	 * Used within libwebrtc dependency which uses int64_t values for time
-	 * representation.
+	 * Offset between our own monotonic clock and the NTP epoch (us).
+	 *
+	 * @remarks
+	 * - It is taken just once, in ClassInit(), so that the NTP timestamps we generate
+	 *   never step when the system clock is adjusted. They just drift away from the real
+	 *   wall clock as much as our monotonic clock does.
 	 */
-	static int64_t GetTimeUsInt64()
+	static int64_t GetNtpOffsetUs()
 	{
-		return static_cast<int64_t>(DepLibUV::GetTimeUs());
+		return DepLibUV::ntpOffsetUs;
 	}
 
 private:
 	static thread_local uv_loop_t* loop;
-	// Distance from our own monotonic clock to the NTP epoch (ms), taken at
+	// Distance from our own monotonic clock to the NTP epoch (us), taken at
 	// ClassInit().
-	static thread_local uint64_t ntpOffsetMs;
+	static thread_local int64_t ntpOffsetUs;
 };
 
 #endif

package/worker/include/RTC/ActiveSpeakerObserver.hpp

@@ -25,8 +25,8 @@ namespace RTC
 		public:
 			void EvalActivityScores();
 			double GetActivityScore(uint8_t interval) const;
-			void LevelChanged(uint32_t level, uint64_t now);
-			void LevelTimedOut(uint64_t now);
+			void LevelChanged(uint32_t level, int64_t nowMs);
+			void LevelTimedOut(int64_t nowMs);
 
 		private:
 			bool ComputeImmediates();
@@ -42,17 +42,17 @@ namespace RTC
 			double immediateActivityScore{ 0 };
 			double mediumActivityScore{ 0 };
 			double longActivityScore{ 0 };
-			uint64_t lastLevelChangeTime{ 0 };
+			int64_t lastLevelChangeAtMs{ 0 };
 
 		private:
-			uint8_t minLevel{ 0u };
-			uint8_t nextMinLevel{ 0u };
-			uint32_t nextMinLevelWindowLen{ 0u };
+			uint8_t minLevel{ 0 };
+			uint8_t nextMinLevel{ 0 };
+			uint32_t nextMinLevelWindowLen{ 0 };
 			std::vector<uint8_t> immediates;
 			std::vector<uint8_t> mediums;
 			std::vector<uint8_t> longs;
 			std::vector<uint8_t> levels;
-			size_t nextLevelIndex{ 0u };
+			size_t nextLevelIndex{ 0 };
 		};
 
 		class ProducerSpeaker
@@ -67,7 +67,7 @@ namespace RTC
 		};
 
 	private:
-		static const uint8_t RelativeSpeachActivitiesLen{ 3u };
+		static const uint8_t RelativeSpeachActivitiesLen{ 3 };
 
 	public:
 		ActiveSpeakerObserver(
@@ -89,7 +89,7 @@ namespace RTC
 		void Resumed() override;
 		void Update();
 		bool CalculateActiveSpeaker();
-		void TimeoutIdleLevels(uint64_t now);
+		void TimeoutIdleLevels(int64_t nowMs);
 
 		/* Pure virtual methods inherited from TimerHandleInterface. */
 	protected:
@@ -99,10 +99,10 @@ namespace RTC
 		double relativeSpeachActivities[RelativeSpeachActivitiesLen]{};
 		std::string dominantId;
 		TimerHandleInterface* periodicTimer{ nullptr };
-		uint16_t interval{ 300u };
+		int64_t intervalMs{ 300 };
 		// Map of ProducerSpeakers indexed by Producer id.
 		ankerl::unordered_dense::map<std::string, ProducerSpeaker*> mapProducerSpeakers;
-		uint64_t lastLevelIdleTime{ 0u };
+		int64_t lastLevelIdleAtMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/AudioLevelObserver.hpp

@@ -13,8 +13,8 @@ namespace RTC
 	private:
 		struct DBovs
 		{
-			uint16_t totalSum{ 0u }; // Sum of dBvos (positive integer).
-			size_t count{ 0u };      // Number of dBvos entries in totalSum.
+			uint16_t totalSum{ 0 }; // Sum of dBvos (positive integer).
+			size_t count{ 0 };      // Number of dBvos entries in totalSum.
 		};
 
 	public:
@@ -44,9 +44,9 @@ namespace RTC
 
 	private:
 		// Passed by argument.
-		uint16_t maxEntries{ 1u };
+		uint16_t maxEntries{ 1 };
 		int8_t threshold{ -80 };
-		uint16_t interval{ 1000u };
+		int64_t intervalMs{ 1000 };
 		// Allocated by this.
 		TimerHandleInterface* periodicTimer{ nullptr };
 		// Others.

package/worker/include/RTC/BWE/AcknowledgedBitrateEstimatorInterface.hpp

@@ -0,0 +1,55 @@
+#ifndef MS_RTC_BWE_ACKNOWLEDGED_BITRATE_ESTIMATOR_INTERFACE_HPP
+#define MS_RTC_BWE_ACKNOWLEDGED_BITRATE_ESTIMATOR_INTERFACE_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Measures the bitrate the receiver is acknowledging, which is what the rate
+		 * control compares its target against.
+		 */
+		class AcknowledgedBitrateEstimatorInterface
+		{
+		public:
+			AcknowledgedBitrateEstimatorInterface() = default;
+
+			AcknowledgedBitrateEstimatorInterface& operator=(
+			  const AcknowledgedBitrateEstimatorInterface&) = delete;
+
+			AcknowledgedBitrateEstimatorInterface(const AcknowledgedBitrateEstimatorInterface&) = delete;
+
+			virtual ~AcknowledgedBitrateEstimatorInterface() = default;
+
+		public:
+			/**
+			 * Feed the packets a feedback reported as received.
+			 *
+			 * @param packetResults - The reported packets, ordered by arrival time.
+			 */
+			virtual void IncomingPacketFeedbackVector(
+			  const std::vector<Types::PacketResult>& packetResults) = 0;
+
+			/**
+			 * Acknowledged bitrate (bps), or no value if it cannot be measured yet.
+			 */
+			virtual std::optional<int64_t> GetBitrate() const = 0;
+
+			/**
+			 * @param inAlr - Whether the sender is in an application limited region.
+			 */
+			virtual void SetAlr(bool inAlr) = 0;
+
+			/**
+			 * @param alrEndedTimeUs - Time at which the sender stopped being in an
+			 *   application limited region.
+			 */
+			virtual void SetAlrEndedTimeUs(int64_t alrEndedTimeUs) = 0;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

package/worker/include/RTC/BWE/AimdRateControl.hpp

@@ -0,0 +1,190 @@
+#ifndef MS_RTC_BWE_AIMD_RATE_CONTROL_HPP
+#define MS_RTC_BWE_AIMD_RATE_CONTROL_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include "RTC/BWE/LinkCapacityEstimator.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Decides the target bitrate out of what the delay based detector says about
+		 * the network.
+		 *
+		 * While no overuse is detected the bitrate is increased, multiplicatively
+		 * when the capacity of the link is still unknown and additively once it has
+		 * been estimated, since being close to the capacity makes a big step
+		 * expensive. On overuse it is decreased to slightly below the measured
+		 * throughput and held there until the queues of the network drain.
+		 */
+		class AimdRateControl
+		{
+		public:
+			struct AimdRateControlOptions
+			{
+				/**
+				 * Fraction of the measured throughput the bitrate is dropped to when
+				 * overuse is detected.
+				 */
+				double backoffFactor{ 0.85 };
+				/**
+				 * Whether the bitrate is not allowed to increase while the sender is in
+				 * an application limited region. In that region the network gives no
+				 * feedback about whether a higher bitrate would have worked, so an
+				 * increase cannot be validated.
+				 */
+				bool noBitrateIncreaseInAlr{ false };
+				/**
+				 * Whether the estimate of the link capacity is used as an upper bound.
+				 */
+				bool estimateBoundedIncrease{ true };
+				/**
+				 * Whether the current bitrate is taken as the lowest possible upper
+				 * bound, so that an estimate of the link capacity below it does not
+				 * drag the bitrate down.
+				 */
+				bool useCurrentEstimateAsMinUpperBound{ true };
+				/**
+				 * Whether this rate control runs in the endpoint that sends the media
+				 * whose capacity is being estimated, rather than in the one that
+				 * receives it. Only the sender can know that it's in an application
+				 * limited region, so `noBitrateIncreaseInAlr` has no effect otherwise.
+				 */
+				bool sendSide{ false };
+			};
+
+		private:
+			enum class RateControlState : uint8_t
+			{
+				HOLD,
+				INCREASE,
+				DECREASE
+			};
+
+		public:
+			AimdRateControl();
+
+			explicit AimdRateControl(AimdRateControlOptions options);
+
+			/**
+			 * Whether the target bitrate has been initialized, which happens either
+			 * when it's explicitly set or once a throughput has been measured for long
+			 * enough.
+			 */
+			bool IsValidEstimate() const
+			{
+				return this->bitrateIsInitialized;
+			}
+
+			/**
+			 * Current target bitrate (bps).
+			 */
+			int64_t GetLatestEstimate() const
+			{
+				return this->currentBitrate;
+			}
+
+			/**
+			 * Feed what the delay based detector says about the network.
+			 *
+			 * @param input - State of the network plus the acknowledged bitrate.
+			 * @param atTimeUs - Time at which the input was produced.
+			 *
+			 * @returns The new target bitrate (bps).
+			 */
+			int64_t Update(const Types::RateControlInput& input, int64_t atTimeUs);
+
+			/**
+			 * Set the target bitrate from outside the rate control, for instance out of
+			 * the bitrate measured by a probe.
+			 *
+			 * @param bitrate - New target bitrate (bps).
+			 */
+			void SetEstimate(int64_t bitrate, int64_t atTimeUs);
+
+			/**
+			 * @param startBitrate - Bitrate to start from (bps).
+			 */
+			void SetStartBitrate(int64_t startBitrate);
+
+			/**
+			 * @param minBitrate - Bitrate the target is never taken below (bps).
+			 */
+			void SetMinBitrate(int64_t minBitrate);
+
+			void SetRttUs(int64_t rttUs);
+
+			void SetInApplicationLimitedRegion(bool inAlr);
+
+			void SetNetworkStateEstimate(const std::optional<Types::NetworkStateEstimate>& estimate);
+
+			/**
+			 * Whether the bitrate can be reduced again, which requires that it has not
+			 * been changed for more than an RTT or that the throughput has fallen well
+			 * below the current target. It's what keeps a single overuse from
+			 * collapsing the bitrate in a few milliseconds.
+			 */
+			bool IsTimeToReduceFurther(int64_t atTimeUs, int64_t estimatedThroughput) const;
+
+			/**
+			 * As above, to be used when overusing before any throughput has been
+			 * measured.
+			 */
+			bool IsInitialTimeToReduceFurther(int64_t atTimeUs) const;
+
+			/**
+			 * Rate at which the bitrate is increased once it's close to the capacity of
+			 * the link (bps per second).
+			 */
+			double GetNearMaxIncreaseRateBpsPerSecond() const;
+
+			/**
+			 * How often feedback can be sent while devoting no more than 5% of the
+			 * current bitrate to it.
+			 */
+			int64_t GetFeedbackIntervalUs() const;
+
+		private:
+			void ChangeBitrate(const Types::RateControlInput& input, int64_t atTimeUs);
+
+			void ChangeState(const Types::RateControlInput& input, int64_t atTimeUs);
+
+			/**
+			 * Apply the configured bounds to a candidate bitrate.
+			 */
+			int64_t ClampBitrate(int64_t newBitrate) const;
+
+			/**
+			 * Increase used while the capacity of the link is unknown, which ramps up
+			 * fast to discover it.
+			 */
+			int64_t MultiplicativeRateIncrease(
+			  int64_t atTimeUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const;
+
+			/**
+			 * Increase used once the capacity of the link has been estimated, which
+			 * approaches it in small steps.
+			 */
+			int64_t AdditiveRateIncrease(int64_t atTimeUs, int64_t lastTimeUs) const;
+
+		private:
+			const AimdRateControlOptions options;
+			int64_t minConfiguredBitrate;
+			int64_t maxConfiguredBitrate;
+			int64_t currentBitrate;
+			int64_t latestEstimatedThroughput;
+			LinkCapacityEstimator linkCapacity;
+			std::optional<Types::NetworkStateEstimate> networkEstimate;
+			RateControlState rateControlState{ RateControlState::HOLD };
+			std::optional<int64_t> timeLastBitrateChangeUs;
+			std::optional<int64_t> timeFirstThroughputEstimateUs;
+			bool bitrateIsInitialized{ false };
+			bool inAlr{ false };
+			int64_t rttUs;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif