mediasoup 3.26.0 → 3.27.0

package/worker/include/RTC/SCTP/association/StateCookie.hpp

@@ -139,12 +139,12 @@ namespace RTC
 			// Fixed length of our generated State Cookies when authentication is
 			// enabled.
 			static constexpr size_t AuthenticatedStateCookieLength{ StateCookie::MacOffset +
-				                                                      StateCookie::MacLength };
-			// State Cookie lifespan (Valid.Cookie.Life) in milliseconds. Used to
+			                                                        StateCookie::MacLength };
+			// State Cookie lifespan (Valid.Cookie.Life) in microseconds. Used to
 			// reject stale authenticated cookies.
 			//
 			// @see RFC 9260 section 16.
-			static constexpr uint64_t ValidCookieLifeMs{ 60000 };
+			static constexpr int64_t ValidCookieLifeUs{ 60000 * 1000 };
 
 		public:
 			/**
@@ -163,7 +163,7 @@ namespace RTC
 			 *   cookie.
 			 * - If `macKey` is not nullptr, an authenticated cookie (with creation
 			 *   timestamp and MAC) is generated. Otherwise a plain cookie is
-			 *   generated and `creationTimestampMs`/`macKey` are ignored.
+			 *   generated and `creationTimestampUs`/`macKey` are ignored.
 			 */
 			static StateCookie* Factory(
 			  uint8_t* buffer,
@@ -175,9 +175,9 @@ namespace RTC
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
 			  const Capabilities& remoteCapabilities,
-			  uint64_t creationTimestampMs = 0,
-			  const uint8_t* macKey        = nullptr,
-			  size_t macKeyLength          = 0);
+			  int64_t creationTimestampUs = 0,
+			  const uint8_t* macKey       = nullptr,
+			  size_t macKeyLength         = 0);
 
 			/**
 			 * Serialize a StateCookie (based on given arguments) in the given buffer.
@@ -185,7 +185,7 @@ namespace RTC
 			 * @remarks
 			 * - If `macKey` is not nullptr, an authenticated cookie (with creation
 			 *   timestamp and MAC) is generated. Otherwise a plain cookie is
-			 *   generated and `creationTimestampMs`/`macKey` are ignored.
+			 *   generated and `creationTimestampUs`/`macKey` are ignored.
 			 */
 			static void Write(
 			  uint8_t* buffer,
@@ -197,9 +197,9 @@ namespace RTC
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
 			  const Capabilities& remoteCapabilities,
-			  uint64_t creationTimestampMs = 0,
-			  const uint8_t* macKey        = nullptr,
-			  size_t macKeyLength          = 0);
+			  int64_t creationTimestampUs = 0,
+			  const uint8_t* macKey       = nullptr,
+			  size_t macKeyLength         = 0);
 
 			/**
 			 * Whether the given buffer is a StateCookie generated by mediasoup.
@@ -311,14 +311,14 @@ namespace RTC
 			}
 
 			/**
-			 * The time (in milliseconds) at which this StateCookie was created.
+			 * The time (in microseconds) at which this StateCookie was created.
 			 *
 			 * @remarks
 			 * - Only meaningful in authenticated cookies (see `IsAuthenticated()`).
 			 */
-			uint64_t GetCreationTimestampMs() const
+			int64_t GetCreationTimestampUs() const
 			{
-				return Utils::Byte::Get8Bytes(GetBuffer(), StateCookie::TimestampOffset);
+				return static_cast<int64_t>(Utils::Byte::Get8Bytes(GetBuffer(), StateCookie::TimestampOffset));
 			}
 
 		private:

package/worker/include/RTC/SCTP/association/StreamResetHandler.hpp

@@ -255,12 +255,12 @@ namespace RTC
 			void HandleReceivedReconfigurationResponseParameter(
 			  const ReconfigurationResponseParameter* receivedReconfigurationResponseParameter);
 
-			void OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnReConfigTimer(int64_t& baseTimeoutMs, bool& stop);
 
 			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
 			void OnBackoffTimer(
-			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			AssociationListenerDeferrer& associationListenerDeferrer;

package/worker/include/RTC/SCTP/association/TransmissionControlBlock.hpp

@@ -140,7 +140,7 @@ namespace RTC
 			 * @remarks
 			 * - Implements TransmissionControlBlockContextInterface.
 			 */
-			void ObserveRttMs(uint64_t rttMs) override;
+			void ObserveRttUs(int64_t rttUs) override;
 
 			size_t GetCwnd() const
 			{
@@ -151,14 +151,14 @@ namespace RTC
 			 * @remarks
 			 * - Implements TransmissionControlBlockContextInterface.
 			 */
-			uint64_t GetCurrentRtoMs() const override
+			int64_t GetCurrentRtoUs() const override
 			{
-				return this->rto.GetRtoMs();
+				return this->rto.GetRtoUs();
 			}
 
-			uint64_t GetCurrentSrttMs() const
+			int64_t GetCurrentSrttUs() const
 			{
-				return this->rto.GetSrttMs();
+				return this->rto.GetSrttUs();
 			}
 
 			/**
@@ -229,7 +229,7 @@ namespace RTC
 			 * May add a FORWARD-TSN or I-FORWARD-TSN chunk to the given packet if it
 			 * is needed and allowed (rate-limited).
 			 */
-			void MayAddForwardTsnChunk(Packet* packet, uint64_t nowMs);
+			void MayAddForwardTsnChunk(Packet* packet, int64_t nowUs);
 
 			void MaySendFastRetransmit();
 
@@ -243,7 +243,7 @@ namespace RTC
 			 * - Cannot pass `addCookieAckChunk=true` if `this->remoteStateCookie` is
 			 *   present (will throw).
 			 */
-			void SendBufferedPackets(uint64_t nowMs, bool addCookieAckChunk = false);
+			void SendBufferedPackets(int64_t nowUs, bool addCookieAckChunk = false);
 
 			/**
 			 * @remarks
@@ -286,20 +286,20 @@ namespace RTC
 			}
 
 		private:
-			void OnT3RtxTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnT3RtxTimer(int64_t& baseTimeoutMs, bool& stop);
 
-			void OnDelayedAckTimer(uint64_t& baseTimeoutMs, bool& stop);
+			void OnDelayedAckTimer(int64_t& baseTimeoutMs, bool& stop);
 
 			/* Pure virtual methods inherited from RetransmissionQueue::Listener. */
 		public:
-			void OnRetransmissionQueueNewRttMs(uint64_t newRttMs) override;
+			void OnRetransmissionQueueNewRttUs(int64_t newRttUs) override;
 			void OnRetransmissionQueueClearRetransmissionCounter() override;
 			;
 
 			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
 			void OnBackoffTimer(
-			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			  BackoffTimerHandleInterface* backoffTimer, int64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			TransmissionControlBlockContextInterface::Listener* listener;
@@ -332,7 +332,7 @@ namespace RTC
 			HeartbeatHandler heartbeatHandler;
 			// Rate limiting of FORWARD-TSN. Next can be sent at or after this
 			// timestamp.
-			uint64_t limitForwardTsnUntilMs{ 0 };
+			int64_t limitForwardTsnUntilUs{ 0 };
 			// Only valid when state is State::COOKIE_ECHOED. In this state, the
 			// association must wait for COOKIE-ACK to continue sending any packets (not
 			// including a COOKIE-ECHO). So if this state cookie is present, the

package/worker/include/RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp

@@ -49,15 +49,15 @@ namespace RTC
 			virtual uint32_t GetRemoteInitialTsn() const = 0;
 
 			/**
-			 * To be called when a RTT (ms) has been measured, to update the RTO
+			 * To be called when a RTT (us) has been measured, to update the RTO
 			 * value.
 			 */
-			virtual void ObserveRttMs(uint64_t rttMs) = 0;
+			virtual void ObserveRttUs(int64_t rttUs) = 0;
 
 			/**
-			 * Returns the Retransmission Timeout (RTO) value.
+			 * Returns the Retransmission Timeout (RTO) value (us).
 			 */
-			virtual uint64_t GetCurrentRtoMs() const = 0;
+			virtual int64_t GetCurrentRtoUs() const = 0;
 
 			/**
 			 * Increments the transmission error counter, given a human readable

package/worker/include/RTC/SCTP/packet/TLV.hpp

@@ -134,7 +134,7 @@ namespace RTC
 			{
 				if (!HasVariableLengthValue())
 				{
-					return 0u;
+					return 0;
 				}
 
 				return GetLengthField() - GetHeaderLength();

package/worker/include/RTC/SCTP/packet/parameters/StateCookieParameter.hpp

@@ -105,9 +105,9 @@ namespace RTC
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
 			  const Capabilities& remoteCapabilities,
-			  uint64_t creationTimestampMs = 0,
-			  const uint8_t* macKey        = nullptr,
-			  size_t macKeyLength          = 0);
+			  int64_t creationTimestampUs = 0,
+			  const uint8_t* macKey       = nullptr,
+			  size_t macKeyLength         = 0);
 
 		protected:
 			StateCookieParameter* SoftClone(const uint8_t* buffer) const final;

package/worker/include/RTC/SCTP/public/AssociationInterface.hpp

@@ -175,8 +175,11 @@ namespace RTC
 
 			/**
 			 * Receives SCTP data (hopefully an SCTP packet) from the remote peer.
+			 *
+			 * @param receivedAtUs - Time at which the data arrived from the network,
+			 *   taken as close to the socket read as possible.
 			 */
-			virtual void ReceiveSctpData(const uint8_t* data, size_t len) = 0;
+			virtual void ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs) = 0;
 
 			/**
 			 * Get negotiated max outbound streams. Returns 0 if the association is

package/worker/include/RTC/SCTP/public/AssociationMetrics.hpp

@@ -58,7 +58,7 @@ namespace RTC
 			 * Smoothed round trip time (in ms), corresponding to `spinfo_srtt`
 			 * defined in RFC 6458.
 			 */
-			uint64_t srttMs{ 0 };
+			int64_t srttMs{ 0 };
 
 			/**
 			 * Number of data items in the retransmission queue that haven’t been

package/worker/include/RTC/SCTP/public/SctpOptions.hpp

@@ -109,55 +109,55 @@ namespace RTC
 			 * RTO calculation. The default value is an extreme maximum but can be
 			 * adapted to better match the environment.
 			 */
-			uint64_t maxRttMs{ 60000 };
+			int64_t maxRttMs{ 60000 };
 
 			/**
 			 * Initial RTO value.
 			 */
-			uint64_t initialRtoMs{ 500 };
+			int64_t initialRtoMs{ 500 };
 
 			/**
 			 * Minimum RTO value.
 			 */
-			uint64_t minRtoMs{ 400 };
+			int64_t minRtoMs{ 400 };
 
 			/**
 			 * Minimum RTO value.
 			 */
-			uint64_t maxRtoMs{ 60000 };
+			int64_t maxRtoMs{ 60000 };
 
 			/**
 			 * T1-init timeout (ms).
 			 */
-			uint64_t t1InitTimeoutMs{ 1000 };
+			int64_t t1InitTimeoutMs{ 1000 };
 
 			/**
 			 * T1-cookie timeout (ms).
 			 */
-			uint64_t t1CookieTimeoutMs{ 1000 };
+			int64_t t1CookieTimeoutMs{ 1000 };
 
 			/**
 			 * T2-shutdown timeout (ms).
 			 */
-			uint64_t t2ShutdownTimeoutMs{ 1000 };
+			int64_t t2ShutdownTimeoutMs{ 1000 };
 
 			/**
 			 * Maximum duration of the backoff timeout. If no value is given, no
 			 * limit is set.
 			 */
-			std::optional<uint64_t> timerMaxBackoffTimeoutMs{ std::nullopt };
+			std::optional<int64_t> timerMaxBackoffTimeoutMs{ std::nullopt };
 
 			/**
 			 * Hearbeat interval (on idle connections only). Set to zero to disable.
 			 */
-			uint64_t heartbeatIntervalMs{ 30000 };
+			int64_t heartbeatIntervalMs{ 30000 };
 
 			/**
 			 * The maximum time when a SACK will be sent from the arrival of an
 			 * unacknowledged packet. Whatever is smallest of RTO/2 and this will be
 			 * used.
 			 */
-			uint64_t delayedAckMaxTimeoutMs{ 200 };
+			int64_t delayedAckMaxTimeoutMs{ 200 };
 
 			/**
 			 * The minimum limit for the measured RTT variance.
@@ -174,7 +174,7 @@ namespace RTC
 			 * This is defined as "G" in the algorithm for TCP in
 			 * https://datatracker.ietf.org/doc/html/rfc6298#section-4.
 			 */
-			uint64_t minRttVarianceMs{ 220 };
+			int64_t minRttVarianceMs{ 220 };
 
 			/**
 			 * The initial congestion window size, in number of MTUs.
@@ -302,7 +302,7 @@ namespace RTC
 			 * received before the lifetime has expired. This is only available if
 			 * the peer supports Partial Reliability Extension (RFC 3758).
 			 */
-			std::optional<uint64_t> lifetimeMs{ std::nullopt };
+			std::optional<int64_t> lifetimeMs{ std::nullopt };
 
 			/**
 			 * If set, limits the number of retransmissions. This is only available

package/worker/include/RTC/SCTP/public/SctpTypes.hpp

@@ -338,7 +338,7 @@ namespace RTC
 
 			constexpr uint16_t MaxRetransmitsNoLimit{ std::numeric_limits<uint16_t>::max() };
 
-			constexpr uint64_t ExpiresAtMsInfinite{ std::numeric_limits<uint64_t>::max() };
+			constexpr int64_t ExpiresAtUsInfinite{ std::numeric_limits<int64_t>::max() };
 
 			/**
 			 * Unwrapped Transmission Sequence Numbers (TSN).

package/worker/include/RTC/SCTP/tx/OutstandingData.hpp

@@ -162,9 +162,9 @@ namespace RTC
 				Item(
 				  uint32_t outgoingMessageId,
 				  UserData data,
-				  uint64_t timeSentMs,
+				  int64_t timeSentUs,
 				  uint16_t maxRetransmissions,
-				  uint64_t expiresAtMs,
+				  int64_t expiresAtUs,
 				  std::optional<uint64_t> lifecycleId);
 
 				Item(const Item&) = delete;
@@ -177,9 +177,9 @@ namespace RTC
 					return this->outgoingMessageId;
 				}
 
-				uint64_t GetTimeSentMs() const
+				int64_t GetTimeSentUs() const
 				{
-					return this->timeSentMs;
+					return this->timeSentUs;
 				}
 
 				const UserData& GetData() const
@@ -251,9 +251,9 @@ namespace RTC
 				 * Given the current time, and the current state of this DATA chunk, it
 				 * will indicate if it has expired (SCTP Partial Reliability Extension).
 				 */
-				bool HasExpired(uint64_t nowMs) const
+				bool HasExpired(int64_t nowUs) const
 				{
-					return (this->expiresAtMs != Types::ExpiresAtMsInfinite && this->expiresAtMs <= nowMs);
+					return (this->expiresAtUs != Types::ExpiresAtUsInfinite && this->expiresAtUs <= nowUs);
 				}
 
 				std::optional<uint64_t> GetLifecycleId() const
@@ -265,15 +265,14 @@ namespace RTC
 				// The actual data to send/retransmit.
 				const UserData data;
 				// When the packet was sent, and placed in this queue.
-				const uint64_t timeSentMs;
+				const int64_t timeSentUs;
 				// If the message was sent with a maximum number of retransmissions,
 				// this is set to that number. The value zero (0) means that it will
 				// never be retransmitted.
 				const uint16_t maxRetransmissions;
-				// At this exact millisecond, the item is considered expired. If the
-				// message is not to be expired, this is set to the infinite future.
-				// NOTE: If 0 it means infinite time.
-				const uint64_t expiresAtMs;
+				// At this exact microsecond, the item is considered expired. If the
+				// message is not to be expired, this is set to `ExpiresAtUsInfinite`.
+				const int64_t expiresAtUs;
 				// An optional lifecycle id, which may only be set for the last
 				// fragment.
 				const std::optional<uint64_t> lifecycleId;
@@ -342,10 +341,10 @@ namespace RTC
 			}
 
 			/**
-			 * Given the current time `nowMs`, expire and abandon outstanding (sent
+			 * Given the current time `nowUs`, expire and abandon outstanding (sent
 			 * at least once) chunks that have a limited lifetime.
 			 */
-			void ExpireOutstandingChunks(uint64_t nowMs);
+			void ExpireOutstandingChunks(int64_t nowUs);
 
 			bool IsEmpty() const
 			{
@@ -382,9 +381,9 @@ namespace RTC
 			std::optional<Types::UnwrappedTsn> Insert(
 			  uint32_t outgoingMessageId,
 			  const UserData& data,
-			  uint64_t timeSentMs,
+			  int64_t timeSentUs,
 			  uint16_t maxRetransmissions         = Types::MaxRetransmitsNoLimit,
-			  uint64_t expiresAtMs                = Types::ExpiresAtMsInfinite,
+			  int64_t expiresAtUs                 = Types::ExpiresAtUsInfinite,
 			  std::optional<uint64_t> lifecycleId = std::nullopt);
 
 			/**
@@ -408,7 +407,7 @@ namespace RTC
 			 * algorithm, so if the chunk has ever been retransmitted, it will return
 			 * `std::nullopt`.
 			 */
-			std::optional<uint64_t> MeasureRtt(uint64_t nowMs, Types::UnwrappedTsn tsn) const;
+			std::optional<int64_t> MeasureRttUs(int64_t nowUs, Types::UnwrappedTsn tsn) const;
 
 			/**
 			 * Returns true if the next chunk that is not acked by the peer has been

package/worker/include/RTC/SCTP/tx/RetransmissionQueue.hpp

@@ -37,7 +37,7 @@ namespace RTC
 				virtual ~Listener() = default;
 
 			public:
-				virtual void OnRetransmissionQueueNewRttMs(uint64_t newRttMs)  = 0;
+				virtual void OnRetransmissionQueueNewRttUs(int64_t newRttUs)   = 0;
 				virtual void OnRetransmissionQueueClearRetransmissionCounter() = 0;
 			};
 
@@ -53,7 +53,7 @@ namespace RTC
 			 * Creates a RetransmissionQueue which will send data using
 			 * `localInitialTsn` as the first TSN to use for sent fragments. It will
 			 * poll data from `sendQueue`. When SACKs are received, it will estimate
-			 * the RTT and call `listener->OnRetransmissionQueueNewRttMs()`. When an
+			 * the RTT and call `listener->OnRetransmissionQueueNewRttUs()`. When an
 			 * outstanding chunk has been acked, it will call
 			 * `listener->OnRetransmissionQueueClearRetransmissionCounter() and will
 			 * also use `t3RtxTimer`, which is the SCTP retransmission timer to manage
@@ -77,7 +77,7 @@ namespace RTC
 			 * Handles a received SACK. Returns true if the SACK was processed and
 			 * false if it was discarded due to received out-of-order and not relevant.
 			 */
-			bool HandleReceivedSackChunk(uint64_t nowMs, const SackChunk* receivedSackChunk);
+			bool HandleReceivedSackChunk(int64_t nowUs, const SackChunk* receivedSackChunk);
 
 			/**
 			 * Handles an expired retransmission timer.
@@ -101,8 +101,7 @@ namespace RTC
 			 * Note that `ShouldSendForwardTsn()` must be called prior to this method,
 			 * to abandon expired chunks, as this method will not expire any chunks.
 			 */
-			std::vector<std::pair<uint32_t /*tsn*/, UserData>> GetChunksToSend(
-			  uint64_t nowMs, size_t maxLength);
+			std::vector<std::pair<uint32_t /*tsn*/, UserData>> GetChunksToSend(int64_t nowUs, size_t maxLength);
 
 #ifdef MS_TEST
 			/**
@@ -182,11 +181,11 @@ namespace RTC
 			}
 
 			/**
-			 * Given the current time `nowMs`, it will evaluate if there are chunks
+			 * Given the current time `nowUs`, it will evaluate if there are chunks
 			 * that have expired and that need to be discarded. It returns true if a
 			 * FORWARD-TSN should be sent.
 			 */
-			bool ShouldSendForwardTsn(uint64_t nowMs);
+			bool ShouldSendForwardTsn(int64_t nowUs);
 
 			/**
 			 * Adds a FORWARD-TSN chunk to the given packet and returns it.
@@ -240,7 +239,7 @@ namespace RTC
 			 * When a SACK chunk is received, this method will be called which may
 			 * call into the `RetransmissionTimeout` to update the RTO.
 			 */
-			void UpdateRttMs(uint64_t nowMs, Types::UnwrappedTsn cumulativeTsnAck);
+			void UpdateRttUs(int64_t nowUs, Types::UnwrappedTsn cumulativeTsnAck);
 
 			/**
 			 * If the congestion control is in "fast recovery mode", this may be

package/worker/include/RTC/SCTP/tx/RetransmissionTimeout.hpp

@@ -14,7 +14,7 @@ namespace RTC
 		 * as delayed ack.
 		 *
 		 * When a round-trip-time (RTT) is calculated (outside this class), the
-		 * `ObserveRttMs()` method is called, which calculates the retransmission
+		 * `ObserveRttUs()` method is called, which calculates the retransmission
 		 * timeout (RTO) value. The RTO value will become larger if the RTT is high
 		 * and/or the RTT values are varying a lot, which is an indicator of a bad
 		 * connection.
@@ -30,35 +30,39 @@ namespace RTC
 			void Dump(int indentation = 0) const;
 
 			/**
-			 * To be called when a RTT (ms) has been measured, to update the RTO
+			 * To be called when a RTT (us) has been measured, to update the RTO
 			 * value.
 			 */
-			void ObserveRttMs(uint64_t rttMs);
+			void ObserveRttUs(int64_t rttUs);
 
 			/**
-			 * Returns the Retransmission Timeout (RTO) value.
+			 * Returns the Retransmission Timeout (RTO) value (us).
 			 */
-			uint64_t GetRtoMs() const
+			int64_t GetRtoUs() const
 			{
-				return this->rtoMs;
+				return static_cast<int64_t>(this->rtoUs);
 			}
 
 			/**
-			 * Returns the smoothed RTT value (ms)..
+			 * Returns the smoothed RTT value (us).
+			 *
+			 * @remarks
+			 * - The smoothed RTT is not rounded, so the sub-microsecond part is
+			 *   truncated here.
 			 */
-			uint64_t GetSrttMs() const
+			int64_t GetSrttUs() const
 			{
-				return this->srttMs;
+				return static_cast<int64_t>(this->srttUs);
 			}
 
 		private:
-			uint64_t minRtoMs;
-			uint64_t maxRtoMs;
-			uint64_t maxRttMs;
-			uint64_t minRttVarianceMs;
-			double srttMs;
-			double rtoMs;
-			double rttVarMs{ 0 };
+			int64_t minRtoUs;
+			int64_t maxRtoUs;
+			int64_t maxRttUs;
+			int64_t minRttVarianceUs;
+			double srttUs;
+			double rtoUs;
+			double rttVarUs{ 0 };
 			bool firstMeasurement{ false };
 		};
 	} // namespace SCTP

package/worker/include/RTC/SCTP/tx/RoundRobinSendQueue.hpp

@@ -47,7 +47,7 @@ namespace RTC
 			{
 				bool isUnordered;
 				uint16_t maxRetransmissions;
-				uint64_t expiresAtMs;
+				int64_t expiresAtUs;
 				std::optional<uint64_t> lifecycleId;
 			};
 
@@ -128,7 +128,7 @@ namespace RTC
 
 				// Implementing `StreamScheduler::StreamProducer`.
 
-				std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength) override;
+				std::optional<SendQueueInterface::DataToSend> Produce(int64_t nowUs, size_t maxLength) override;
 
 				size_t GetBytesToSendInNextMessage() const override;
 
@@ -291,12 +291,11 @@ namespace RTC
 
 			/**
 			 * Adds the message to be sent using the `sendMessageOptions` provided.
-			 * The current time should be in `nowMs`. Note that it's the responsibility
+			 * The current time should be in `nowUs`. Note that it's the responsibility
 			 * of the caller to ensure that the buffer is not full (by calling
 			 * `IsFull()`) before adding messages to it.
 			 */
-			void AddMessage(
-			  uint64_t nowMs, Message message, const SendMessageOptions& sendMessageOptions = {});
+			void AddMessage(int64_t nowUs, Message message, const SendMessageOptions& sendMessageOptions = {});
 
 			uint16_t GetStreamPriority(uint16_t streamId) const;
 
@@ -309,7 +308,7 @@ namespace RTC
 				this->scheduler.EnableMessageInterleaving(enabled);
 			}
 
-			std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength) override;
+			std::optional<SendQueueInterface::DataToSend> Produce(int64_t nowUs, size_t maxLength) override;
 
 			bool Discard(uint16_t streamId, uint32_t outgoingMessageId) override;
 

package/worker/include/RTC/SCTP/tx/SendQueueInterface.hpp

@@ -38,7 +38,7 @@ namespace RTC
 				/**
 				 * Time when it expires.
 				 */
-				uint64_t expiresAtMs{ Types::ExpiresAtMsInfinite };
+				int64_t expiresAtUs{ Types::ExpiresAtUsInfinite };
 
 				/**
 				 * Lifecycle. Set for the last fragment and `std::nullopt` for all
@@ -69,7 +69,7 @@ namespace RTC
 			 *   model message prioritization, which is important for any advanced
 			 *   stream scheduler, is further clarified.
 			 */
-			virtual std::optional<DataToSend> Produce(uint64_t nowMs, size_t maxLength) = 0;
+			virtual std::optional<DataToSend> Produce(int64_t nowUs, size_t maxLength) = 0;
 
 			/**
 			 * Discards a partially sent message identified by the parameters `streamId`

package/worker/include/RTC/SCTP/tx/StreamScheduler.hpp

@@ -49,13 +49,13 @@ namespace RTC
 			public:
 				/**
 				 * Produces a fragment of data to send. The current wall time is specified
-				 * as `nowMs` and should be used to skip chunks with expired limited
+				 * as `nowUs` and should be used to skip chunks with expired limited
 				 * lifetime. The parameter `maxLength` specifies the maximum amount of
 				 * actual payload that may be returned. If these constraints prevents the
 				 * stream from sending some data, `std::nullopt` should be returned.
 				 */
 				virtual std::optional<SendQueueInterface::DataToSend> Produce(
-				  uint64_t nowMs, size_t maxLength) = 0;
+				  int64_t nowUs, size_t maxLength) = 0;
 
 				/**
 				 * Returns the number of payload bytes that is scheduled to be sent in the
@@ -123,7 +123,7 @@ namespace RTC
 				 * Produces a message from this stream. This will only be called on
 				 * streams that have data.
 				 */
-				std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+				std::optional<SendQueueInterface::DataToSend> Produce(int64_t nowUs, size_t maxLength);
 
 				void MakeActive(size_t bytesToSendNext);
 
@@ -203,12 +203,12 @@ namespace RTC
 
 			/**
 			 * Produces a fragment of data to send. The current wall time is specified
-			 * as `nowMs` and will be used to skip chunks with expired limited
+			 * as `nowUs` and will be used to skip chunks with expired limited
 			 * lifetime. The parameter `maxLength` specifies the maximum amount of
 			 * actual payload that may be returned. If no data can be produced,
 			 * `std::nullopt` is returned.
 			 */
-			std::optional<SendQueueInterface::DataToSend> Produce(uint64_t nowMs, size_t maxLength);
+			std::optional<SendQueueInterface::DataToSend> Produce(int64_t nowUs, size_t maxLength);
 
 			std::set<uint16_t> GetActiveStreamsForTesting() const;
 

package/worker/include/RTC/SctpDictionaries.hpp

@@ -16,10 +16,10 @@ namespace RTC
 		  flatbuffers::FlatBufferBuilder& builder) const;
 
 	public:
-		uint16_t streamId{ 0u };
+		uint16_t streamId{ 0 };
 		bool ordered{ true };
-		uint16_t maxPacketLifeTime{ 0u };
-		uint16_t maxRetransmits{ 0u };
+		uint16_t maxPacketLifeTime{ 0 };
+		uint16_t maxRetransmits{ 0 };
 	};
 } // namespace RTC