mediasoup 3.27.1 → 3.29.0

package/node/lib/test/test-Producer.js

@@ -536,6 +536,8 @@ test('producer.dump() succeeds', async () => {
     expect(dump1.rtpParameters.encodings[0]).toEqual(expect.objectContaining({
         codecPayloadType: 0,
     }));
+    // No RTP has been received yet, so there are no RTP streams.
+    expect(dump1.rtpStreams).toEqual([]);
     expect(dump1.type).toBe('simple');
     const videoProducer = await ctx.webRtcTransport2.produce(ctx.videoProducerOptions);
     const dump2 = await videoProducer.dump();
@@ -592,8 +594,103 @@ test('producer.dump() succeeds', async () => {
         { codecPayloadType: 112, ssrc: 22222226, rtx: { ssrc: 22222227 } },
         { codecPayloadType: 112, ssrc: 22222228, rtx: { ssrc: 22222229 } },
     ]);
+    // These encodings have no rid, so it must be undefined in rtpMapping.
+    expect(dump2.rtpMapping).toMatchObject({
+        encodings: [
+            { rid: undefined, ssrc: 22222222 },
+            { rid: undefined, ssrc: 22222224 },
+            { rid: undefined, ssrc: 22222226 },
+            { rid: undefined, ssrc: 22222228 },
+        ],
+    });
+    expect(dump2.rtpStreams).toEqual([]);
     expect(dump2.type).toBe('simulcast');
 }, 2000);
+test('producer.dump() exposes rid in rtpMapping.encodings', async () => {
+    const videoProducer = await ctx.webRtcTransport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            mid: 'VIDEO',
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                },
+            ],
+            headerExtensions: [
+                {
+                    uri: 'urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id',
+                    id: 11,
+                },
+            ],
+            encodings: [{ rid: 'r0' }, { rid: 'r1' }, { rid: 'r2' }],
+            rtcp: { cname: 'video-rid' },
+        },
+    });
+    const dump = await videoProducer.dump();
+    expect(dump.type).toBe('simulcast');
+    expect(dump.rtpMapping).toMatchObject({
+        encodings: [
+            { rid: 'r0', ssrc: undefined },
+            { rid: 'r1', ssrc: undefined },
+            { rid: 'r2', ssrc: undefined },
+        ],
+    });
+}, 2000);
+test('producer.dump() exposes rtpStreams once RTP is received', async () => {
+    // RTP packet without extensions or payload.
+    // payloadType: 1, seqNumber: 8, timestamp: 4, ssrc: 5.
+    // prettier-ignore
+    const rtpPacket = Buffer.from([
+        0x80, 0x01, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x05,
+    ]);
+    // A DirectTransport is needed since it's the only one that allows injecting
+    // RTP packets via producer.send().
+    const directTransport = await ctx.router.createDirectTransport();
+    const audioProducer = await directTransport.produce({
+        kind: 'audio',
+        rtpParameters: {
+            mid: 'AUDIO',
+            codecs: [
+                {
+                    mimeType: 'audio/opus',
+                    payloadType: 1,
+                    clockRate: 48000,
+                    channels: 2,
+                },
+            ],
+            encodings: [{ ssrc: 5 }],
+            rtcp: { cname: 'audio-rtp' },
+        },
+    });
+    // No RTP has been received yet, so there are no RTP streams.
+    await expect(audioProducer.dump()).resolves.toMatchObject({
+        rtpStreams: [],
+    });
+    // The worker emits a first 'score' event as soon as it creates the
+    // RtpStreamRecv, which happens upon reception of the first RTP packet.
+    const onScore = (0, enhancedEvents_1.enhancedOnce)(audioProducer, 'score');
+    audioProducer.send(rtpPacket);
+    await onScore;
+    const dump = await audioProducer.dump();
+    expect(dump.rtpStreams.length).toBe(1);
+    expect(typeof dump.rtpStreams[0].score).toBe('number');
+    expect(dump.rtpStreams[0].rtxStream).toBeUndefined();
+    expect(dump.rtpStreams[0].params).toMatchObject({
+        encodingIdx: 0,
+        ssrc: 5,
+        payloadType: 1,
+        mimeType: 'audio/opus',
+        clockRate: 48000,
+        cname: 'audio-rtp',
+        rid: undefined,
+        rtxSsrc: undefined,
+        rtxPayloadType: undefined,
+    });
+}, 2000);
 test('producer.getStats() succeeds', async () => {
     const audioProducer = await ctx.webRtcTransport1.produce(ctx.audioProducerOptions);
     const videoProducer = await ctx.webRtcTransport2.produce(ctx.videoProducerOptions);

package/node/lib/test/test-ortc.js

@@ -174,7 +174,7 @@ test('generateRouterRtpCapabilities() with too many codecs throws', () => {
             channels: 2,
         });
     }
-    expect(() => ortc.generateRouterRtpCapabilities(mediaCodecs)).toThrow('cannot allocate');
+    expect(() => ortc.generateRouterRtpCapabilities(mediaCodecs)).toThrow();
 });
 test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsumerRtpParameters() and getPipeConsumerRtpParameters() succeed', () => {
     const mediaCodecs = [
@@ -377,13 +377,6 @@ test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsum
                 preferredEncrypt: false,
                 direction: 'sendrecv',
             },
-            {
-                kind: 'video',
-                uri: 'urn:ietf:params:rtp-hdrext:toffset',
-                preferredId: 9,
-                preferredEncrypt: false,
-                direction: 'sendrecv',
-            },
         ],
     };
     const consumerRtpParameters = ortc.getConsumerRtpParameters({
@@ -436,12 +429,6 @@ test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsum
             encrypt: false,
             parameters: {},
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            encrypt: false,
-            parameters: {},
-        },
     ]);
     expect(consumerRtpParameters.rtcp).toEqual({
         cname: rtpParameters.rtcp?.cname,
@@ -523,3 +510,36 @@ test('getProducerRtpParametersMapping() with incompatible params throws Unsuppor
     };
     expect(() => ortc.getProducerRtpParametersMapping(rtpParameters, routerRtpCapabilities)).toThrow(errors_1.UnsupportedError);
 });
+test('getProducerRtpParametersMapping() with RTX apt pointing to a non media codec throws', () => {
+    const mediaCodecs = [
+        {
+            kind: 'video',
+            mimeType: 'video/VP8',
+            clockRate: 90000,
+        },
+    ];
+    const routerRtpCapabilities = ortc.generateRouterRtpCapabilities(mediaCodecs);
+    // The apt parameter of the RTX codec is its own payload type, which is not a
+    // media codec.
+    const rtpParameters = {
+        codecs: [
+            {
+                mimeType: 'video/VP8',
+                payloadType: 111,
+                clockRate: 90000,
+            },
+            {
+                mimeType: 'video/rtx',
+                payloadType: 112,
+                clockRate: 90000,
+                parameters: { apt: 112 },
+            },
+        ],
+        headerExtensions: [],
+        encodings: [{ ssrc: 11111111 }],
+        rtcp: {
+            cname: 'qwerty1234',
+        },
+    };
+    expect(() => ortc.getProducerRtpParametersMapping(rtpParameters, routerRtpCapabilities)).toThrow(TypeError);
+});

package/npm-scripts.mjs

@@ -566,18 +566,6 @@ function publishDryRun() {
 async function checkRelease() {
 	logInfo('checkRelease()');
 
-	// Verify that CHANGELOG.md has an entry for the new version (and grab its
-	// changes, used as the GitHub release body) before the slow build steps.
-	let versionChanges;
-
-	try {
-		versionChanges = await getVersionChanges();
-	} catch (error) {
-		logError(`checkRelease() | ${error.message}`);
-
-		exitWithError();
-	}
-
 	installNodeDeps();
 	await flatcNode({ force: true });
 	buildTypescript({ force: true });
@@ -589,8 +577,6 @@ async function checkRelease() {
 	// Validate packaging (the `files` list in package.json) before the
 	// irreversible release steps (git push, GitHub release, npm publish).
 	publishDryRun();
-
-	return { versionChanges };
 }
 
 async function release({ args = '' } = {}) {
@@ -622,8 +608,17 @@ async function release({ args = '' } = {}) {
 	// Clean working tree required before bumping the version.
 	checkGitClean();
 
-	// Lint, test, build, publish dry-run, and verify the CHANGELOG entry (of the
-	// previous version still in package.json, which is harmless).
+	// CHANGELOG.md must have unreleased changes in its "### NEXT" section.
+	// Checked before the slow build steps.
+	try {
+		await checkChangelog();
+	} catch (error) {
+		logError(`release() | ${error.message}`);
+
+		exitWithError();
+	}
+
+	// Lint, test, build and publish dry-run.
 	await checkRelease();
 
 	// Bump the version in package.json + package-lock.json and in CHANGELOG.md.
@@ -834,46 +829,42 @@ function checkGitClean() {
 	}
 }
 
-async function getVersionChanges() {
-	logInfo('getVersionChanges()');
+/**
+ * Verifies that the first section of CHANGELOG.md is "### NEXT" and that it is
+ * not empty.
+ */
+async function checkChangelog() {
+	logInfo('checkChangelog()');
 
 	// NOTE: Load dep on demand since it's a devDependency.
 	const marked = await import('marked');
 
 	const changelog = fs.readFileSync('./CHANGELOG.md', { encoding: 'utf-8' });
-	const entries = marked.lexer(changelog);
-
-	for (let idx = 0; idx < entries.length; ++idx) {
-		const entry = entries[idx];
-
-		if (entry.type === 'heading' && entry.text === pkg.version) {
-			// Collect every token after the matching heading until the next heading.
-			// NOTE: We cannot just use `entries[idx + 1].raw` because `marked`
-			// inserts a `space` token between the heading and its content.
-			let changes = '';
-
-			for (let next = idx + 1; next < entries.length; ++next) {
-				if (entries[next].type === 'heading') {
-					break;
-				}
-
-				changes += entries[next].raw;
-			}
+	const tokens = marked.lexer(changelog);
+	const idx = tokens.findIndex(
+		token => token.type === 'heading' && token.depth === 3
+	);
 
-			changes = changes.trim();
+	if (idx === -1 || tokens[idx].text !== 'NEXT') {
+		throw new Error("first section in CHANGELOG.md is not '### NEXT'");
+	}
 
-			if (changes) {
-				return changes;
-			}
+	// Collect every token after the "### NEXT" heading until the next heading.
+	// NOTE: We cannot just use `tokens[idx + 1].raw` because `marked` inserts a
+	// `space` token between the heading and its content.
+	let changes = '';
 
+	for (let next = idx + 1; next < tokens.length; ++next) {
+		if (tokens[next].type === 'heading') {
 			break;
 		}
+
+		changes += tokens[next].raw;
 	}
 
-	// This should not happen (unless author forgot to update CHANGELOG).
-	throw new Error(
-		`no entry found in CHANGELOG.md for version '${pkg.version}'`
-	);
+	if (!changes.trim()) {
+		throw new Error("'### NEXT' section in CHANGELOG.md is empty");
+	}
 }
 
 async function updateChangelog(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.27.1",
+	"version": "3.29.0",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -121,22 +121,26 @@
 		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^26.5.1",
-		"eslint": "^10.10.0",
+		"@types/node": "^26.6.4",
+		"eslint": "^10.12.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.16.6",
 		"eslint-plugin-prettier": "^5.5.6",
-		"globals": "^17.12.0",
+		"globals": "^17.13.0",
 		"ini": "^7.0.0",
-		"jest": "^30.5.1",
-		"knip": "^6.35.1",
-		"marked": "^18.0.13",
+		"jest": "^30.5.2",
+		"knip": "^6.40.0",
+		"marked": "^18.1.0",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.1",
-		"prettier": "^3.9.6",
-		"ts-jest": "^29.4.12",
+		"prettier": "^3.9.9",
+		"ts-jest": "^29.4.14",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.70.0",
+		"typescript-eslint": "^8.71.1",
 		"werift-sctp": "^0.0.11"
+	},
+	"allowScripts": {
+		"@parcel/watcher@2.6.0": true,
+		"unrs-resolver@1.12.2": true
 	}
 }

package/worker/fbs/rtpParameters.fbs

@@ -70,7 +70,6 @@ enum RtpHeaderExtensionUri: uint8 {
     SsrcAudioLevel,
     DependencyDescriptor,
     VideoOrientation,
-    TimeOffset,
     AbsCaptureTime,
     PlayoutDelay,
     MediasoupPacketId,

package/worker/fbs/transport.fbs

@@ -121,6 +121,14 @@ table RecvRtpHeaderExtensions {
     transport_wide_cc01: uint8 = null;
 }
 
+// Values match the SCTP Zero Checksum Alternate Error Detection Method
+// Identifiers (EDMID).
+enum SctpZeroChecksum: uint32 {
+    NONE = 0,
+    SCTP_OVER_DTLS = 1,
+    TRUSTED_NETWORK = 4294967294
+}
+
 table Options {
     direct: bool = false;
     initial_available_outgoing_bitrate: uint64 = null;
@@ -131,6 +139,7 @@ table Options {
     sctp_per_stream_send_queue_limit: uint32;
     sctp_max_receiver_window_buffer_size: uint32;
     sctp_default_stream_buffered_amount_low_threshold: uint32;
+    sctp_zero_checksum: SctpZeroChecksum = NONE;
     is_data_channel: bool = false;
 }
 
@@ -182,8 +191,6 @@ table Stats {
     max_incoming_bitrate: uint64 = null;
     max_outgoing_bitrate: uint64 = null;
     min_outgoing_bitrate: uint64 = null;
-    rtp_packet_loss_received: float64 = null;
-    rtp_packet_loss_sent: float64 = null;
 }
 
 table SetMaxIncomingBitrateRequest {

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -92,10 +92,12 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 
 	/* Time class. */
 
-	auto ntp = Utils::Time::TimeUs2Ntp(static_cast<int64_t>(len));
+	auto ntp = Utils::Time::TimeUsToNtp(static_cast<int64_t>(len));
 
-	Utils::Time::Ntp2TimeUs(ntp);
+	Utils::Time::NtpToTimeUs(ntp);
+	Utils::Time::CompactNtpIntervalToTimeUs(static_cast<uint32_t>(len));
+	Utils::Time::CompactNtpRttToTimeUs(static_cast<uint32_t>(len));
 	Utils::Time::TimeUsToAbsSendTime(static_cast<int64_t>(len));
 	Utils::Time::Q32x32ToTimeUs(static_cast<int64_t>(len));
-	Utils::Time::TimeUs2Q32x32(static_cast<int64_t>(len));
+	Utils::Time::TimeUsToQ32x32(static_cast<int64_t>(len));
 }

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

@@ -2,6 +2,7 @@
 #include "RTC/RTP/HeaderExtensionIds.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "Utils.hpp"
 #include <string>
 #include <vector>
 
@@ -35,6 +36,8 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	bool flip;
 	uint16_t rotation;
 	uint32_t absSendTime;
+	uint64_t absCaptureTimestamp;
+	int64_t estimatedCaptureClockOffset;
 	uint16_t playoutDelayMinDelay;
 	uint16_t playoutDelayMaxDelay;
 	uint16_t wideSeqNumber;
@@ -76,6 +79,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	headerExtensionIds.ssrcAudioLevel    = 1;
 	headerExtensionIds.videoOrientation  = 2;
 	headerExtensionIds.playoutDelay      = 8;
+	headerExtensionIds.absCaptureTime    = 9;
 
 	packet->AssignExtensionIds(headerExtensionIds);
 
@@ -91,7 +95,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->HasExtension(3);
 	packet->GetExtensionValue(3, extenLen);
 	packet->ReadAbsSendTime(absSendTime);
-	packet->UpdateAbsSendTime(12345678);
+	packet->UpdateAbsSendTime(Utils::Time::TimeUsToAbsSendTime(12345678));
 
 	packet->HasExtension(4);
 	packet->GetExtensionValue(4, extenLen);
@@ -110,6 +114,11 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->GetExtensionValue(8, extenLen);
 	packet->ReadPlayoutDelay(playoutDelayMinDelay, playoutDelayMaxDelay);
 
+	packet->HasExtension(9);
+	packet->GetExtensionValue(9, extenLen);
+	packet->ReadAbsCaptureTime(absCaptureTimestamp, estimatedCaptureClockOffset);
+	packet->UpdateAbsCaptureTime(12345678);
+
 	packet->HasExtension(6);
 	packet->HasExtension(7);
 	packet->HasExtension(8);
@@ -189,7 +198,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->HasExtension(13);
 	packet->GetExtensionValue(13, extenLen);
 	packet->ReadAbsSendTime(absSendTime);
-	packet->UpdateAbsSendTime(12345678);
+	packet->UpdateAbsSendTime(Utils::Time::TimeUsToAbsSendTime(12345678));
 
 	packet->HasExtension(14);
 	packet->GetExtensionValue(14, extenLen);
@@ -208,6 +217,11 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	packet->GetExtensionValue(15, extenLen);
 	packet->ReadPlayoutDelay(playoutDelayMinDelay, playoutDelayMaxDelay);
 
+	packet->HasExtension(16);
+	packet->GetExtensionValue(16, extenLen);
+	packet->ReadAbsCaptureTime(absCaptureTimestamp, estimatedCaptureClockOffset);
+	packet->UpdateAbsCaptureTime(12345678);
+
 	packet->HasPayload();
 	packet->GetPayload();
 	packet->GetPayloadLength();

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

@@ -1,4 +1,5 @@
 #include "RTC/RTP/FuzzerRetransmissionBuffer.hpp"
+#include "DepLibUV.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RetransmissionBuffer.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
@@ -26,6 +27,7 @@ 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{ 0 };
+	int64_t nowMs = DepLibUV::GetTimeMs();
 
 	while (len >= 4)
 	{
@@ -35,7 +37,18 @@ void FuzzerRtcRtpRetransmissionBuffer::Fuzz(const uint8_t* data, size_t len)
 		packet->SetSequenceNumber(Utils::Byte::Get2Bytes(data, offset));
 		packet->SetTimestamp(Utils::Byte::Get4Bytes(data, offset));
 
-		retransmissionBuffer.Insert(packet, sharedPacket);
+		retransmissionBuffer.Insert(packet, sharedPacket, nowMs);
+
+		// Let some 'random' time pass and check whether the packet is too old.
+		nowMs += static_cast<int64_t>(Utils::Crypto::GetRandomUInt<uint64_t>(0, 1000));
+
+		const RTC::RTP::RetransmissionBuffer::Item* const item =
+		  retransmissionBuffer.Get(packet->GetSequenceNumber());
+
+		if (item)
+		{
+			retransmissionBuffer.IsTooOld(item, nowMs);
+		}
 
 		len -= 4;
 		offset += 4;

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

@@ -1,4 +1,5 @@
 #include "RTC/RTP/FuzzerRtpStreamSend.hpp"
+#include "RTC/RTCP/ReceiverReport.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
 #include "Utils.hpp"
 #include "mocks/include/MockShared.hpp"
@@ -45,18 +46,30 @@ void FuzzerRtcRtpStreamSend::Fuzz(const uint8_t* data, size_t len)
 	  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 	size_t offset{ 0u };
 
-	while (len >= 4u)
+	while (len >= 12)
 	{
 		const RTC::RTP::SharedPacket sharedPacket;
 
 		// Set 'random' sequence number and timestamp.
 		packet->SetSequenceNumber(Utils::Byte::Get2Bytes(data, offset));
-		packet->SetTimestamp(Utils::Byte::Get4Bytes(data, offset));
+		packet->SetTimestamp(Utils::Byte::Get4Bytes(data, offset + 2));
 
 		stream->ReceivePacket(packet, sharedPacket);
 
-		len -= 4u;
-		offset += 4;
+		// Feed a 'random' Receiver Report, which is what the loss of the stream is
+		// worked out from.
+		RTC::RTCP::ReceiverReport report;
+
+		report.SetSsrc(params.ssrc);
+		report.SetLastSeq(Utils::Byte::Get4Bytes(data, offset + 6));
+		// NOTE: Signed on purpose, since a duplicate makes a remote endpoint report
+		// fewer packets lost than it reported before.
+		report.SetTotalLost(static_cast<int16_t>(Utils::Byte::Get2Bytes(data, offset + 10)));
+
+		stream->ReceiveRtcpReceiverReport(std::addressof(report), shared.GetTimeUs());
+
+		len -= 12;
+		offset += 12;
 	}
 
 	delete stream;

package/worker/include/DepLibUV.hpp

@@ -36,6 +36,19 @@ public:
 		return static_cast<int64_t>(uv_hrtime() / 1000);
 	}
 
+	/**
+	 * Time at which the current iteration of the event loop began (ms).
+	 *
+	 * @remarks
+	 * - It is taken once per iteration and cached, so every caller within the same one
+	 *   gets the very same value no matter how long the iteration takes. That is what
+	 *   tells two iterations apart, which the clocks above cannot do.
+	 */
+	static uint64_t GetLoopTimeMs()
+	{
+		return uv_now(DepLibUV::GetLoop());
+	}
+
 	/**
 	 * Offset between our own monotonic clock and the NTP epoch (us).
 	 *

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

@@ -90,11 +90,11 @@ namespace RTC
 			 * 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.
+			 * @param nowUs - Current time.
 			 *
 			 * @returns The new target bitrate (bps).
 			 */
-			int64_t Update(const Types::RateControlInput& input, int64_t atTimeUs);
+			int64_t Update(const Types::RateControlInput& input, int64_t nowUs);
 
 			/**
 			 * Set the target bitrate from outside the rate control, for instance out of
@@ -102,7 +102,7 @@ namespace RTC
 			 *
 			 * @param bitrate - New target bitrate (bps).
 			 */
-			void SetEstimate(int64_t bitrate, int64_t atTimeUs);
+			void SetEstimate(int64_t bitrate, int64_t nowUs);
 
 			/**
 			 * @param startBitrate - Bitrate to start from (bps).
@@ -126,13 +126,13 @@ namespace RTC
 			 * 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;
+			bool IsTimeToReduceFurther(int64_t nowUs, int64_t estimatedThroughput) const;
 
 			/**
 			 * As above, to be used when overusing before any throughput has been
 			 * measured.
 			 */
-			bool IsInitialTimeToReduceFurther(int64_t atTimeUs) const;
+			bool IsInitialTimeToReduceFurther(int64_t nowUs) const;
 
 			/**
 			 * Rate at which the bitrate is increased once it's close to the capacity of
@@ -147,9 +147,9 @@ namespace RTC
 			int64_t GetFeedbackIntervalUs() const;
 
 		private:
-			void ChangeBitrate(const Types::RateControlInput& input, int64_t atTimeUs);
+			void ChangeBitrate(const Types::RateControlInput& input, int64_t nowUs);
 
-			void ChangeState(const Types::RateControlInput& input, int64_t atTimeUs);
+			void ChangeState(const Types::RateControlInput& input, int64_t nowUs);
 
 			/**
 			 * Apply the configured bounds to a candidate bitrate.
@@ -161,13 +161,13 @@ namespace RTC
 			 * fast to discover it.
 			 */
 			int64_t MultiplicativeRateIncrease(
-			  int64_t atTimeUs, std::optional<int64_t> lastTimeUs, int64_t currentBitrate) const;
+			  int64_t nowUs, 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;
+			int64_t AdditiveRateIncrease(int64_t nowUs, int64_t lastTimeUs) const;
 
 		private:
 			const AimdRateControlOptions options;