mediasoup 3.27.0 → 3.28.0

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

@@ -2,6 +2,7 @@
 #define MS_RTC_BWE_SEND_PACKET_HISTORY_HPP
 
 #include "common.hpp"
+#include "Utils/UnwrappedSequenceNumber.hpp"
 #include "RTC/BWE/BweTypes.hpp"
 #include <map>
 #include <tuple>
@@ -37,14 +38,113 @@ namespace RTC
 				int64_t windowDurationUs{ 60 * 1000 * 1000 };
 			};
 
-		private:
+			/**
+			 * Everything about a packet that this history has to be told, since none
+			 * of it can be read back from the bytes that go on the wire.
+			 */
+			struct AddPacketOptions
+			{
+				uint32_t ssrc{ 0 };
+				/**
+				 * RTP sequence number of the packet, which is what a feedback that
+				 * doesn't carry the one above identifies it by.
+				 */
+				uint16_t seq{ 0 };
+				/**
+				 * Size of the packet including the overhead up to the IP layer (bytes).
+				 *
+				 * @remarks
+				 * - What the link has to carry is what the estimation is about, so the
+				 *   length of the packet on its own falls short. The overhead of the
+				 *   path it takes is what `RTC::TransportTuple::GetPacketOverhead()`
+				 *   answers.
+				 */
+				size_t size{ 0 };
+				/**
+				 * Whether it's an audio packet. False for video, padding and RTX.
+				 */
+				bool isAudio{ false };
+				bool isRetransmission{ false };
+				/**
+				 * SSRC of the packet a retransmission carries, which is the SSRC above
+				 * itself when it goes without RTX. No value when the packet isn't a
+				 * retransmission.
+				 */
+				std::optional<uint32_t> originalSsrc;
+				/**
+				 * Whether the packet is marked as ECT(1), which asks the network to
+				 * report congestion instead of dropping the packet.
+				 *
+				 * @see https://www.rfc-editor.org/rfc/rfc9331.html
+				 */
+				bool sentWithEct1{ false };
+				/**
+				 * The burst the packet belongs to, or no value if it isn't part of one.
+				 */
+				std::optional<Types::ProbeCluster> probeCluster;
+				/**
+				 * Time at which the packet is taken note of, which is not yet the time
+				 * at which it was sent.
+				 */
+				int64_t createdAtUs{ 0 };
+			};
+
+			/**
+			 * A packet as this history holds it, which is what it was sent with plus
+			 * what identifies it on the wire.
+			 */
 			struct SentPacketEntry
 			{
 				Types::SentPacket sentPacket;
+				/**
+				 * Time at which the packet was taken note of, which is what makes it
+				 * fall out of the window. It comes before the packet was sent, and by
+				 * an unbounded amount when the socket cannot take the datagram right
+				 * away.
+				 */
+				int64_t createdAtUs{ 0 };
 				uint32_t ssrc{ 0 };
 				uint16_t seq{ 0 };
+				bool isRetransmission{ false };
+				/**
+				 * Whether what a feedback reports as the arrival time of this packet
+				 * cannot be told from that of another one, which happens when the very
+				 * same SSRC and RTP sequence number were sent more than once.
+				 *
+				 * @remark
+				 * - Nothing in this estimator reads it. It is only of use to SCReAM,
+				 *   another way of estimating the bandwidth, which discards the delay
+				 *   of a packet it cannot tell apart.
+				 *
+				 * @link https://datatracker.ietf.org/doc/draft-johansson-ccwg-rfc8298bis-screamv2
+				 */
+				bool ambiguousReceiveTime{ false };
+				/**
+				 * Whether the packet was sent marked as ECT(1), which asks the network
+				 * to report congestion instead of dropping the packet.
+				 *
+				 * @remark
+				 * - Only a feedback that reports ECN carries it back, which is the one
+				 *   of RFC 8888 and not the transport-cc one.
+				 *
+				 * @see https://datatracker.ietf.org/doc/html/rfc8888
+				 * @see https://www.rfc-editor.org/rfc/rfc9331.html
+				 */
+				bool sentWithEct1{ false };
+				/**
+				 * Whether a feedback already reported this packet as lost, which is
+				 * what tells a first loss from the same loss reported again.
+				 *
+				 * @remark
+				 * - Only a feedback that reports on a whole range of packets makes use
+				 *   of it, which is the one of RFC 8888 and not the transport-cc one.
+				 *
+				 * @see https://datatracker.ietf.org/doc/html/rfc8888
+				 */
+				bool previouslyReportedLost{ false };
 			};
 
+		private:
 			struct SsrcAndSeq
 			{
 				bool operator<(const SsrcAndSeq& other) const
@@ -62,23 +162,58 @@ namespace RTC
 			explicit SendPacketHistory(SendPacketHistoryOptions options);
 
 			/**
-			 * Take note of a packet that has just been sent.
+			 * Take note of a packet that is about to be sent.
+			 *
+			 * @returns The sequence number given to the packet, whose lowest 16 bits
+			 *   are what has to go into the transport-wide sequence number RTP header
+			 *   extension, and which is what a feedback resolves into.
+			 */
+			int64_t AddPacket(const AddPacketOptions& options);
+
+			/**
+			 * Recover the sequence number this history gave a packet out of the
+			 * lowest 16 bits of it that the wire carries.
+			 *
+			 * @remarks
+			 * - Each number is resolved against the previous one resolved, be it of a
+			 *   packet taken note of or of another feedback, which is what carries the
+			 *   count across a turn of the wire's 16 bits. So one further than half
+			 *   that range away from the previous cannot be told apart from the same
+			 *   number a turn later.
+			 */
+			int64_t UnwrapSequenceNumber(uint16_t wrappedSequenceNumber);
+
+			/**
+			 * Take note that the packet with the given sequence number has left.
 			 *
-			 * @param size - Size of the packet including overhead up to the IP layer
-			 *   (bytes).
-			 * @param audio - Whether it's an audio packet. False for video, padding
-			 *   and RTX.
-			 * @returns The sequence number given to the packet, which is what a
-			 *   feedback has to be resolved into.
+			 * @returns The packet as it was sent, or no value if this history doesn't
+			 *   hold it anymore or it had already left.
+			 *
+			 * @remarks
+			 * - This is what makes the packet count as in flight, and what settles how
+			 *   many bytes were in flight when it left.
+			 * - A packet sent under a sequence number that already left is not taken
+			 *   note of twice, so that its bytes are not counted twice either.
+			 */
+			std::optional<Types::SentPacket> ProcessSentPacket(int64_t sequenceNumber, int64_t sentAtUs);
+
+			/**
+			 * Take note of bytes that left without being tracked one by one, which is
+			 * what packets carrying no sequence number of this history amount to.
+			 *
+			 * @remarks
+			 * - They are held until the next tracked packet leaves and are attributed
+			 *   to it, so that whoever measures the acknowledged bitrate doesn't
+			 *   believe the link carried less than it did.
 			 */
-			int64_t AddPacket(uint32_t ssrc, uint16_t seq, size_t size, bool audio, int64_t sentAtUs);
+			void ProcessSentUntrackedPacket(size_t size, int64_t sentAtUs);
 
 			/**
 			 * Resolve what a feedback reported about a single packet.
 			 *
 			 * @param received - Whether the feedback reported the packet as received.
-			 * @returns The packet as it was sent, or no value if this history doesn't
-			 *   hold it anymore.
+			 * @returns The packet as this history holds it, or no value if it doesn't
+			 *   hold it anymore or it was never reported as sent.
 			 *
 			 * @remarks
 			 * - Every packet up to the given one stops counting as in flight, since
@@ -86,24 +221,13 @@ namespace RTC
 			 * - A packet reported as received is dropped, while one reported as lost
 			 *   is kept, since a later feedback may still report it as received.
 			 */
-			std::optional<Types::SentPacket> RetrievePacket(int64_t sequenceNumber, bool received);
+			std::optional<SentPacketEntry> RetrievePacket(int64_t sequenceNumber, bool received);
 
 			/**
 			 * Same, for a feedback that identifies the packet by its SSRC and RTP
 			 * sequence number rather than by the sequence number given to it.
 			 */
-			std::optional<Types::SentPacket> RetrievePacket(uint32_t ssrc, uint16_t seq, bool received);
-
-			/**
-			 * Sequence number this history gave to the latest packet added, or no
-			 * value if no packet was ever added.
-			 *
-			 * @remarks
-			 * - It's the sequence number of this history, not the RTP one, so it
-			 *   never wraps around. It's also the highest a feedback carrying only
-			 *   the lowest bits of it can possibly stand for.
-			 */
-			std::optional<int64_t> GetLastSequenceNumber() const;
+			std::optional<SentPacketEntry> RetrievePacket(uint32_t ssrc, uint16_t seq, bool received);
 
 			/**
 			 * Bytes that were sent and no feedback has reported on yet.
@@ -126,10 +250,22 @@ namespace RTC
 			const SendPacketHistoryOptions options;
 			std::map<int64_t, SentPacketEntry> history;
 			std::map<SsrcAndSeq, int64_t> ssrcAndSeqToSequenceNumber;
-			int64_t nextSequenceNumber{ 0 };
+			// Hands out the sequence numbers and recovers them out of the lowest bits
+			// the wire carries, which keeps both to a single count.
+			Utils::UnwrappedSequenceNumber<uint16_t>::Unwrapper sequenceNumberUnwrapper;
+			uint16_t nextWrappedSequenceNumber{ 0 };
+			// Highest sequence number ever taken note of, or no value if none was.
+			std::optional<int64_t> highestSequenceNumber;
 			// Sequence numbers are never negative, so this sits below all of them.
 			int64_t lastAckSequenceNumber{ -1 };
 			size_t outstandingBytes{ 0 };
+			// Bytes that left untracked and no packet has been attributed yet.
+			size_t pendingUntrackedBytes{ 0 };
+			// Time at which the latest tracked packet left, or no value if none has.
+			std::optional<int64_t> lastSendTimeUs;
+			// Time at which the latest untracked bytes left, or no value if none
+			// have.
+			std::optional<int64_t> lastUntrackedSendTimeUs;
 		};
 	} // namespace BWE
 } // namespace RTC

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

@@ -0,0 +1,306 @@
+#ifndef MS_RTC_BWE_TARGET_RATE_CONTROLLER_HPP
+#define MS_RTC_BWE_TARGET_RATE_CONTROLLER_HPP
+
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include "RTC/BWE/LossBasedController.hpp"
+#include <deque>
+#include <vector>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Holds the target bitrate and every bound that applies to it.
+		 *
+		 * The delay based path, the receiver of the media and the application each
+		 * produce a limit rather than a bitrate, so something has to hold the value
+		 * they bound and decide how it moves within them. That is this class, and it
+		 * also owns the two inputs that move the target down on their own: a round
+		 * trip time long enough to mean that the queues of the network are full, and
+		 * the loss the receiver reports.
+		 *
+		 * How loss moves the target depends on how much is known about it. Until the
+		 * loss controller has seen enough feedback to tell congestion from the loss a
+		 * link has by itself, this class applies rules of its own on the fraction of
+		 * packets reported as lost: increase while it stays under 2%, leave the target
+		 * alone up to 10%, and decrease it above that. They are coarse on purpose, and
+		 * their weakness is precisely what they cannot tell apart, so on a link with
+		 * steady loss above 2% they hold the target still and above 10% they drive it
+		 * to the minimum. As soon as the loss controller is ready, its estimate
+		 * replaces them.
+		 *
+		 * @remarks
+		 * - This class is a port of the SendSideBandwidthEstimation class in
+		 *   libwebrtc (renamed to a better name).
+		 */
+		class TargetRateController
+		{
+		public:
+			struct TargetRateControllerOptions
+			{
+				/**
+				 * Reported loss under which the bitrate is increased.
+				 */
+				double lowLossThreshold{ 0.02 };
+				/**
+				 * Reported loss over which the bitrate is decreased.
+				 */
+				double highLossThreshold{ 0.1 };
+				/**
+				 * Bitrate under which loss is ignored altogether, since at a low enough
+				 * bitrate loss is unlikely to be caused by the traffic itself.
+				 */
+				int64_t bitrateThreshold{ 0 };
+				/**
+				 * Whether the bound asked for by the receiver takes part in how the
+				 * target moves, rather than only capping the value this controller
+				 * hands out.
+				 */
+				bool disableReceiverLimitCapsOnly{ false };
+				/**
+				 * Round trip time over which the bitrate is dropped regardless of loss.
+				 * A round trip time this long means the queues of the network are full.
+				 */
+				int64_t maxRttUs{ 3 * 1000 * 1000 };
+				/**
+				 * Fraction of the target the bitrate is dropped to on each of those
+				 * drops.
+				 */
+				double rttBackoffDropFraction{ 0.8 };
+				/**
+				 * How often the bitrate may be dropped due to the round trip time.
+				 */
+				int64_t rttBackoffDropIntervalUs{ 1000 * 1000 };
+				/**
+				 * Bitrate the round trip time backoff never drops below.
+				 */
+				int64_t rttBackoffBitrateFloor{ 5000 };
+			};
+
+		private:
+			/**
+			 * Drops the bitrate when the round trip time stays long enough to mean
+			 * that the queues of the network are full, which is a congestion signal
+			 * that loss and delay may both miss.
+			 */
+			struct RttBackoff
+			{
+				/**
+				 * Round trip time corrected for the sender being idle. Without the
+				 * correction a sender that stops transmitting would keep reporting the
+				 * last measured value forever.
+				 */
+				int64_t GetCorrectedRttUs() const
+				{
+					int64_t timeoutCorrectionUs{ 0 };
+
+					// While either instant is missing there is nothing to correct: no
+					// feedback has arrived, or nothing that gets feedback has been sent.
+					if (this->lastPacketSentAtUs.has_value() && this->lastPropagationRttAtUs.has_value())
+					{
+						timeoutCorrectionUs = std::max<int64_t>(
+						  this->lastPacketSentAtUs.value() - this->lastPropagationRttAtUs.value(), 0);
+					}
+
+					return timeoutCorrectionUs + this->lastPropagationRttUs;
+				}
+
+				std::optional<int64_t> lastPropagationRttAtUs;
+				std::optional<int64_t> lastPacketSentAtUs;
+				int64_t lastPropagationRttUs{ 0 };
+			};
+
+		public:
+			TargetRateController();
+
+			explicit TargetRateController(TargetRateControllerOptions options);
+
+			/**
+			 * Bitrate this controller may produce, already within every bound.
+			 */
+			int64_t GetTargetBitrate() const;
+
+			/**
+			 * Latest fraction of lost packets reported by the receiver, in 1/256 units.
+			 */
+			uint8_t GetFractionLost() const
+			{
+				return this->lastFractionLost;
+			}
+
+			int64_t GetRttUs() const
+			{
+				return this->lastRttUs;
+			}
+
+			/**
+			 * Whether the round trip time is long enough to be taken as congestion on
+			 * its own.
+			 */
+			bool IsRttAboveLimit() const
+			{
+				return this->rttBackoff.GetCorrectedRttUs() > this->options.maxRttUs;
+			}
+
+			/**
+			 * Forget everything learnt about the network, which is what a transport
+			 * that is not going through the same path anymore calls for.
+			 *
+			 * @remarks
+			 * - The bounds set by the application are dropped too, so they have to be
+			 *   set again afterwards.
+			 */
+			void OnRouteChange();
+
+			/**
+			 * Bounds set by the application.
+			 *
+			 * @remarks
+			 * - A max bitrate of zero means no limit.
+			 */
+			void SetBitrateLimits(int64_t minBitrate, int64_t maxBitrate);
+
+			/**
+			 * Place the target at the given bitrate, dropping the bound that could
+			 * hold it back and the history that limits how fast it grows.
+			 */
+			void SetSendBitrate(int64_t bitrate);
+
+			/**
+			 * Upper bound produced by the delay based path.
+			 */
+			void SetDelayBasedEstimate(int64_t bitrate);
+
+			/**
+			 * Upper bound asked for by the receiver of the media, which reaches us as
+			 * a REMB message.
+			 *
+			 * @remarks
+			 * - A bitrate of zero means no limit.
+			 */
+			void SetReceiverEstimate(int64_t bitrate);
+
+			/**
+			 * Feed a loss report of the receiver.
+			 *
+			 * @remarks
+			 * - Reports are accumulated until they cover enough packets, so most calls
+			 *   change nothing.
+			 */
+			void UpdatePacketsLost(int64_t lostPackets, int64_t totalPackets, int64_t nowUs);
+
+			void UpdateRtt(int64_t rttUs);
+
+			/**
+			 * Feed the round trip time the round trip time backoff watches, which is
+			 * the one measured by the transport feedback rather than by RTCP.
+			 */
+			void UpdatePropagationRtt(int64_t propagationRttUs, int64_t nowUs);
+
+			/**
+			 * Tell that a packet that will be reported back has just been sent.
+			 */
+			void OnPacketSent(int64_t sentAtUs);
+
+			/**
+			 * Reconsider the target. Called after every loss report and periodically,
+			 * since the increase depends on how much time has elapsed.
+			 */
+			void Update(int64_t nowUs);
+
+			/**
+			 * Bitrate the network is known to be delivering.
+			 */
+			void SetAcknowledgedBitrate(int64_t acknowledgedBitrate);
+
+			/**
+			 * Feed the results of a feedback message to the loss controller, which is
+			 * the only thing in here that looks at packets one by one.
+			 *
+			 * @param inAlr - Whether the sender is not sending enough to fill the link.
+			 */
+			void UpdateLossBasedController(
+			  const std::vector<Types::PacketResult>& packetResults, bool inAlr, int64_t nowUs);
+
+			/**
+			 * What the loss controller is doing with the target, which tells whether
+			 * probing makes sense.
+			 */
+			LossBasedController::State GetLossBasedState() const
+			{
+				return this->lossBasedState;
+			}
+
+		private:
+			/**
+			 * Whether the target is still allowed to just follow the bounds because
+			 * not enough is known about the network yet.
+			 */
+			bool IsInStartPhase(int64_t nowUs) const;
+
+			/**
+			 * Lowest bitrate the target has had during the last second, which is what
+			 * the increase grows from.
+			 */
+			void UpdateMinBitrateHistory(int64_t nowUs);
+
+			/**
+			 * Upper bound of every kind that applies to the target.
+			 */
+			int64_t GetUpperLimit() const;
+
+			/**
+			 * Set the target to the given bitrate, keeping it within its bounds.
+			 */
+			void SetTargetBitrate(int64_t bitrate);
+
+			/**
+			 * Reapply the bounds to the current target, which is needed when one of
+			 * them changes.
+			 */
+			void ApplyTargetLimits();
+
+		private:
+			// Passed by argument.
+			const TargetRateControllerOptions options;
+			// Others.
+			// Tells congestion from the loss the link has by itself, and takes over
+			// the target as soon as it has enough observations.
+			LossBasedController lossBasedController;
+			LossBasedController::State lossBasedState{ LossBasedController::State::DELAY_BASED_ESTIMATE };
+			struct RttBackoff rttBackoff;
+			// Lowest target of the last second, as a sliding window minimum of
+			// (instant in us, bitrate in bps) pairs.
+			std::deque<std::pair<int64_t, int64_t>> minBitrateHistory;
+			// Loss reports too small to tell anything on their own, accumulated until
+			// they cover enough packets.
+			int64_t lostPacketsSinceLastLossUpdate{ 0 };
+			int64_t expectedPacketsSinceLastLossUpdate{ 0 };
+			int64_t currentTarget{ 0 };
+			int64_t minBitrateConfigured{ 0 };
+			int64_t maxBitrateConfigured{ 0 };
+			// Instant of the first loss report ever received, which is when the start
+			// phase begins.
+			std::optional<int64_t> firstLossReportAtUs;
+			// Instant of the latest loss report that covered enough packets to tell
+			// something.
+			std::optional<int64_t> lastLossReportAtUs;
+			// Instant at which the target was last decreased, by the loss rules or by
+			// the round trip time backoff.
+			std::optional<int64_t> lastDecreaseAtUs;
+			// Whether the target has already been decreased for the loss currently
+			// reported, so that a same report doesn't decrease it twice.
+			bool hasDecreasedSinceLastFractionLoss{ false };
+			uint8_t lastFractionLost{ 0 };
+			int64_t lastRttUs{ 0 };
+			// Upper bound asked for by the receiver of the media.
+			int64_t receiverLimit{ Types::BitrateInfinite };
+			// Upper bound produced by the delay based path.
+			int64_t delayBasedLimit{ Types::BitrateInfinite };
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif

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

@@ -0,0 +1,146 @@
+#ifndef MS_RTC_BWE_TRANSPORT_WIDE_CC_FEEDBACK_GENERATOR_HPP
+#define MS_RTC_BWE_TRANSPORT_WIDE_CC_FEEDBACK_GENERATOR_HPP
+
+#include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
+#include "RTC/RTCP/FeedbackRtpTransport.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "RTC/RateCalculator.hpp"
+#include "RTC/SeqManager.hpp"
+#include "SharedInterface.hpp"
+#include <map>
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/**
+		 * Tells the remote sender when each of its packets arrived, which is what
+		 * lets that sender estimate the link towards us.
+		 *
+		 * Nothing is estimated here. The arrival time of every packet carrying the
+		 * transport wide sequence number is kept, and a feedback packet with as many
+		 * of them as fit is emitted periodically. Turning those arrival times into a
+		 * bitrate is the remote sender's job.
+		 *
+		 * How often the feedback is emitted follows the bitrate coming in, so that
+		 * what reporting costs stays a small share of what is being reported on.
+		 */
+		class TransportWideCcFeedbackGenerator : public TimerHandleInterface::Listener
+		{
+		public:
+			class Listener
+			{
+			public:
+				virtual ~Listener() = default;
+
+			public:
+				/**
+				 * A feedback packet is ready for the remote sender.
+				 *
+				 * @param packet - Packet to send, only valid for the duration of this
+				 *   call.
+				 */
+				virtual void OnTransportWideCcFeedbackGeneratorSendRtcpPacket(
+				  TransportWideCcFeedbackGenerator* transportWideCcFeedbackGenerator,
+				  RTC::RTCP::FeedbackRtpTransportPacket* packet) = 0;
+			};
+
+		public:
+			TransportWideCcFeedbackGenerator(
+			  Listener* listener, SharedInterface* shared, size_t maxRtcpPacketLen);
+			~TransportWideCcFeedbackGenerator() override = default;
+
+			TransportWideCcFeedbackGenerator(const TransportWideCcFeedbackGenerator&)            = delete;
+			TransportWideCcFeedbackGenerator& operator=(const TransportWideCcFeedbackGenerator&) = delete;
+
+			/**
+			 * Feed a received RTP packet, which is ignored unless it carries the
+			 * transport wide sequence number extension.
+			 *
+			 * @param arrivalTimeUs - Instant the packet arrived.
+			 */
+			void IncomingPacket(int64_t arrivalTimeUs, const RTC::RTP::Packet* packet);
+
+#ifdef MS_TEST
+		public:
+#else
+		private:
+#endif
+			/**
+			 * Report everything received since the last time, in as many feedback
+			 * packets as it takes.
+			 */
+			void FillAndSendFeedback();
+
+			/**
+			 * How often feedback should be emitted (ms) to report on the given
+			 * incoming bitrate (bps) without taking more than a small share of it.
+			 */
+			static int64_t ComputeSendIntervalMs(int64_t incomingBitrate);
+
+			/**
+			 * How often feedback is being emitted right now (ms).
+			 */
+			int64_t GetSendIntervalMs() const
+			{
+				return this->sendIntervalMs;
+			}
+
+		private:
+			/**
+			 * Hand the feedback packet being filled to the listener.
+			 *
+			 * @returns Whether it was handed over, which does not happen when it holds
+			 *   nothing that can be put on the wire.
+			 */
+			bool SendFeedback();
+
+			/**
+			 * Forget the arrival times too old to be reported, keeping the one the
+			 * next feedback starts at.
+			 */
+			void MayDropOldPacketArrivalTimes(uint16_t seqNum, int64_t arrivalTimeUs);
+
+			/**
+			 * Start a new feedback packet, carrying on the given count.
+			 */
+			void ResetFeedbackPacket(uint8_t feedbackPacketCount);
+
+			/**
+			 * Work out how often feedback should be emitted out of the bitrate coming
+			 * in, and reprogram the timer if the answer changed.
+			 */
+			void MayUpdateSendInterval(int64_t nowMs);
+
+			/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
+		public:
+			void OnTimer(TimerHandleInterface* timer) override;
+
+		private:
+			// Largest an RTCP packet may be on this transport (bytes).
+			const size_t maxRtcpPacketLen;
+
+			// Passed by argument.
+			Listener* listener{ nullptr };
+			SharedInterface* shared{ nullptr };
+			// Allocated by this.
+			const std::unique_ptr<TimerHandleInterface> sendPeriodicTimer;
+			std::unique_ptr<RTC::RTCP::FeedbackRtpTransportPacket> feedbackPacket;
+			// Bitrate coming in, which is what decides how often feedback is emitted.
+			RTC::RtpDataCounter incomingDataCounter;
+			// How often feedback is emitted (ms).
+			int64_t sendIntervalMs;
+			uint8_t feedbackPacketCount{ 0 };
+			uint32_t feedbackMediaSsrc{ 0 };
+			// Sequence number the next feedback starts reporting at, or no value
+			// until the first packet is seen.
+			std::optional<uint16_t> feedbackWideSeqNumStart;
+			// Instant each packet arrived (us), indexed by its transport wide
+			// sequence number.
+			std::map<uint16_t, int64_t, RTC::SeqManager<uint16_t>::SeqLowerThan> mapPacketArrivalTimes;
+		};
+	} // namespace BWE
+} // namespace RTC
+
+#endif