Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

fix: report interval media processing cost

AAAbe00ca84a028
diff --git a/src/client/components/StatsGrid.tsx b/src/client/components/StatsGrid.tsx
index 2a0ece9f..8ed61c7f 100644
--- a/src/client/components/StatsGrid.tsx
+++ b/src/client/components/StatsGrid.tsx
@@ -78,8 +78,8 @@ export function StatsGrid({
<>
<Metric label="编码器" value={encoder} />
<Metric
- label="平均编码"
- value={`${readableNumber(metrics.averageEncodeMs, 1)} ms`}
+ label="最近区间编码/帧"
+ value={`${readableNumber(metrics.intervalEncodeMs, 1)} ms`}
/>
<Metric label="质量状态" value={qualityReason(metrics.qualityLimitationReason)} />
</>
@@ -87,8 +87,8 @@ export function StatsGrid({
<>
<Metric label="丢帧" value={readableNumber(metrics.framesDropped)} />
<Metric
- label="平均解码"
- value={`${readableNumber(metrics.averageDecodeMs, 1)} ms`}
+ label="最近区间解码/帧"
+ value={`${readableNumber(metrics.intervalDecodeMs, 1)} ms`}
/>
</>
)}
diff --git a/src/client/types.ts b/src/client/types.ts
index 8ebfb318..5269cc38 100644
--- a/src/client/types.ts
+++ b/src/client/types.ts
@@ -23,8 +23,8 @@ export interface ConnectionMetrics {
codec: string | null;
encoderImplementation: string | null;
powerEfficientEncoder: boolean | null;
- averageEncodeMs: number | null;
- averageDecodeMs: number | null;
+ intervalEncodeMs: number | null;
+ intervalDecodeMs: number | null;
qualityLimitationReason: string | null;
}
@@ -54,7 +54,7 @@ export const EMPTY_METRICS: ConnectionMetrics = {
codec: null,
encoderImplementation: null,
powerEfficientEncoder: null,
- averageEncodeMs: null,
- averageDecodeMs: null,
+ intervalEncodeMs: null,
+ intervalDecodeMs: null,
qualityLimitationReason: null,
};
diff --git a/src/client/webrtc/host-peer.ts b/src/client/webrtc/host-peer.ts
index 60f83c66..6fabc948 100644
--- a/src/client/webrtc/host-peer.ts
+++ b/src/client/webrtc/host-peer.ts
@@ -27,10 +27,11 @@ export class HostPeer {
private readonly connection: RTCPeerConnection;
private readonly pendingCandidates: SignalCandidate[] = [];
- private readonly statsAccumulator = createStatsAccumulator();
+ private statsAccumulator = createStatsAccumulator();
private videoSender: RTCRtpSender | null = null;
private audioSender: RTCRtpSender | null = null;
private statsTimer: number | null = null;
+ private statsInFlight = false;
private disposed = false;
private negotiating = false;
private senderMutationTail: Promise<void> = Promise.resolve();
@@ -127,9 +128,7 @@ export class HostPeer {
return false;
}
this.stream = nextStream;
- this.statsAccumulator.bytes = null;
- this.statsAccumulator.frames = null;
- this.statsAccumulator.timestamp = null;
+ this.statsAccumulator = createStatsAccumulator();
try {
await configureVideoSender(videoSender, this.desiredProfile);
} catch (error) {
@@ -160,9 +159,7 @@ export class HostPeer {
if (this.disposed) {
return false;
}
- this.statsAccumulator.bytes = null;
- this.statsAccumulator.frames = null;
- this.statsAccumulator.timestamp = null;
+ this.statsAccumulator = createStatsAccumulator();
this.snapshot = { ...this.snapshot, error: null };
this.emit();
return true;
@@ -310,19 +307,30 @@ export class HostPeer {
}
private async updateStats(): Promise<void> {
- if (this.disposed || this.connection.connectionState === "closed") {
+ if (
+ this.disposed ||
+ this.connection.connectionState === "closed" ||
+ this.statsInFlight
+ ) {
return;
}
+ this.statsInFlight = true;
+ const statsAccumulator = this.statsAccumulator;
try {
const metrics = await collectConnectionMetrics(
this.connection,
"send",
- this.statsAccumulator,
+ statsAccumulator,
);
+ if (this.disposed || this.statsAccumulator !== statsAccumulator) {
+ return;
+ }
this.snapshot = { ...this.snapshot, metrics };
this.emit();
} catch {
// Stats are observational and must never disrupt a healthy media path.
+ } finally {
+ this.statsInFlight = false;
}
}
diff --git a/src/client/webrtc/stats.ts b/src/client/webrtc/stats.ts
index d8bd2bdd..3609aa08 100644
--- a/src/client/webrtc/stats.ts
+++ b/src/client/webrtc/stats.ts
@@ -10,13 +10,45 @@ type StatsRecord = Record<string, unknown> & {
};
export interface StatsAccumulator {
+ mediaId: string | null;
bytes: number | null;
frames: number | null;
timestamp: number | null;
+ previousTotalEncodeTime: number | null;
+ previousTotalDecodeTime: number | null;
}
export function createStatsAccumulator(): StatsAccumulator {
- return { bytes: null, frames: null, timestamp: null };
+ return {
+ mediaId: null,
+ bytes: null,
+ frames: null,
+ timestamp: null,
+ previousTotalEncodeTime: null,
+ previousTotalDecodeTime: null,
+ };
+}
+
+function intervalAverageMs(
+ totalTime: number | null,
+ previousTotalTime: number | null,
+ frames: number | null,
+ previousFrames: number | null,
+): number | null {
+ if (
+ totalTime === null ||
+ previousTotalTime === null ||
+ frames === null ||
+ previousFrames === null
+ ) {
+ return null;
+ }
+
+ const frameDelta = frames - previousFrames;
+ const timeDelta = totalTime - previousTotalTime;
+ return frameDelta > 0 && timeDelta >= 0
+ ? (timeDelta / frameDelta) * 1_000
+ : null;
}
function numberValue(record: StatsRecord | null, key: string): number | null {
@@ -121,39 +153,67 @@ export async function collectConnectionMetrics(
: "unknown";
const media = mediaRecord(report, direction);
+ const mediaId = media?.id ?? null;
+ const sameMedia = mediaId !== null && mediaId === previous.mediaId;
const remoteInbound = direction === "send" ? remoteInboundVideo(report) : null;
const bytesKey = direction === "send" ? "bytesSent" : "bytesReceived";
const bytes = numberValue(media, bytesKey);
const framesKey = direction === "send" ? "framesEncoded" : "framesDecoded";
const frames = numberValue(media, framesKey);
const timestamp = media?.timestamp ?? null;
+ const framesEncoded = numberValue(media, "framesEncoded");
+ const framesDecoded = numberValue(media, "framesDecoded");
+ const totalEncodeTime = numberValue(media, "totalEncodeTime");
+ const totalDecodeTime = numberValue(media, "totalDecodeTime");
let bitrateKbps: number | null = null;
let derivedFps: number | null = null;
if (
- bytes !== null &&
+ sameMedia &&
timestamp !== null &&
- previous.bytes !== null &&
previous.timestamp !== null &&
timestamp > previous.timestamp
) {
const elapsedSeconds = (timestamp - previous.timestamp) / 1_000;
- bitrateKbps = ((bytes - previous.bytes) * 8) / elapsedSeconds / 1_000;
- if (frames !== null && previous.frames !== null) {
+ if (bytes !== null && previous.bytes !== null && bytes >= previous.bytes) {
+ bitrateKbps = ((bytes - previous.bytes) * 8) / elapsedSeconds / 1_000;
+ }
+ if (
+ frames !== null &&
+ previous.frames !== null &&
+ frames >= previous.frames
+ ) {
derivedFps = (frames - previous.frames) / elapsedSeconds;
}
}
+ const intervalEncodeMs =
+ direction === "send"
+ ? intervalAverageMs(
+ totalEncodeTime,
+ sameMedia ? previous.previousTotalEncodeTime : null,
+ framesEncoded,
+ sameMedia ? previous.frames : null,
+ )
+ : null;
+ const intervalDecodeMs =
+ direction === "receive"
+ ? intervalAverageMs(
+ totalDecodeTime,
+ sameMedia ? previous.previousTotalDecodeTime : null,
+ framesDecoded,
+ sameMedia ? previous.frames : null,
+ )
+ : null;
+ previous.mediaId = mediaId;
previous.bytes = bytes;
previous.frames = frames;
previous.timestamp = timestamp;
+ previous.previousTotalEncodeTime = totalEncodeTime;
+ previous.previousTotalDecodeTime = totalDecodeTime;
const codec = getRecord(report, stringValue(media, "codecId"));
const width = numberValue(media, "frameWidth");
const height = numberValue(media, "frameHeight");
- const framesEncoded = numberValue(media, "framesEncoded");
- const framesDecoded = numberValue(media, "framesDecoded");
- const totalEncodeTime = numberValue(media, "totalEncodeTime");
- const totalDecodeTime = numberValue(media, "totalDecodeTime");
const iceProtocol =
stringValue(localCandidate, "protocol") ??
stringValue(remoteCandidate, "protocol");
@@ -191,14 +251,8 @@ export async function collectConnectionMetrics(
codec: stringValue(codec, "mimeType"),
encoderImplementation: stringValue(media, "encoderImplementation"),
powerEfficientEncoder: booleanValue(media, "powerEfficientEncoder"),
- averageEncodeMs:
- framesEncoded && totalEncodeTime !== null
- ? (totalEncodeTime / framesEncoded) * 1_000
- : null,
- averageDecodeMs:
- framesDecoded && totalDecodeTime !== null
- ? (totalDecodeTime / framesDecoded) * 1_000
- : null,
+ intervalEncodeMs,
+ intervalDecodeMs,
qualityLimitationReason: stringValue(media, "qualityLimitationReason"),
};
}
diff --git a/src/client/webrtc/viewer-peer.ts b/src/client/webrtc/viewer-peer.ts
index d3ab443a..b24a34dc 100644
--- a/src/client/webrtc/viewer-peer.ts
+++ b/src/client/webrtc/viewer-peer.ts
@@ -37,6 +37,7 @@ export class ViewerPeer {
>();
private statsAccumulator: StatsAccumulator = createStatsAccumulator();
private statsTimer: number | null = null;
+ private statsInFlightConnection: RTCPeerConnection | null = null;
private disconnectTimer: number | null = null;
private restartRequested = false;
private offerRecoveryAttempts = 0;
@@ -346,6 +347,10 @@ export class ViewerPeer {
if (!this.isCurrentConnection(connection, connectionId)) {
return;
}
+ if (this.statsInFlightConnection === connection) {
+ return;
+ }
+ this.statsInFlightConnection = connection;
const statsAccumulator = this.statsAccumulator;
try {
const metrics = await collectConnectionMetrics(
@@ -362,6 +367,10 @@ export class ViewerPeer {
}
} catch {
// Stats are observational and must never disrupt a healthy media path.
+ } finally {
+ if (this.statsInFlightConnection === connection) {
+ this.statsInFlightConnection = null;
+ }
}
}
diff --git a/tests/client-state.test.ts b/tests/client-state.test.ts
index 3f34f4a5..841d4eb8 100644
--- a/tests/client-state.test.ts
+++ b/tests/client-state.test.ts
@@ -323,23 +323,42 @@ describe("WebRTC stats parsing", () => {
},
],
]);
+ const secondReport = new Map(report);
+ secondReport.set("inbound", {
+ id: "inbound",
+ type: "inbound-rtp",
+ timestamp: 4_000,
+ kind: "video",
+ bytesReceived: 4_000,
+ framesDecoded: 150,
+ totalDecodeTime: 1.5,
+ });
+ const reports = [report, secondReport];
const connection = {
- getStats: async () => report as unknown as RTCStatsReport,
+ getStats: async () =>
+ reports.shift() as unknown as RTCStatsReport,
} as unknown as RTCPeerConnection;
+ const accumulator = createStatsAccumulator();
+ const firstMetrics = await collectConnectionMetrics(
+ connection,
+ "receive",
+ accumulator,
+ );
const metrics = await collectConnectionMetrics(
connection,
"receive",
- createStatsAccumulator(),
+ accumulator,
);
+ expect(firstMetrics.intervalDecodeMs).toBeNull();
expect(metrics).toMatchObject({
path: "relay",
iceProtocol: "udp",
localRelayProtocol: "tls",
localCandidateType: "relay",
remoteCandidateType: "host",
- averageDecodeMs: 5,
+ intervalDecodeMs: 20,
});
});
@@ -405,4 +424,82 @@ describe("WebRTC stats parsing", () => {
remoteCandidateType: "relay",
});
});
+
+ it("rebases interval metrics when the RTP stream or its counters reset", async () => {
+ const inbound = (
+ id: string,
+ timestamp: number,
+ bytesReceived: number,
+ framesDecoded: number,
+ totalDecodeTime: number,
+ ) =>
+ new Map<string, unknown>([
+ [
+ id,
+ {
+ id,
+ type: "inbound-rtp",
+ timestamp,
+ kind: "video",
+ bytesReceived,
+ framesDecoded,
+ totalDecodeTime,
+ },
+ ],
+ ]) as unknown as RTCStatsReport;
+ const reports = [
+ inbound("inbound-a", 1_000, 10_000, 100, 0.5),
+ inbound("inbound-b", 2_000, 20_000, 150, 1.5),
+ inbound("inbound-b", 3_000, 22_000, 160, 1.7),
+ inbound("inbound-b", 4_000, 1_000, 10, 0.1),
+ inbound("inbound-b", 5_000, 3_000, 20, 0.3),
+ ];
+ const connection = {
+ getStats: async () => reports.shift()!,
+ } as unknown as RTCPeerConnection;
+ const accumulator = createStatsAccumulator();
+
+ await collectConnectionMetrics(connection, "receive", accumulator);
+ const streamChanged = await collectConnectionMetrics(
+ connection,
+ "receive",
+ accumulator,
+ );
+ const afterStreamChange = await collectConnectionMetrics(
+ connection,
+ "receive",
+ accumulator,
+ );
+ const countersReset = await collectConnectionMetrics(
+ connection,
+ "receive",
+ accumulator,
+ );
+ const afterCounterReset = await collectConnectionMetrics(
+ connection,
+ "receive",
+ accumulator,
+ );
+
+ expect(streamChanged).toMatchObject({
+ bitrateKbps: null,
+ framesPerSecond: null,
+ intervalDecodeMs: null,
+ });
+ expect(afterStreamChange).toMatchObject({
+ bitrateKbps: 16,
+ framesPerSecond: 10,
+ });
+ expect(afterStreamChange.intervalDecodeMs).toBeCloseTo(20);
+ expect(countersReset).toMatchObject({
+ bitrateKbps: null,
+ framesPerSecond: null,
+ intervalDecodeMs: null,
+ });
+ expect(afterCounterReset).toMatchObject({
+ bitrateKbps: 16,
+ framesPerSecond: 10,
+ });
+ expect(afterCounterReset.intervalDecodeMs).toBeCloseTo(20);
+ });
});
diff --git a/tests/host-peer-tracks.test.ts b/tests/host-peer-tracks.test.ts
index 0c393920..afc738f3 100644
--- a/tests/host-peer-tracks.test.ts
+++ b/tests/host-peer-tracks.test.ts
@@ -1,6 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { QUALITY_PROFILES } from "../src/client/media/quality.ts";
+import type { PeerSnapshot } from "../src/client/types.ts";
import { HostPeer } from "../src/client/webrtc/host-peer.ts";
import { ViewerRelay } from "../src/client/webrtc/viewer-relay.ts";
@@ -95,9 +96,9 @@ class FakePeerConnection {
this.localDescription = description as RTCSessionDescription;
}
- async getStats(): Promise<RTCStatsReport> {
- return await (this.statsReports.shift() ?? emptyStatsReport());
- }
+ readonly getStats = vi.fn(async (): Promise<RTCStatsReport> =>
+ await (this.statsReports.shift() ?? emptyStatsReport())
+ );
close(): void {
this.connectionState = "closed";
@@ -112,11 +113,13 @@ function sendStatsReport({
bytesSent,
framesEncoded,
timestamp,
+ totalEncodeTime,
qualityLimitationReason,
}: {
bytesSent: number;
framesEncoded: number;
timestamp: number;
+ totalEncodeTime?: number;
qualityLimitationReason: string;
}): RTCStatsReport {
return new Map<string, Record<string, unknown>>([
@@ -175,7 +178,7 @@ function sendStatsReport({
framesPerSecond: 30,
frameWidth: 1280,
frameHeight: 720,
- totalEncodeTime: framesEncoded * 0.005,
+ totalEncodeTime: totalEncodeTime ?? framesEncoded * 0.005,
qualityLimitationReason,
encoderImplementation: "test-encoder",
codecId: "codec",
@@ -209,7 +212,10 @@ function createStream(
} as unknown as MediaStream;
}
-function createPeer(stream: MediaStream): HostPeer {
+function createPeer(
+ stream: MediaStream,
+ onUpdate: (snapshot: PeerSnapshot) => void = () => undefined,
+): HostPeer {
return new HostPeer(
"viewer-peer",
{ iceServers: [], expiresAt: null, relayAvailable: false },
@@ -217,7 +223,7 @@ function createPeer(stream: MediaStream): HostPeer {
QUALITY_PROFILES["720p30"],
{
sendSignal: () => true,
- onUpdate: () => undefined,
+ onUpdate,
},
);
}
@@ -405,6 +411,79 @@ describe("HostPeer source replacement", () => {
});
});
+ it("discards an in-flight stats sample after a profile reset", async () => {
+ let resolveOldStats!: (report: RTCStatsReport) => void;
+ const oldStats = new Promise<RTCStatsReport>((resolve) => {
+ resolveOldStats = resolve;
+ });
+ const updates: PeerSnapshot[] = [];
+ const peer = createPeer(
+ createStream(createTrack("video", "video"), null),
+ (snapshot) => updates.push(snapshot),
+ );
+
+ await expect(peer.start()).resolves.toBe(true);
+ const connection = FakePeerConnection.latest!;
+ connection.statsReports.push(oldStats);
+ statsCallbacks[0]!();
+ await vi.waitFor(() => expect(connection.statsReports).toHaveLength(0));
+ statsCallbacks[0]!();
+ expect(connection.getStats).toHaveBeenCalledOnce();
+
+ await expect(
+ peer.updateProfile(QUALITY_PROFILES["1080p60"]),
+ ).resolves.toBe(true);
+ resolveOldStats(
+ sendStatsReport({
+ bytesSent: 1_000_000,
+ framesEncoded: 30,
+ timestamp: 1_000,
+ totalEncodeTime: 0.15,
+ qualityLimitationReason: "cpu",
+ }),
+ );
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(
+ updates.some(
+ ({ metrics }) => metrics.qualityLimitationReason === "cpu",
+ ),
+ ).toBe(false);
+
+ connection.statsReports.push(
+ sendStatsReport({
+ bytesSent: 2_000_000,
+ framesEncoded: 60,
+ timestamp: 2_000,
+ totalEncodeTime: 0.3,
+ qualityLimitationReason: "bandwidth",
+ }),
+ sendStatsReport({
+ bytesSent: 2_500_000,
+ framesEncoded: 90,
+ timestamp: 3_000,
+ totalEncodeTime: 0.9,
+ qualityLimitationReason: "bandwidth",
+ }),
+ );
+ statsCallbacks[0]!();
+ await vi.waitFor(() =>
+ expect(updates.at(-1)?.metrics.qualityLimitationReason).toBe(
+ "bandwidth",
+ ),
+ );
+ expect(updates.at(-1)?.metrics.intervalEncodeMs).toBeNull();
+
+ statsCallbacks[0]!();
+ await vi.waitFor(() =>
+ expect(updates.at(-1)?.metrics.intervalEncodeMs).toBeCloseTo(20),
+ );
+ expect(
+ updates.some(
+ ({ metrics }) => metrics.qualityLimitationReason === "cpu",
+ ),
+ ).toBe(false);
+ });
+
it("rolls the first sender back when the second replacement fails", async () => {
const oldVideo = createTrack("video", "old-video");
const oldAudio = createTrack("audio", "old-audio");
@@ -451,28 +530,31 @@ describe("ViewerRelay downstream ownership", () => {
bytesSent: 1_000_000,
framesEncoded: 30,
timestamp: 1_000,
+ totalEncodeTime: 0.15,
qualityLimitationReason: "cpu",
}),
sendStatsReport({
bytesSent: 1_500_000,
framesEncoded: 60,
timestamp: 2_000,
+ totalEncodeTime: 0.75,
qualityLimitationReason: "bandwidth",
}),
);
statsCallbacks[0]!();
await vi.waitFor(() =>
- expect(relay.getSnapshot()?.metrics.averageEncodeMs).toBe(5),
+ expect(relay.getSnapshot()?.metrics.qualityLimitationReason).toBe("cpu"),
);
+ expect(relay.getSnapshot()?.metrics.intervalEncodeMs).toBeNull();
statsCallbacks[0]!();
await vi.waitFor(() =>
- expect(relay.getSnapshot()?.metrics.bitrateKbps).toBe(4_000),
+ expect(relay.getSnapshot()?.metrics.intervalEncodeMs).toBe(20),
);
const snapshot = relay.getSnapshot()!;
expect(snapshot.metrics).toMatchObject({
- averageEncodeMs: 5,
+ intervalEncodeMs: 20,
bitrateKbps: 4_000,
encoderImplementation: "test-encoder",
qualityLimitationReason: "bandwidth",
diff --git a/tests/viewer-peer-generation.test.ts b/tests/viewer-peer-generation.test.ts
index 8e3b8b96..2c952cfd 100644
--- a/tests/viewer-peer-generation.test.ts
+++ b/tests/viewer-peer-generation.test.ts
@@ -354,4 +354,25 @@ describe("ViewerPeer connection generations", () => {
expect(newSnapshots).toHaveLength(newSnapshotCount);
expect(newSnapshots.at(-1)?.metrics.resolution).toBeNull();
});
+
+ it("skips overlapping stats ticks on the same connection", async () => {
+ const peer = createPeer([], []);
+ await peer.acceptSignal("host", offer("connection"));
+ const connection = FakePeerConnection.instances[0]!;
+ const stats = createDeferred<RTCStatsReport>();
+ connection.statsGate = stats.promise;
+ const statsCallback = intervalCallbacks.get(1)!;
+
+ statsCallback();
+ statsCallback();
+ await vi.waitFor(() => expect(connection.getStats).toHaveBeenCalledOnce());
+
+ stats.resolve(new Map() as unknown as RTCStatsReport);
+ await flushAsyncWork();
+ connection.statsGate = null;
+ statsCallback();
+ await vi.waitFor(() =>
+ expect(connection.getStats).toHaveBeenCalledTimes(2),
+ );
+ });
});