mediasoup 3.26.0 → 3.27.0

package/worker/include/RTC/Serializable.hpp

@@ -218,7 +218,7 @@ namespace RTC
 		// take.
 		size_t bufferLength;
 		// Serializable current exact length (includes padding bytes).
-		size_t length{ 0u };
+		size_t length{ 0 };
 		// Event listener invoked when the current buffer is released (no longer
 		// used by this Serializable)-
 		BufferReleasedListener* bufferReleasedListener{ nullptr };

package/worker/include/RTC/SimpleProducerStreamManager.hpp

@@ -42,10 +42,9 @@ namespace RTC
 		void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
-		uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
-		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
-		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		int64_t IncreaseLayer(int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) override;
+		void ApplyLayers(int64_t rtpStreamActiveMs) override;
+		int64_t GetDesiredBitrate(int64_t nowMs) const override;
 		RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,
 		  bool lastSentPacketHasMarker,

package/worker/include/RTC/SimulcastProducerStreamManager.hpp

@@ -48,10 +48,9 @@ namespace RTC
 		void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
-		uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
-		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
-		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		int64_t IncreaseLayer(int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) override;
+		void ApplyLayers(int64_t rtpStreamActiveMs) override;
+		int64_t GetDesiredBitrate(int64_t nowMs) const override;
 		RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,
 		  bool lastSentPacketHasMarker,
@@ -83,13 +82,13 @@ namespace RTC
 		// Spatial layer that was the RTP timestamp reference the last time its capture
 		// instant was known upon a received Sender Report.
 		int16_t tsReferenceSpatialLayerWithCaptureMapping{ -1 };
-		uint32_t tsOffset{ 0u };
+		uint32_t tsOffset{ 0 };
 		bool keyFrameForTsOffsetRequested{ false };
 		// Old-packet filtering after spatial switch.
-		uint16_t snReferenceSpatialLayer{ 0u };
+		uint16_t snReferenceSpatialLayer{ 0 };
 		bool checkingForOldPacketsInSpatialLayer{ false };
 		// BWE downgrade tracking.
-		uint64_t lastBweDowngradeAtMs{ 0u };
+		int64_t lastBweDowngradeAtMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/SvcProducerStreamManager.hpp

@@ -42,10 +42,11 @@ namespace RTC
 		void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
-		uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
-		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
-		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		void ProducerSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive) override;
+		int64_t IncreaseLayer(int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) override;
+		void ApplyLayers(int64_t rtpStreamActiveMs) override;
+		int64_t GetDesiredBitrate(int64_t nowMs) const override;
 		RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,
 		  bool lastSentPacketHasMarker,
@@ -65,7 +66,7 @@ namespace RTC
 		// Producer RTP stream (single stream for SVC).
 		RTC::RTP::RtpStreamRecv* producerRtpStream{ nullptr };
 		// BWE downgrade tracking.
-		uint64_t lastBweDowngradeAtMs{ 0u };
+		int64_t lastBweDowngradeAtMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/TcpConnection.hpp

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "handles/TcpConnectionHandle.hpp"
+#include "SharedInterface.hpp"
 
 namespace RTC
 {
@@ -16,11 +17,15 @@ namespace RTC
 
 		public:
 			virtual void OnTcpConnectionPacketReceived(
-			  RTC::TcpConnection* connection, const uint8_t* data, size_t len, size_t bufferLen) = 0;
+			  RTC::TcpConnection* connection,
+			  const uint8_t* data,
+			  size_t len,
+			  size_t bufferLen,
+			  int64_t receivedAtUs) = 0;
 		};
 
 	public:
-		TcpConnection(Listener* listener, size_t bufferSize);
+		TcpConnection(Listener* listener, SharedInterface* shared, size_t bufferSize);
 		~TcpConnection() override;
 
 	public:
@@ -33,8 +38,9 @@ namespace RTC
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		// Others.
-		size_t frameStart{ 0u }; // Where the latest frame starts.
+		size_t frameStart{ 0 }; // Where the latest frame starts.
 	};
 } // namespace RTC
 

package/worker/include/RTC/TcpServer.hpp

@@ -28,12 +28,14 @@ namespace RTC
 		TcpServer(
 		  Listener* listener,
 		  RTC::TcpConnection::Listener* connListener,
+		  SharedInterface* shared,
 		  std::string& ip,
 		  uint16_t port,
 		  RTC::Transport::SocketFlags& flags);
 		TcpServer(
 		  Listener* listener,
 		  RTC::TcpConnection::Listener* connListener,
+		  SharedInterface* shared,
 		  std::string& ip,
 		  uint16_t minPort,
 		  uint16_t maxPort,
@@ -50,6 +52,7 @@ namespace RTC
 		// Passed by argument.
 		Listener* listener{ nullptr };
 		RTC::TcpConnection::Listener* connListener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		bool fixedPort{ false };
 		RTC::PortManager::PortRangeKey portRangeKey{};
 	};

package/worker/include/RTC/Transport.hpp

@@ -1,13 +1,12 @@
 #ifndef MS_RTC_TRANSPORT_HPP
 #define MS_RTC_TRANSPORT_HPP
 
-// #define ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-
 #include "common.hpp"
 #include "Channel/ChannelNotification.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "FBS/transport.h"
+#include "handles/TimerHandleInterface.hpp"
 #include "RTC/Consumer.hpp"
 #include "RTC/DataConsumer.hpp"
 #include "RTC/DataProducer.hpp"
@@ -24,13 +23,11 @@
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 #include "RTC/SctpListener.hpp"
-#include "SharedInterface.hpp"
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-#include "RTC/SenderBandwidthEstimator.hpp"
-#endif
-#include "handles/TimerHandleInterface.hpp"
+#ifndef MS_USE_BUILTIN_BWE
 #include "RTC/TransportCongestionControlClient.hpp"
 #include "RTC/TransportCongestionControlServer.hpp"
+#endif
+#include "SharedInterface.hpp"
 #include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
@@ -42,13 +39,12 @@ namespace RTC
 	                  public RTC::DataProducer::Listener,
 	                  public RTC::DataConsumer::Listener,
 	                  public RTC::SCTP::AssociationListenerInterface,
+#ifndef MS_USE_BUILTIN_BWE
 	                  public RTC::TransportCongestionControlClient::Listener,
 	                  public RTC::TransportCongestionControlServer::Listener,
+#endif
 	                  public Channel::ChannelSocket::RequestHandler,
 	                  public Channel::ChannelSocket::NotificationHandler,
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-	                  public RTC::SenderBandwidthEstimator::Listener,
-#endif
 	                  public TimerHandleInterface::Listener
 	{
 	protected:
@@ -82,6 +78,12 @@ namespace RTC
 			  RTC::Producer* producer,
 			  RTC::RTP::RtpStreamRecv* rtpStream,
 			  bool first) = 0;
+			virtual void OnTransportProducerSpatialLayerActivityChanged(
+			  RTC::Transport* transport,
+			  RTC::Producer* producer,
+			  RTC::RTP::RtpStreamRecv* rtpStream,
+			  uint8_t spatialLayer,
+			  bool isActive) = 0;
 			virtual void OnTransportProducerRtpPacketReceived(
 			  RTC::Transport* transport, RTC::Producer* producer, RTC::RTP::Packet* packet) = 0;
 			/**
@@ -132,19 +134,19 @@ namespace RTC
 
 		struct PortRange
 		{
-			uint16_t min{ 0u };
-			uint16_t max{ 0u };
+			uint16_t min{ 0 };
+			uint16_t max{ 0 };
 		};
 
 		struct ListenInfo
 		{
 			std::string ip;
 			std::string announcedAddress;
-			uint16_t port{ 0u };
+			uint16_t port{ 0 };
 			PortRange portRange;
 			SocketFlags flags;
-			uint32_t sendBufferSize{ 0u };
-			uint32_t recvBufferSize{ 0u };
+			uint32_t sendBufferSize{ 0 };
+			uint32_t recvBufferSize{ 0 };
 		};
 
 	private:
@@ -161,10 +163,10 @@ namespace RTC
 		  RTC::Transport::Listener* listener,
 		  const FBS::Transport::Options* options,
 		  /**
-		   * Whether the SCTP association (if enabled) must authenticate received
-		   * State Cookies. This must be `true` for transports whose SCTP traffic
-		   * is not protected by DTLS (PlainTransport and PipeTransport).
-		   */
+			 * Whether the SCTP association (if enabled) must authenticate received
+			 * State Cookies. This must be `true` for transports whose SCTP traffic
+			 * is not protected by DTLS (PlainTransport and PipeTransport).
+			 */
 		  bool requireSctpStateCookieAuthentication);
 		~Transport() override;
 
@@ -196,9 +198,9 @@ namespace RTC
 		{
 			this->sendTransmission.Update(len, this->shared->GetTimeMs());
 		}
-		virtual void ReceiveRtpPacket(RTC::RTP::Packet* packet) final;
-		virtual void ReceiveRtcpPacket(RTC::RTCP::Packet* packet) final;
-		virtual void ReceiveSctpData(const uint8_t* data, size_t len) final;
+		virtual void ReceiveRtpPacket(RTC::RTP::Packet* packet, int64_t receivedAtUs) final;
+		virtual void ReceiveRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
+		virtual void ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs) final;
 		virtual void SendSctpMessage(
 		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) final;
 
@@ -228,8 +230,8 @@ namespace RTC
 		}
 		virtual void SendRtpPacket(
 		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const onSendCallback* cb = nullptr) = 0;
-		virtual void HandleRtcpPacket(RTC::RTCP::Packet* packet) final;
-		virtual void SendRtcp(uint64_t nowMs) final;
+		virtual void HandleRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
+		virtual void SendRtcp(int64_t nowUs) final;
 		virtual void SendRtcpPacket(RTC::RTCP::Packet* packet)                 = 0;
 		virtual void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) = 0;
 		virtual void SendMessage(
@@ -240,8 +242,10 @@ namespace RTC
 		virtual void DistributeAvailableOutgoingBitrate() final;
 		virtual void ComputeOutgoingDesiredBitrate(bool forceBitrate = false) final;
 		virtual void EmitTraceEventProbationType(RTC::RTP::Packet* packet) const final;
+#ifndef MS_USE_BUILTIN_BWE
 		virtual void EmitTraceEventBweType(
 		  RTC::TransportCongestionControlClient::Bitrates& bitrates) const final;
+#endif
 
 		/* Pure virtual methods inherited from RTC::Producer::Listener. */
 	public:
@@ -249,9 +253,10 @@ namespace RTC
 		{
 			this->DataReceived(len);
 		}
-		void OnProducerReceiveRtpPacket(RTC::Producer* /*producer*/, RTC::RTP::Packet* packet) override
+		void OnProducerReceiveRtpPacket(
+		  RTC::Producer* /*producer*/, RTC::RTP::Packet* packet, int64_t receivedAtUs) override
 		{
-			this->ReceiveRtpPacket(packet);
+			this->ReceiveRtpPacket(packet, receivedAtUs);
 		}
 		void OnProducerPaused(RTC::Producer* producer) override;
 		void OnProducerResumed(RTC::Producer* producer) override;
@@ -264,12 +269,17 @@ namespace RTC
 		  uint8_t previousScore) override;
 		void OnProducerRtcpSenderReport(
 		  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
+		void OnProducerSpatialLayerActivityChanged(
+		  RTC::Producer* producer,
+		  RTC::RTP::RtpStreamRecv* rtpStream,
+		  uint8_t spatialLayer,
+		  bool isActive) override;
 		void OnProducerRtpPacketReceived(RTC::Producer* producer, RTC::RTP::Packet* packet) override;
 		void OnProducerSendRtcpPacket(RTC::Producer* producer, RTC::RTCP::Packet* packet) override;
 		uint8_t OnProducerNeedWorstRemoteFractionLost(RTC::Producer* producer, uint32_t mappedSsrc) override;
-		std::optional<uint64_t> OnProducerNeedLocalCaptureMs(
+		std::optional<int64_t> OnProducerNeedLocalCaptureAtUs(
 		  RTC::Producer* producer, const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) override;
-		std::optional<int64_t> OnProducerNeedRemoteClockOffsetMs(const RTC::Producer* producer) override;
+		std::optional<int64_t> OnProducerNeedRemoteClockOffsetUs(const RTC::Producer* producer) override;
 
 		/* Pure virtual methods inherited from RTC::Consumer::Listener. */
 	public:
@@ -325,6 +335,7 @@ namespace RTC
 		void OnAssociationTotalBufferedAmountLow() override;
 		bool OnAssociationIsTransportReadyForSctp() override;
 
+#ifndef MS_USE_BUILTIN_BWE
 		/* Pure virtual methods inherited from RTC::TransportCongestionControlClient::Listener. */
 	public:
 		void OnTransportCongestionControlClientBitrates(
@@ -339,14 +350,6 @@ namespace RTC
 	public:
 		void OnTransportCongestionControlServerSendRtcpPacket(
 		  RTC::TransportCongestionControlServer* tccServer, RTC::RTCP::Packet* packet) override;
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-		/* Pure virtual methods inherited from RTC::SenderBandwidthEstimator::Listener. */
-	public:
-		void OnSenderBandwidthEstimatorAvailableBitrate(
-		  RTC::SenderBandwidthEstimator* senderBwe,
-		  uint32_t availableBitrate,
-		  uint32_t previousAvailableBitrate) override;
 #endif
 
 		/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
@@ -378,10 +381,9 @@ namespace RTC
 		TimerHandleInterface* rtcpTimer{ nullptr };
 		// Allocated by this.
 		std::unique_ptr<RTC::SCTP::AssociationInterface> sctpAssociation{ nullptr };
+#ifndef MS_USE_BUILTIN_BWE
 		std::shared_ptr<RTC::TransportCongestionControlClient> tccClient{ nullptr };
 		std::shared_ptr<RTC::TransportCongestionControlServer> tccServer{ nullptr };
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-		std::shared_ptr<RTC::SenderBandwidthEstimator> senderBwe{ nullptr };
 #endif
 		// Others.
 		bool direct{ false }; // Whether this Transport allows direct communication.
@@ -396,14 +398,19 @@ namespace RTC
 		RTC::RtpDataCounter recvRtxTransmission;
 		RTC::RtpDataCounter sendRtxTransmission;
 		RTC::RtpDataCounter sendProbationTransmission;
-		uint16_t transportWideCcSeq{ 0u };
-		uint32_t initialAvailableOutgoingBitrate{ 600000u };
-		uint32_t maxIncomingBitrate{ 0u };
-		uint32_t maxOutgoingBitrate{ 0u };
-		uint32_t minOutgoingBitrate{ 0u };
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: The built-in downlink BWE hands the sequence number out, so this
+		// counter goes away.
+#else
+		uint16_t transportWideCcSeq{ 0 };
+#endif
+		int64_t initialAvailableOutgoingBitrate{ 600000 };
+		int64_t maxIncomingBitrate{ 0 };
+		int64_t maxOutgoingBitrate{ 0 };
+		int64_t minOutgoingBitrate{ 0 };
 		// For SCTP capable transports and for direct transport.
-		size_t maxSendMessageSize{ 0u };
-		size_t maxReceiveMessageSize{ 0u };
+		size_t maxSendMessageSize{ 0 };
+		size_t maxReceiveMessageSize{ 0 };
 		struct TraceEventTypes traceEventTypes;
 	};
 } // namespace RTC

package/worker/include/RTC/TransportCongestionControlClient.hpp

@@ -18,8 +18,6 @@
 
 namespace RTC
 {
-	constexpr uint32_t TransportCongestionControlMinOutgoingBitrate{ 30000u };
-
 	class TransportCongestionControlClient : public webrtc::PacketRouter,
 	                                         public webrtc::TargetTransferRateObserver,
 	                                         public TimerHandleInterface::Listener
@@ -27,13 +25,13 @@ namespace RTC
 	public:
 		struct Bitrates
 		{
-			uint32_t desiredBitrate{ 0u };
-			uint32_t effectiveDesiredBitrate{ 0u };
-			uint32_t minBitrate{ 0u };
-			uint32_t maxBitrate{ 0u };
-			uint32_t startBitrate{ 0u };
-			uint32_t maxPaddingBitrate{ 0u };
-			uint32_t availableBitrate{ 0u };
+			int64_t desiredBitrate{ 0 };
+			int64_t effectiveDesiredBitrate{ 0 };
+			int64_t minBitrate{ 0 };
+			int64_t maxBitrate{ 0 };
+			int64_t startBitrate{ 0 };
+			int64_t maxPaddingBitrate{ 0 };
+			int64_t availableBitrate{ 0 };
 		};
 
 	public:
@@ -53,13 +51,18 @@ namespace RTC
 		};
 
 	public:
+		/**
+		 * @param absoluteMinOutgoingBitrate - Bitrate the target is never taken
+		 *   below (bps), whatever the API asks for.
+		 */
 		TransportCongestionControlClient(
 		  RTC::TransportCongestionControlClient::Listener* listener,
 		  SharedInterface* shared,
 		  RTC::BweType bweType,
-		  uint32_t initialAvailableBitrate,
-		  uint32_t maxOutgoingBitrate,
-		  uint32_t minOutgoingBitrate);
+		  int64_t absoluteMinOutgoingBitrate,
+		  int64_t initialAvailableBitrate,
+		  int64_t maxOutgoingBitrate,
+		  int64_t minOutgoingBitrate);
 		~TransportCongestionControlClient() override;
 
 	public:
@@ -71,23 +74,24 @@ namespace RTC
 		void TransportDisconnected();
 		void InsertPacket(webrtc::RtpPacketSendInfo& packetInfo);
 		webrtc::PacedPacketInfo GetPacingInfo();
-		void PacketSent(const webrtc::RtpPacketSendInfo& packetInfo, int64_t nowMs);
-		void ReceiveEstimatedBitrate(uint32_t bitrate);
-		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReportPacket* packet, float rtt, int64_t nowMs);
+		void PacketSent(const webrtc::RtpPacketSendInfo& packetInfo, int64_t nowUs);
+		void ReceiveEstimatedBitrate(int64_t bitrate);
+		void ReceiveRtcpReceiverReport(
+		  RTC::RTCP::ReceiverReportPacket* packet, float rttMs, int64_t receivedAtUs);
 		void ReceiveRtcpTransportFeedback(const RTC::RTCP::FeedbackRtpTransportPacket* feedback);
-		void SetDesiredBitrate(uint32_t desiredBitrate, bool force);
-		void SetMaxOutgoingBitrate(uint32_t maxBitrate);
-		void SetMinOutgoingBitrate(uint32_t minBitrate);
+		void SetDesiredBitrate(int64_t desiredBitrate, bool force);
+		void SetMaxOutgoingBitrate(int64_t maxBitrate);
+		void SetMinOutgoingBitrate(int64_t minBitrate);
 		const Bitrates& GetBitrates() const
 		{
 			return this->bitrates;
 		}
-		uint32_t GetAvailableBitrate() const;
+		int64_t GetAvailableBitrate() const;
 		double GetPacketLoss() const;
 		void RescheduleNextAvailableBitrateEvent();
 
 	private:
-		void MayEmitAvailableBitrateEvent(uint32_t previousAvailableBitrate);
+		void MayEmitAvailableBitrateEvent(int64_t previousAvailableBitrate);
 		void UpdatePacketLoss(double packetLoss);
 		void ApplyBitrateUpdates();
 
@@ -120,13 +124,14 @@ namespace RTC
 		RTC::RTP::ProbationGenerator* probationGenerator{ nullptr };
 		TimerHandleInterface* processTimer{ nullptr };
 		// Others.
-		RTC::BweType bweType;
-		uint32_t initialAvailableBitrate{ 0u };
-		uint32_t maxOutgoingBitrate{ 0u };
-		uint32_t minOutgoingBitrate{ 0u };
+		const RTC::BweType bweType;
+		const int64_t absoluteMinOutgoingBitrate;
+		const int64_t initialAvailableBitrate;
+		int64_t maxOutgoingBitrate{ 0 };
+		int64_t minOutgoingBitrate{ 0 };
 		Bitrates bitrates;
 		bool availableBitrateEventCalled{ false };
-		uint64_t lastAvailableBitrateEventAtMs{ 0u };
+		int64_t lastAvailableBitrateEventAtMs{ 0 };
 		RTC::TrendCalculator desiredBitrateTrend;
 		std::deque<double> packetLossHistory;
 		double packetLoss{ 0 };

package/worker/include/RTC/TransportCongestionControlServer.hpp

@@ -43,7 +43,7 @@ namespace RTC
 		}
 		void TransportConnected();
 		void TransportDisconnected();
-		uint32_t GetAvailableBitrate() const
+		int64_t GetAvailableBitrate() const
 		{
 			switch (this->bweType)
 			{
@@ -51,19 +51,19 @@ namespace RTC
 					return this->rembServer->GetAvailableBitrate();
 
 				default:
-					return 0u;
+					return 0;
 			}
 		}
 		double GetPacketLoss() const;
-		void IncomingPacket(uint64_t nowMs, const RTC::RTP::Packet* packet);
-		void SetMaxIncomingBitrate(uint32_t bitrate);
+		void IncomingPacket(int64_t nowUs, const RTC::RTP::Packet* packet);
+		void SetMaxIncomingBitrate(int64_t bitrate);
 		void FillAndSendTransportCcFeedback();
 
 	private:
 		// Returns true if a feedback packet was sent.
 		bool SendTransportCcFeedback();
-		void MayDropOldPacketArrivalTimes(uint16_t seqNum, uint64_t nowMs);
-		void MaySendLimitationRembFeedback(uint64_t nowMs);
+		void MayDropOldPacketArrivalTimes(uint16_t seqNum, int64_t nowUs);
+		void MaySendLimitationRembFeedback(int64_t nowMs);
 		void UpdatePacketLoss(double packetLoss);
 		void ResetTransportCcFeedback(uint8_t feedbackPacketCount);
 
@@ -72,7 +72,7 @@ namespace RTC
 		void OnRembServerAvailableBitrate(
 		  const webrtc::RemoteBitrateEstimator* remoteBitrateEstimator,
 		  const std::vector<uint32_t>& ssrcs,
-		  uint32_t availableBitrate) override;
+		  int64_t availableBitrate) override;
 
 		/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 	public:
@@ -88,20 +88,20 @@ namespace RTC
 		webrtc::RemoteBitrateEstimatorAbsSendTime* rembServer{ nullptr };
 		// Others.
 		RTC::BweType bweType;
-		size_t maxRtcpPacketLen{ 0u };
-		uint8_t transportCcFeedbackPacketCount{ 0u };
-		uint32_t transportCcFeedbackSenderSsrc{ 0u };
-		uint32_t transportCcFeedbackMediaSsrc{ 0u };
-		uint32_t maxIncomingBitrate{ 0u };
-		uint64_t limitationRembSentAtMs{ 0u };
-		uint8_t unlimitedRembCounter{ 0u };
+		size_t maxRtcpPacketLen{ 0 };
+		uint8_t transportCcFeedbackPacketCount{ 0 };
+		uint32_t transportCcFeedbackSenderSsrc{ 0 };
+		uint32_t transportCcFeedbackMediaSsrc{ 0 };
+		int64_t maxIncomingBitrate{ 0 };
+		int64_t limitationRembSentAtMs{ 0 };
+		uint8_t unlimitedRembCounter{ 0 };
 		std::deque<double> packetLossHistory;
 		double packetLoss{ 0 };
 		// Whether any packet with transport wide sequence number was received.
 		bool transportWideSeqNumberReceived{ false };
-		uint16_t transportCcFeedbackWideSeqNumStart{ 0u };
-		// Map of arrival timestamp (ms) indexed by wide seq number.
-		std::map<uint16_t, uint64_t, RTC::SeqManager<uint16_t>::SeqLowerThan> mapPacketArrivalTimes;
+		uint16_t transportCcFeedbackWideSeqNumStart{ 0 };
+		// Map of arrival timestamp (us) indexed by wide seq number.
+		std::map<uint16_t, int64_t, RTC::SeqManager<uint16_t>::SeqLowerThan> mapPacketArrivalTimes;
 	};
 } // namespace RTC
 

package/worker/include/RTC/TrendCalculator.hpp

@@ -18,14 +18,14 @@ namespace RTC
 		{
 			return this->value;
 		}
-		void Update(uint32_t value, uint64_t nowMs);
-		void ForceUpdate(uint32_t value, uint64_t nowMs);
+		void Update(uint32_t value, int64_t nowMs);
+		void ForceUpdate(uint32_t value, int64_t nowMs);
 
 	private:
 		float decreaseFactor{ DecreaseFactor };
-		uint32_t value{ 0u };
-		uint32_t highestValue{ 0u };
-		uint64_t highestValueUpdatedAtMs{ 0u };
+		uint32_t value{ 0 };
+		uint32_t highestValue{ 0 };
+		int64_t highestValueUpdatedAtMs{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/UdpSocket.hpp

@@ -5,6 +5,7 @@
 #include "handles/UdpSocketHandle.hpp"
 #include "RTC/PortManager.hpp"
 #include "RTC/Transport.hpp"
+#include "SharedInterface.hpp"
 #include <string>
 
 namespace RTC
@@ -23,13 +24,20 @@ namespace RTC
 			  const uint8_t* data,
 			  size_t len,
 			  size_t bufferLen,
-			  const struct sockaddr* remoteAddr) = 0;
+			  const struct sockaddr* remoteAddr,
+			  int64_t receivedAtUs) = 0;
 		};
 
 	public:
-		UdpSocket(Listener* listener, std::string& ip, uint16_t port, RTC::Transport::SocketFlags& flags);
 		UdpSocket(
 		  Listener* listener,
+		  SharedInterface* shared,
+		  std::string& ip,
+		  uint16_t port,
+		  RTC::Transport::SocketFlags& flags);
+		UdpSocket(
+		  Listener* listener,
+		  SharedInterface* shared,
 		  std::string& ip,
 		  uint16_t minPort,
 		  uint16_t maxPort,
@@ -45,6 +53,7 @@ namespace RTC
 	private:
 		// Passed by argument.
 		Listener* listener{ nullptr };
+		SharedInterface* shared{ nullptr };
 		bool fixedPort{ false };
 		RTC::PortManager::PortRangeKey portRangeKey{};
 	};

package/worker/include/RTC/WebRtcServer.hpp

@@ -68,10 +68,20 @@ namespace RTC
 		void HandleRequest(Channel::ChannelRequest* request) override;
 
 	private:
-		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnStunDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnStunDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 		void OnNonStunDataReceived(
-		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
 
 		/* Pure virtual methods inherited from RTC::WebRtcTransport::WebRtcTransportListener. */
 	public:
@@ -93,7 +103,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 		/* Pure virtual methods inherited from RTC::TcpServer::Listener. */
 	public:
@@ -102,7 +113,11 @@ namespace RTC
 		/* Pure virtual methods inherited from RTC::TcpConnection::Listener. */
 	public:
 		void OnTcpConnectionPacketReceived(
-		  RTC::TcpConnection* connection, const uint8_t* data, size_t len, size_t bufferLen) override;
+		  RTC::TcpConnection* connection,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs) override;
 		const std::string& GetId() const
 		{
 			return this->id;