Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { describe, expect, it } from "vitest";
import {
invalidateSenderQualityEvidence,
retireSenderQualityEvidence,
retireSfuPublisherQualityEvidence,
senderQualityEvidenceFromSnapshot,
sfuPublisherQualityEvidenceFromMetrics,
} from "../src/client/media/sender-quality-evidence.ts";
import type { PeerSnapshot } from "../src/client/types.ts";
import { EMPTY_METRICS } from "../src/client/types.ts";
import {
collectConnectionMetricsFromReport,
collectNativeSenderQualityFromReport,
createNativeSenderQualityAccumulator,
createStatsAccumulator,
} from "../src/client/webrtc/stats.ts";
function report(
timestamp: number,
reason: "none" | "bandwidth" | "cpu",
durations: Record<"none" | "bandwidth" | "cpu" | "other", number>,
): RTCStatsReport {
return new Map([
[
"video",
{
id: "video",
type: "outbound-rtp",
kind: "video",
timestamp,
ssrc: 1,
bytesSent: timestamp * 100,
framesEncoded: timestamp / 20,
qualityLimitationReason: reason,
qualityLimitationDurations: durations,
},
],
]) as unknown as RTCStatsReport;
}
describe("native sender quality evidence", () => {
it.each(["failed", "closed"] as const)("does not retain a retired %s snapshot", (connectionState) => {
invalidateSenderQualityEvidence();
const snapshot: PeerSnapshot = {
peerId: "viewer_12345678", connectionId: "connection_12345678",
connectionState: "connected", iceConnectionState: "connected", error: null,
metrics: { ...EMPTY_METRICS },
};
expect(senderQualityEvidenceFromSnapshot(snapshot, 2)?.state).toBe("unknown");
expect(senderQualityEvidenceFromSnapshot({ ...snapshot, connectionState }, 2)).toBeNull();
expect(senderQualityEvidenceFromSnapshot(snapshot, 2)?.state).toBe("unknown");
});
it.each(["direct", "publication"])("retires only the released %s identity", (path) => {
invalidateSenderQualityEvidence();
const metrics = {
...EMPTY_METRICS, sampleTimestampMs: 1_000, sampleWindowMs: 2_000,
rtpStatsId: "outbound-1", trackIdentifier: "track-1", intervalFramesEncoded: 30,
nativeEdgeQualityState: "healthy" as const, qualityLimitationReason: "none",
};
const emit = (identity: string) => path === "direct"
? senderQualityEvidenceFromSnapshot({
peerId: "viewer_12345678", connectionId: identity,
connectionState: "connected", iceConnectionState: "connected", error: null, metrics,
}, 2)
: sfuPublisherQualityEvidenceFromMetrics(metrics, 2, identity);
const retired = "retired_12345678";
const live = "live_12345678";
expect(emit(retired)?.state).toBe("unknown");
expect(emit(live)?.state).toBe("unknown");
if (path === "direct") retireSenderQualityEvidence(retired);
else retireSfuPublisherQualityEvidence(retired);
expect(emit(retired)?.state).toBe("unknown");
expect(emit(live)).toBeNull();
metrics.sampleTimestampMs += 2_000;
expect(emit(live)?.state).toBe("healthy");
});
it.each(["direct", "publication"])("preserves %s observations independently of control evidence", (path) => {
invalidateSenderQualityEvidence();
const metrics = {
...EMPTY_METRICS, sampleTimestampMs: 1_000, sampleWindowMs: 2_000,
rtpStatsId: "outbound-1", trackIdentifier: "track-1", intervalFramesEncoded: 960,
nativeEdgeQualityState: "healthy" as const, qualityLimitationReason: "none",
availableOutgoingKbps: 1_000_000, bitrateKbps: 120_000, framesPerSecond: 480,
rttMs: NaN, packetLossPercent: 101,
};
const emit = () => path === "direct"
? senderQualityEvidenceFromSnapshot({
peerId: "viewer_12345678", connectionId: "connection_12345678",
connectionState: "connected", iceConnectionState: "connected", error: null, metrics,
}, 2)
: sfuPublisherQualityEvidenceFromMetrics(metrics, 2, "publication_12345678");
expect(emit()?.state).toBe("unknown");
metrics.sampleTimestampMs += 2_000;
expect(emit()).toMatchObject({ state: "healthy", diagnostics: {
availableOutgoingKbps: 1_000_000, bitrateKbps: 120_000, framesPerSecond: 480,
rttMs: null, packetLossPercent: null,
} });
metrics.sampleTimestampMs += 2_000;
metrics.intervalFramesEncoded = NaN;
expect(emit()?.state).toBe("unknown");
metrics.intervalFramesEncoded = 960;
metrics.sampleTimestampMs += 2_000;
expect(emit()?.state).toBe("healthy");
});
it("uses actual Native publication sent frames without inventing encoder work", () => {
invalidateSenderQualityEvidence();
const metrics = {
...EMPTY_METRICS,
sampleTimestampMs: 12_000,
sampleWindowMs: 2_000,
intervalFramesSent: 30,
framesPerSecond: 15,
nativeEdgeQualityState: "healthy" as const,
qualityLimitationReason: "none",
};
sfuPublisherQualityEvidenceFromMetrics(metrics, 3, "native_publication");
expect(
sfuPublisherQualityEvidenceFromMetrics(
{ ...metrics, sampleTimestampMs: 14_000 },
3,
"native_publication",
),
).toMatchObject({ state: "healthy", diagnostics: { framesPerSecond: 15 } });
expect(metrics.intervalFramesEncoded).toBeNull();
});
it("conservatively combines every active SFU publication encoding", () => {
const accumulator = createNativeSenderQualityAccumulator();
const multi = (
timestamp: number,
reasons: readonly ["none" | "bandwidth", "none" | "bandwidth"],
) => {
const entries: Array<[string, Record<string, unknown>]> = [
[
"source",
{
id: "source",
type: "media-source",
timestamp,
trackIdentifier: "track",
},
],
];
reasons.forEach((reason, index) =>
entries.push([
`video-${index}`,
{
id: `video-${index}`,
type: "outbound-rtp",
kind: "video",
timestamp,
framesEncoded: timestamp / 20 + index,
mediaSourceId: "source",
qualityLimitationReason: reason,
qualityLimitationDurations: {
none: reason === "none" ? timestamp / 1_000 : 3,
bandwidth: reason === "bandwidth" ? timestamp / 1_000 - 3 : 0,
cpu: 0,
other: 0,
},
},
]),
);
return new Map(entries) as unknown as RTCStatsReport;
};
expect(
collectNativeSenderQualityFromReport(
multi(1_000, ["none", "none"]),
"track",
accumulator,
).nativeEdgeQualityState,
).toBe("unknown");
expect(
collectNativeSenderQualityFromReport(
multi(3_000, ["none", "none"]),
"track",
accumulator,
).nativeEdgeQualityState,
).toBe("healthy");
expect(
collectNativeSenderQualityFromReport(
multi(5_000, ["bandwidth", "none"]),
"track",
accumulator,
).nativeEdgeQualityState,
).toBe("degraded");
});
it("derives categorical state only from one complete native duration delta", () => {
const accumulator = createStatsAccumulator();
const first = collectConnectionMetricsFromReport(
report(1_000, "none", { none: 1, bandwidth: 0, cpu: 0, other: 0 }),
"send",
accumulator,
);
expect(first.nativeEdgeQualityState).toBe("unknown");
const healthy = collectConnectionMetricsFromReport(
report(3_000, "none", { none: 3, bandwidth: 0, cpu: 0, other: 0 }),
"send",
accumulator,
);
expect(healthy.nativeEdgeQualityState).toBe("healthy");
const degraded = collectConnectionMetricsFromReport(
report(5_000, "bandwidth", {
none: 3,
bandwidth: 2,
cpu: 0,
other: 0,
}),
"send",
accumulator,
);
expect(degraded.nativeEdgeQualityState).toBe("degraded");
const mixed = collectConnectionMetricsFromReport(
report(7_000, "none", {
none: 4,
bandwidth: 3,
cpu: 0,
other: 0,
}),
"send",
accumulator,
);
expect(mixed.nativeEdgeQualityState).toBe("unknown");
});
it("serializes only exact healthy or degraded sender snapshots", () => {
const metrics = collectConnectionMetricsFromReport(
report(1_000, "none", { none: 1, bandwidth: 0, cpu: 0, other: 0 }),
"send",
createStatsAccumulator(),
);
const snapshot: PeerSnapshot = {
peerId: "viewer_12345678",
connectionId: "connection_12345678",
connectionState: "connected",
iceConnectionState: "connected",
metrics: {
...metrics,
rtpStatsId: "rtp-stats-1",
trackIdentifier: "track-1",
sampleWindowMs: 2_000,
intervalFramesEncoded: 100,
qualityLimitationReason: "none",
nativeEdgeQualityState: "healthy",
},
error: null,
};
expect(senderQualityEvidenceFromSnapshot(snapshot, 7)).toMatchObject({
state: "unknown",
});
expect(senderQualityEvidenceFromSnapshot(snapshot, 7)).toBeNull();
const nextSnapshot = {
...snapshot,
metrics: {
...snapshot.metrics,
sampleTimestampMs: 2_000,
},
};
expect(senderQualityEvidenceFromSnapshot(nextSnapshot, 7)).toMatchObject({
type: "sender-quality-evidence",
childPeerId: snapshot.peerId,
connectionId: snapshot.connectionId,
routeRevision: 7,
state: "healthy",
sampleTimestampMs: 2_000,
diagnostics: { natTraversalPath: "unknown" },
});
invalidateSenderQualityEvidence();
expect(senderQualityEvidenceFromSnapshot(nextSnapshot, 7)).toMatchObject({
state: "unknown",
});
expect(senderQualityEvidenceFromSnapshot(nextSnapshot, 7)).toBeNull();
});
it("waits for a new SFU publisher stats window after rebaseline", () => {
invalidateSenderQualityEvidence();
const metrics = {
...collectConnectionMetricsFromReport(
report(1_000, "none", {
none: 1,
bandwidth: 0,
cpu: 0,
other: 0,
}),
"send",
createStatsAccumulator(),
),
sampleTimestampMs: 1_000,
sampleWindowMs: 2_000,
intervalFramesEncoded: 100,
qualityLimitationReason: "none",
nativeEdgeQualityState: "healthy" as const,
};
const generation = "publication_generation_12345678";
expect(
sfuPublisherQualityEvidenceFromMetrics(metrics, 3, generation),
).toMatchObject({ state: "unknown" });
expect(
sfuPublisherQualityEvidenceFromMetrics(metrics, 3, generation),
).toBeNull();
expect(
sfuPublisherQualityEvidenceFromMetrics(
{ ...metrics, sampleTimestampMs: 3_000 },
3,
generation,
),
).toMatchObject({ state: "healthy", sampleTimestampMs: 3_000 });
});
});