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. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

37.8 KB
Raw Blame
import {
  EMPTY_METRICS,
  type ConnectionMetrics,
} from "../types";
import { packetLossPercentFromDeltas } from "../../shared/packet-loss";
import { deriveVideoCodecEvidence } from "../../shared/video-codec-evidence";
import { isPredictedCandidateFoundation } from "../../shared/nat-candidate";
import { debugRtcFailure, debugRtcStats } from "../lib/debug-webrtc";
import { senderCaptureTrack } from "../media/sender-video-track";

type StatsRecord = Record<string, unknown> & {
  id: string;
  type: string;
  timestamp: number;
};

type QualityLimitationDurations = Record<
  "none" | "bandwidth" | "cpu" | "other",
  number
>;

export interface StatsAccumulator {
  mediaId: string | null;
  ssrc: number | null;
  trackIdentifier: string | null;
  lossSourceId: string | null;
  lossReportTimestamp: number | null;
  bytes: number | null;
  frames: number | null;
  timestamp: number | null;
  previousTotalEncodeTime: number | null;
  previousTotalDecodeTime: number | null;
  previousPacketsSent: number | null;
  previousPacketsReceived: number | null;
  previousPacketsLost: number | null;
  previousFramesDropped: number | null;
  previousFreezeCount: number | null;
  previousTotalFreezesDuration: number | null;
  previousPauseCount: number | null;
  previousTotalPausesDuration: number | null;
  previousRetransmittedPackets: number | null;
  previousRetransmittedBytes: number | null;
  previousVideoJitterBufferDelay: number | null;
  previousVideoJitterBufferEmittedCount: number | null;
  previousQualityLimitationDurations: QualityLimitationDurations | null;
  audioMediaId: string | null;
  audioSsrc: number | null;
  audioTrackIdentifier: string | null;
  audioLossSourceId: string | null;
  audioBytes: number | null;
  audioTimestamp: number | null;
  previousAudioPacketsReceived: number | null;
  previousAudioPacketsLost: number | null;
  previousAudioJitterBufferDelay: number | null;
  previousAudioJitterBufferEmittedCount: number | null;
  previousAudioTotalSamplesReceived: number | null;
  previousAudioConcealedSamples: number | null;
  previousAudioConcealmentEvents: number | null;
}

export interface StatsMediaSelector {
  kind?: "audio" | "video";
  trackIdentifier: string | null;
  rid?: string | null;
  audioTrackIdentifier?: string | null;
}

interface NativeSenderQualityPrevious {
  timestamp: number;
  durations: QualityLimitationDurations | null;
  framesEncoded: number | null;
  bytesSent: number | null;
}

export interface NativeSenderQualityAccumulator {
  previousByStatsId: Map<string, NativeSenderQualityPrevious>;
}

export function createNativeSenderQualityAccumulator(): NativeSenderQualityAccumulator {
  return { previousByStatsId: new Map() };
}

export function collectNativeSenderQualityFromReport(
  report: RTCStatsReport,
  trackIdentifier: string,
  accumulator: NativeSenderQualityAccumulator,
): Pick<
  ConnectionMetrics,
  | "sampleTimestampMs"
  | "nativeEdgeQualityState"
  | "qualityLimitationReason"
  | "sampleWindowMs"
  | "intervalFramesEncoded"
  | "bitrateKbps"
> {
  const records: StatsRecord[] = [];
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (
      record.type === "outbound-rtp" &&
      record.kind === "video" &&
      record.isRemote !== true &&
      record.active !== false &&
      mediaTrackIdentifier(report, record, "send") === trackIdentifier
    ) {
      records.push(record);
    }
  });
  const activeIds = new Set(records.map((record) => record.id));
  for (const id of accumulator.previousByStatsId.keys()) {
    if (!activeIds.has(id)) accumulator.previousByStatsId.delete(id);
  }
  const samples = records.map((record) => {
    const timestamp = numberValue(record, "timestamp");
    const durations = qualityLimitationDurationsValue(record);
    const reason = stringValue(record, "qualityLimitationReason");
    const framesEncoded = numberValue(record, "framesEncoded");
    const bytesSent = numberValue(record, "bytesSent");
    const previous = accumulator.previousByStatsId.get(record.id);
    const windowMs =
      timestamp !== null && previous && timestamp > previous.timestamp
        ? timestamp - previous.timestamp
        : null;
    const state = nativeEdgeQualityState(
      reason,
      durations,
      previous?.durations ?? null,
      windowMs !== null,
    );
    const intervalFramesEncoded =
      previous &&
      framesEncoded !== null &&
      previous.framesEncoded !== null &&
      framesEncoded >= previous.framesEncoded
        ? framesEncoded - previous.framesEncoded
        : null;
    const bitrateKbps =
      previous &&
      windowMs !== null &&
      bytesSent !== null &&
      previous.bytesSent !== null &&
      bytesSent >= previous.bytesSent
        ? ((bytesSent - previous.bytesSent) * 8) / (windowMs / 1_000) / 1_000
        : null;
    if (timestamp !== null) {
      accumulator.previousByStatsId.set(record.id, {
        timestamp,
        durations,
        framesEncoded,
        bytesSent,
      });
    } else {
      accumulator.previousByStatsId.delete(record.id);
    }
    return {
      timestamp,
      state,
      reason,
      windowMs,
      intervalFramesEncoded,
      bitrateKbps,
    };
  });
  const bitrateKbps =
    samples.length > 0 && samples.every((sample) => sample.bitrateKbps !== null)
      ? samples.reduce((total, sample) => total + sample.bitrateKbps!, 0)
      : null;
  if (
    samples.length === 0 ||
    samples.some(
      (sample) =>
        sample.state === "unknown" ||
        sample.timestamp === null ||
        sample.windowMs === null ||
        sample.intervalFramesEncoded === null,
    )
  ) {
    return {
      sampleTimestampMs: null,
      nativeEdgeQualityState: "unknown",
      qualityLimitationReason: null,
      sampleWindowMs: null,
      intervalFramesEncoded: null,
      bitrateKbps,
    };
  }
  const degraded = samples.filter((sample) => sample.state === "degraded");
  return {
    sampleTimestampMs: Math.min(...samples.map((sample) => sample.timestamp!)),
    nativeEdgeQualityState: degraded.length > 0 ? "degraded" : "healthy",
    qualityLimitationReason:
      degraded.some((sample) => sample.reason === "bandwidth")
        ? "bandwidth"
        : degraded.length > 0
          ? "cpu"
          : "none",
    sampleWindowMs: Math.min(...samples.map((sample) => sample.windowMs!)),
    intervalFramesEncoded: samples.reduce(
      (total, sample) => total + sample.intervalFramesEncoded!,
      0,
    ),
    bitrateKbps,
  };
}

export function captureMetrics(
  track: MediaStreamTrack,
): Pick<
  ConnectionMetrics,
  "captureWidth" | "captureHeight" | "captureFramesPerSecond"
> {
  try {
    const settings = senderCaptureTrack(track).getSettings();
    const finite = (value: unknown): number | null =>
      typeof value === "number" && Number.isFinite(value) ? value : null;
    return {
      captureWidth: finite(settings.width),
      captureHeight: finite(settings.height),
      captureFramesPerSecond: finite(settings.frameRate),
    };
  } catch {
    return {
      captureWidth: null,
      captureHeight: null,
      captureFramesPerSecond: null,
    };
  }
}

export function createStatsAccumulator(): StatsAccumulator {
  return {
    mediaId: null,
    ssrc: null,
    trackIdentifier: null,
    lossSourceId: null,
    lossReportTimestamp: null,
    bytes: null,
    frames: null,
    timestamp: null,
    previousTotalEncodeTime: null,
    previousTotalDecodeTime: null,
    previousPacketsSent: null,
    previousPacketsReceived: null,
    previousPacketsLost: null,
    previousFramesDropped: null,
    previousFreezeCount: null,
    previousTotalFreezesDuration: null,
    previousPauseCount: null,
    previousTotalPausesDuration: null,
    previousRetransmittedPackets: null,
    previousRetransmittedBytes: null,
    previousVideoJitterBufferDelay: null,
    previousVideoJitterBufferEmittedCount: null,
    previousQualityLimitationDurations: null,
    audioMediaId: null,
    audioSsrc: null,
    audioTrackIdentifier: null,
    audioLossSourceId: null,
    audioBytes: null,
    audioTimestamp: null,
    previousAudioPacketsReceived: null,
    previousAudioPacketsLost: null,
    previousAudioJitterBufferDelay: null,
    previousAudioJitterBufferEmittedCount: null,
    previousAudioTotalSamplesReceived: null,
    previousAudioConcealedSamples: null,
    previousAudioConcealmentEvents: null,
  };
}

function intervalDelta(
  current: number | null,
  previous: number | null,
  hasInterval: boolean,
): number | null {
  if (
    !hasInterval ||
    current === null ||
    previous === null ||
    current < previous
  ) {
    return null;
  }
  return current - previous;
}

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 percentOfInterval(
  partDelta: number | null,
  totalDelta: number | null,
): number | null {
  if (
    partDelta === null ||
    totalDelta === null ||
    !Number.isFinite(partDelta) ||
    !Number.isFinite(totalDelta) ||
    partDelta < 0 ||
    totalDelta <= 0 ||
    partDelta > totalDelta
  ) {
    return null;
  }
  return (partDelta / totalDelta) * 100;
}

function numberValue(record: StatsRecord | null, key: string): number | null {
  const value = record?.[key];
  return typeof value === "number" && Number.isFinite(value) ? value : null;
}

function stringValue(record: StatsRecord | null, key: string): string | null {
  const value = record?.[key];
  return typeof value === "string" && value.length > 0 ? value : null;
}

function qualityLimitationDurationsValue(
  record: StatsRecord | null,
): QualityLimitationDurations | null {
  const value = record?.qualityLimitationDurations;
  if (!value || typeof value !== "object") {
    return null;
  }
  const durations = value as Record<string, unknown>;
  const result = {} as QualityLimitationDurations;
  for (const reason of ["none", "bandwidth", "cpu", "other"] as const) {
    const duration = durations[reason];
    if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) {
      return null;
    }
    result[reason] = duration;
  }
  return result;
}

function nativeEdgeQualityState(
  reason: string | null,
  current: QualityLimitationDurations | null,
  previous: QualityLimitationDurations | null,
  hasInterval: boolean,
): ConnectionMetrics["nativeEdgeQualityState"] {
  if (!hasInterval || !current || !previous) {
    return "unknown";
  }
  const deltas = {} as QualityLimitationDurations;
  for (const key of ["none", "bandwidth", "cpu", "other"] as const) {
    if (current[key] < previous[key]) {
      return "unknown";
    }
    deltas[key] = current[key] - previous[key];
  }
  if (
    reason === "none" &&
    deltas.none > 0 &&
    deltas.bandwidth === 0 &&
    deltas.cpu === 0 &&
    deltas.other === 0
  ) {
    return "healthy";
  }
  if (
    (reason === "bandwidth" || reason === "cpu") &&
    deltas[reason] > 0 &&
    deltas.none === 0 &&
    deltas.other === 0 &&
    deltas[reason === "bandwidth" ? "cpu" : "bandwidth"] === 0
  ) {
    return "degraded";
  }
  return "unknown";
}

function booleanValue(record: StatsRecord | null, key: string): boolean | null {
  const value = record?.[key];
  return typeof value === "boolean" ? value : null;
}

function getRecord(report: RTCStatsReport, id: string | null): StatsRecord | null {
  if (!id) {
    return null;
  }
  return (report.get(id) as StatsRecord | undefined) ?? null;
}

function mediaTrackIdentifier(
  report: RTCStatsReport,
  media: StatsRecord,
  direction: "send" | "receive",
): string | null {
  if (direction === "receive") {
    return stringValue(media, "trackIdentifier");
  }
  const source = mediaSourceRecord(report, media);
  return stringValue(source, "trackIdentifier");
}

export function mediaSourceRecord(
  report: RTCStatsReport,
  media: StatsRecord | null,
): StatsRecord | null {
  if (!media || media.type !== "outbound-rtp" || media.isRemote === true) return null;
  if (media.mediaSourceId !== undefined) {
    const source = getRecord(report, stringValue(media, "mediaSourceId"));
    return source?.type === "media-source" ? source : null;
  }
  if (media.kind !== "video" && media.kind !== "audio") return null;
  // Some browsers omit the link. Infer it only for one sender and one source
  // of the same kind; stale/multiple senders or sources remain ambiguous.
  const senders: StatsRecord[] = [];
  const sources: StatsRecord[] = [];
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (record.kind !== media.kind) return;
    if (record.type === "outbound-rtp" && record.isRemote !== true) senders.push(record);
    if (record.type === "media-source") sources.push(record);
  });
  return senders.length === 1 && senders[0]!.id === media.id && sources.length === 1
    ? sources[0]!
    : null;
}

function mediaRecord(
  report: RTCStatsReport,
  direction: "send" | "receive",
  selector: StatsMediaSelector | null,
  kind: "audio" | "video" = "video",
): StatsRecord | null {
  const expectedType = direction === "send" ? "outbound-rtp" : "inbound-rtp";
  const isExpectedMedia = (record: StatsRecord): boolean =>
    record.type === expectedType &&
    record.kind === kind &&
    record.isRemote !== true;

  const candidates: StatsRecord[] = [];
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (isExpectedMedia(record)) {
      candidates.push(record);
    }
  });
  const selectedTrackIdentifier = selector?.trackIdentifier ?? null;
  const selectedRid = selector?.rid ?? null;
  const narrowed = candidates.filter(
    (candidate) =>
      (selectedTrackIdentifier === null ||
        mediaTrackIdentifier(report, candidate, direction) ===
          selectedTrackIdentifier) &&
      (selectedRid === null || stringValue(candidate, "rid") === selectedRid),
  );
  return narrowed.length === 1 ? narrowed[0]! : null;
}

export function decodedVideoFrames(
  report: RTCStatsReport,
  selector: StatsMediaSelector | null = null,
): number | null {
  return numberValue(mediaRecord(report, "receive", selector), "framesDecoded");
}

export function maxEncodedVideoFrames(
  report: RTCStatsReport,
  trackIdentifier: string,
): number | null {
  // An absent current-track counter is unknown, not a fresh encoder at zero.
  let frames: number | null = null;
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (
      record.type === "outbound-rtp" &&
      record.kind === "video" &&
      record.isRemote !== true &&
      mediaTrackIdentifier(report, record, "send") === trackIdentifier
    ) {
      const encodedFrames = numberValue(record, "framesEncoded");
      if (encodedFrames !== null) {
        frames = Math.max(frames ?? 0, encodedFrames);
      }
    }
  });
  return frames;
}

export function highestActiveVideoRid(
  report: RTCStatsReport,
  trackIdentifier: string,
): string | null {
  let selectedRid: string | null = null;
  let selectedPixels = -1;
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (
      record.type !== "outbound-rtp" ||
      record.kind !== "video" ||
      record.isRemote === true ||
      record.active === false ||
      mediaTrackIdentifier(report, record, "send") !== trackIdentifier
    ) {
      return;
    }
    const rid = stringValue(record, "rid");
    const width = numberValue(record, "frameWidth");
    const height = numberValue(record, "frameHeight");
    if (!rid || width === null || height === null || width <= 0 || height <= 0) {
      return;
    }
    const pixels = width * height;
    if (pixels > selectedPixels) {
      selectedRid = rid;
      selectedPixels = pixels;
    }
  });
  return selectedRid;
}

function transportRecord(
  report: RTCStatsReport,
  media: StatsRecord | null,
): StatsRecord | null {
  const referenced = getRecord(report, stringValue(media, "transportId"));
  return referenced?.type === "transport" ? referenced : null;
}

function selectedCandidatePair(
  report: RTCStatsReport,
  transport: StatsRecord | null,
): StatsRecord | null {
  if (!transport) {
    return null;
  }
  const candidatePairs: StatsRecord[] = [];
  report.forEach((raw) => {
    const record = raw as StatsRecord;
    if (record.type === "candidate-pair") {
      candidatePairs.push(record);
    }
  });

  const pairId = stringValue(transport, "selectedCandidatePairId");
  if (pairId) {
    const referenced = getRecord(report, pairId);
    return referenced?.type === "candidate-pair" &&
      stringValue(referenced, "transportId") === transport.id
      ? referenced
      : null;
  }
  const selected = candidatePairs.filter(
    (pair) =>
      stringValue(pair, "transportId") === transport.id &&
      pair.state === "succeeded" &&
      (pair.nominated === true || pair.selected === true),
  );
  return selected.length === 1 ? selected[0]! : null;
}

function linkedRemoteInbound(
  report: RTCStatsReport,
  outbound: StatsRecord | null,
  kind: "audio" | "video" = "video",
): StatsRecord | null {
  const remote = getRecord(report, stringValue(outbound, "remoteId"));
  return remote?.type === "remote-inbound-rtp" && remote.kind === kind
    ? remote
    : null;
}

function linkedMediaCodec(
  report: RTCStatsReport,
  media: StatsRecord | null,
  transport: StatsRecord | null,
  kind: "audio" | "video",
): StatsRecord | null {
  const codec = getRecord(report, stringValue(media, "codecId"));
  const mimeType = stringValue(codec, "mimeType");
  return codec?.type === "codec" &&
    transport !== null &&
    stringValue(codec, "transportId") === transport.id &&
    mimeType !== null &&
    new RegExp(`^${kind}\\/[A-Za-z0-9.+-]{1,32}$`, "i").test(mimeType)
    ? codec
    : null;
}

function deriveCodecEvidence(codec: StatsRecord | null) {
  const mimeType = stringValue(codec, "mimeType");
  return deriveVideoCodecEvidence(
    mimeType,
    stringValue(codec, "sdpFmtpLine"),
  );
}

function positiveIntegerValue(
  record: StatsRecord | null,
  key: string,
): number | null {
  const value = numberValue(record, key);
  return value !== null && Number.isInteger(value) && value > 0 ? value : null;
}

function candidateAddressValue(record: StatsRecord | null): string | null {
  const value = stringValue(record, "address");
  return value !== null &&
    value.length <= 255 &&
    !/[\u0000-\u0020\u007f]/.test(value)
    ? value
    : null;
}

function candidatePortValue(record: StatsRecord | null): number | null {
  const value = numberValue(record, "port");
  return value !== null &&
    Number.isInteger(value) &&
    value > 0 &&
    value <= 65_535
    ? value
    : null;
}

function audioCodecParameters(codec: StatsRecord | null): string | null {
  const value = stringValue(codec, "sdpFmtpLine");
  return value !== null && value.length <= 512 && /^[\x20-\x7e]+$/.test(value)
    ? value
    : null;
}

function scalabilityModeValue(media: StatsRecord | null): string | null {
  const value = stringValue(media, "scalabilityMode");
  return value && /^[A-Za-z0-9_-]{1,32}$/.test(value) ? value : null;
}

export async function collectConnectionMetrics(
  connection: RTCPeerConnection,
  direction: "send" | "receive",
  previous: StatsAccumulator,
  selector: StatsMediaSelector | null = null,
): Promise<ConnectionMetrics> {
  try {
    const report = await connection.getStats();
    debugRtcStats(connection, report);
    return collectConnectionMetricsFromReport(report, direction, previous, selector);
  } catch (error) {
    debugRtcFailure(connection, error);
    throw error;
  }
}

export function collectConnectionMetricsFromReport(
  report: RTCStatsReport,
  direction: "send" | "receive",
  previous: StatsAccumulator,
  selector: StatsMediaSelector | null = null,
): ConnectionMetrics {
  const kind = selector?.kind ?? "video";
  const media = mediaRecord(report, direction, selector, kind);
  const transport = transportRecord(report, media);
  let pair = selectedCandidatePair(report, transport);
  let localCandidate = getRecord(
    report,
    stringValue(pair, "localCandidateId"),
  );
  let remoteCandidate = getRecord(
    report,
    stringValue(pair, "remoteCandidateId"),
  );
  if (
    localCandidate?.type !== "local-candidate" ||
    remoteCandidate?.type !== "remote-candidate"
  ) {
    pair = null;
    localCandidate = null;
    remoteCandidate = null;
  }
  const localType = stringValue(localCandidate, "candidateType");
  const remoteType = stringValue(remoteCandidate, "candidateType");
  const remoteFoundation = stringValue(remoteCandidate, "foundation");
  const natTraversalPath =
    remoteFoundation === null
      ? "unknown"
      : isPredictedCandidateFoundation(remoteFoundation)
        ? "predicted"
        : "ordinary";
  const path =
    localType === "relay" || remoteType === "relay"
      ? "unknown"
      : localType !== null && remoteType !== null
        ? "direct"
        : "unknown";

  const mediaId = media?.id ?? null;
  const ssrc = numberValue(media, "ssrc");
  const trackIdentifier = media
    ? mediaTrackIdentifier(report, media, direction)
    : null;
  const remoteInbound =
    direction === "send" ? linkedRemoteInbound(report, media, kind) : null;
  const lossSource = direction === "send" ? remoteInbound : media;
  const lossSourceId = lossSource?.id ?? null;
  const lossReportTimestamp = numberValue(lossSource, "timestamp");
  const sameMedia =
    mediaId !== null &&
    mediaId === previous.mediaId &&
    ssrc === previous.ssrc &&
    trackIdentifier === previous.trackIdentifier;
  const sameLossSource =
    sameMedia &&
    lossSourceId !== null &&
    lossSourceId === previous.lossSourceId;
  const bytesKey = direction === "send" ? "bytesSent" : "bytesReceived";
  const bytes = numberValue(media, bytesKey);
  const framesKey = direction === "send" ? "framesEncoded" : "framesDecoded";
  const frames = numberValue(media, framesKey);
  const timestamp = numberValue(media, "timestamp");
  const framesEncoded = numberValue(media, "framesEncoded");
  const framesDecoded = numberValue(media, "framesDecoded");
  const packetsSent = numberValue(media, "packetsSent");
  const packetsReceived = numberValue(lossSource, "packetsReceived");
  const packetsLost = numberValue(lossSource, "packetsLost");
  const fractionLost = numberValue(remoteInbound, "fractionLost");
  const totalEncodeTime = numberValue(media, "totalEncodeTime");
  const totalDecodeTime = numberValue(media, "totalDecodeTime");
  const framesDropped = numberValue(media, "framesDropped");
  const freezeCount = numberValue(media, "freezeCount");
  const totalFreezesDuration = numberValue(media, "totalFreezesDuration");
  const pauseCount = numberValue(media, "pauseCount");
  const totalPausesDuration = numberValue(media, "totalPausesDuration");
  const retransmittedPackets = numberValue(
    media,
    direction === "send"
      ? "retransmittedPacketsSent"
      : "retransmittedPacketsReceived",
  );
  const retransmittedBytes = numberValue(
    media,
    direction === "send"
      ? "retransmittedBytesSent"
      : "retransmittedBytesReceived",
  );
  const videoJitterBufferDelay = numberValue(media, "jitterBufferDelay");
  const videoJitterBufferEmittedCount = numberValue(
    media,
    "jitterBufferEmittedCount",
  );
  const qualityLimitationReason = stringValue(
    media,
    "qualityLimitationReason",
  );
  const qualityLimitationDurations = qualityLimitationDurationsValue(media);
  let bitrateKbps: number | null = null;
  let derivedFps: number | null = null;
  const sampleWindowMs =
    sameMedia &&
    timestamp !== null &&
    previous.timestamp !== null &&
    timestamp > previous.timestamp
      ? timestamp - previous.timestamp
      : null;

  if (sampleWindowMs !== null) {
    const elapsedSeconds = sampleWindowMs / 1_000;
    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,
          sampleWindowMs !== null ? previous.previousTotalEncodeTime : null,
          framesEncoded,
          sampleWindowMs !== null ? previous.frames : null,
        )
      : null;
  const intervalFramesEncoded =
    direction === "send"
      ? intervalDelta(framesEncoded, previous.frames, sampleWindowMs !== null)
      : null;
  const encodeTimeDelta =
    direction === "send"
      ? intervalDelta(
          totalEncodeTime,
          previous.previousTotalEncodeTime,
          sampleWindowMs !== null,
        )
      : null;
  const intervalDecodeMs =
    direction === "receive"
      ? intervalAverageMs(
          totalDecodeTime,
          sampleWindowMs !== null ? previous.previousTotalDecodeTime : null,
          framesDecoded,
          sampleWindowMs !== null ? previous.frames : null,
        )
      : null;
  const lossPacketsReceivedDelta = intervalDelta(
    packetsReceived,
    previous.previousPacketsReceived,
    sampleWindowMs !== null && sameLossSource,
  );
  const intervalPacketsReceived =
    direction === "receive" ? lossPacketsReceivedDelta : null;
  const intervalPacketsSent =
    direction === "send"
      ? intervalDelta(
          packetsSent,
          previous.previousPacketsSent,
          sampleWindowMs !== null,
        )
      : null;
  const intervalPacketsLost = intervalDelta(
    packetsLost,
    previous.previousPacketsLost,
    sampleWindowMs !== null && sameLossSource,
  );
  // RTCP already defines fractionLost over its own report interval. Consume a
  // report once instead of mixing that remote interval with local send deltas.
  const senderPacketLossPercent =
    direction === "send" &&
    sameLossSource &&
    lossReportTimestamp !== null &&
    previous.lossReportTimestamp !== null &&
    lossReportTimestamp > previous.lossReportTimestamp &&
    fractionLost !== null &&
    fractionLost >= 0 &&
    fractionLost <= 1
      ? fractionLost * 100
      : null;
  const intervalFramesDecoded =
    direction === "receive"
      ? intervalDelta(
          framesDecoded,
          previous.frames,
          sampleWindowMs !== null,
        )
      : null;
  const intervalFramesDropped = intervalDelta(
    framesDropped,
    previous.previousFramesDropped,
    sampleWindowMs !== null,
  );
  const intervalFreezeCount = intervalDelta(
    freezeCount,
    previous.previousFreezeCount,
    sampleWindowMs !== null,
  );
  const freezeDurationDelta = intervalDelta(
    totalFreezesDuration,
    previous.previousTotalFreezesDuration,
    sampleWindowMs !== null,
  );
  const intervalPauseCount =
    direction === "receive"
      ? intervalDelta(
          pauseCount,
          previous.previousPauseCount,
          sampleWindowMs !== null,
        )
      : null;
  const pauseDurationDelta =
    direction === "receive"
      ? intervalDelta(
          totalPausesDuration,
          previous.previousTotalPausesDuration,
          sampleWindowMs !== null,
        )
      : null;
  const intervalRetransmittedPackets = intervalDelta(
    retransmittedPackets,
    previous.previousRetransmittedPackets,
    sampleWindowMs !== null,
  );
  const intervalRetransmittedBytes = intervalDelta(
    retransmittedBytes,
    previous.previousRetransmittedBytes,
    sampleWindowMs !== null,
  );
  const videoJitterBufferDelayMs =
    direction === "receive" && sampleWindowMs !== null
      ? intervalAverageMs(
          videoJitterBufferDelay,
          previous.previousVideoJitterBufferDelay,
          videoJitterBufferEmittedCount,
          previous.previousVideoJitterBufferEmittedCount,
        )
      : null;
  const currentNativeEdgeQualityState = nativeEdgeQualityState(
    qualityLimitationReason,
    qualityLimitationDurations,
    previous.previousQualityLimitationDurations,
    sampleWindowMs !== null,
  );
  previous.mediaId = mediaId;
  previous.ssrc = ssrc;
  previous.trackIdentifier = trackIdentifier;
  previous.lossSourceId = lossSourceId;
  previous.lossReportTimestamp = lossReportTimestamp;
  previous.bytes = bytes;
  previous.frames = frames;
  previous.timestamp = timestamp;
  previous.previousTotalEncodeTime = totalEncodeTime;
  previous.previousTotalDecodeTime = totalDecodeTime;
  previous.previousPacketsSent = packetsSent;
  previous.previousPacketsReceived = packetsReceived;
  previous.previousPacketsLost = packetsLost;
  previous.previousFramesDropped = framesDropped;
  previous.previousFreezeCount = freezeCount;
  previous.previousTotalFreezesDuration = totalFreezesDuration;
  previous.previousPauseCount = pauseCount;
  previous.previousTotalPausesDuration = totalPausesDuration;
  previous.previousRetransmittedPackets = retransmittedPackets;
  previous.previousRetransmittedBytes = retransmittedBytes;
  previous.previousVideoJitterBufferDelay = videoJitterBufferDelay;
  previous.previousVideoJitterBufferEmittedCount =
    videoJitterBufferEmittedCount;
  previous.previousQualityLimitationDurations = qualityLimitationDurations;

  const linkedCodec = linkedMediaCodec(report, media, transport, "video");
  const codecEvidence = deriveCodecEvidence(linkedCodec);
  const mediaSource =
    direction === "send" ? mediaSourceRecord(report, media) : null;
  const audio =
    selector?.audioTrackIdentifier === null
      ? null
      : mediaRecord(
          report,
          direction,
          selector?.audioTrackIdentifier === undefined
            ? null
            : { trackIdentifier: selector.audioTrackIdentifier },
          "audio",
        );
  const audioTransport = transportRecord(report, audio);
  const audioRemoteInbound =
    direction === "send"
      ? linkedRemoteInbound(report, audio, "audio")
      : null;
  const audioLossSource = direction === "send" ? audioRemoteInbound : audio;
  const audioMediaId = audio?.id ?? null;
  const audioSsrc = numberValue(audio, "ssrc");
  const audioTrackIdentifier = audio
    ? mediaTrackIdentifier(report, audio, direction)
    : null;
  const audioLossSourceId = audioLossSource?.id ?? null;
  const sameAudio =
    audioMediaId !== null &&
    audioMediaId === previous.audioMediaId &&
    audioSsrc === previous.audioSsrc &&
    audioTrackIdentifier === previous.audioTrackIdentifier;
  const sameAudioLossSource =
    sameAudio &&
    audioLossSourceId !== null &&
    audioLossSourceId === previous.audioLossSourceId;
  const audioBytes = numberValue(
    audio,
    direction === "send" ? "bytesSent" : "bytesReceived",
  );
  const audioTimestamp = numberValue(audio, "timestamp");
  const audioSampleWindowMs =
    sameAudio &&
    audioTimestamp !== null &&
    previous.audioTimestamp !== null &&
    audioTimestamp > previous.audioTimestamp
      ? audioTimestamp - previous.audioTimestamp
      : null;
  const audioPacketsReceived = numberValue(audioLossSource, "packetsReceived");
  const audioPacketsLost = numberValue(audioLossSource, "packetsLost");
  const audioJitterBufferDelay = numberValue(audio, "jitterBufferDelay");
  const audioJitterBufferEmittedCount = numberValue(
    audio,
    "jitterBufferEmittedCount",
  );
  const audioTotalSamplesReceived = numberValue(audio, "totalSamplesReceived");
  const audioConcealedSamples = numberValue(audio, "concealedSamples");
  const audioConcealmentEvents = numberValue(audio, "concealmentEvents");
  const audioPacketsReceivedDelta = intervalDelta(
    audioPacketsReceived,
    previous.previousAudioPacketsReceived,
    audioSampleWindowMs !== null && sameAudioLossSource,
  );
  const audioPacketsLostDelta = intervalDelta(
    audioPacketsLost,
    previous.previousAudioPacketsLost,
    audioSampleWindowMs !== null && sameAudioLossSource,
  );
  const audioBitrateKbps =
    audioSampleWindowMs !== null &&
    audioBytes !== null &&
    previous.audioBytes !== null &&
    audioBytes >= previous.audioBytes
      ? ((audioBytes - previous.audioBytes) * 8) / audioSampleWindowMs
      : null;
  const audioJitterBufferDelayMs =
    direction === "receive" && audioSampleWindowMs !== null
      ? intervalAverageMs(
          audioJitterBufferDelay,
          previous.previousAudioJitterBufferDelay,
          audioJitterBufferEmittedCount,
          previous.previousAudioJitterBufferEmittedCount,
        )
      : null;
  const intervalAudioTotalSamplesReceived = intervalDelta(
    audioTotalSamplesReceived,
    previous.previousAudioTotalSamplesReceived,
    direction === "receive" && audioSampleWindowMs !== null,
  );
  const intervalAudioConcealedSamples = intervalDelta(
    audioConcealedSamples,
    previous.previousAudioConcealedSamples,
    direction === "receive" && audioSampleWindowMs !== null,
  );
  const intervalAudioConcealmentEvents = intervalDelta(
    audioConcealmentEvents,
    previous.previousAudioConcealmentEvents,
    direction === "receive" && audioSampleWindowMs !== null,
  );
  const videoEstimatedPlayoutTimestamp = numberValue(
    media,
    "estimatedPlayoutTimestamp",
  );
  const audioEstimatedPlayoutTimestamp = numberValue(
    audio,
    "estimatedPlayoutTimestamp",
  );
  const audioVideoPlayoutDeltaMs =
    direction === "receive" &&
    videoEstimatedPlayoutTimestamp !== null &&
    audioEstimatedPlayoutTimestamp !== null
      ? audioEstimatedPlayoutTimestamp - videoEstimatedPlayoutTimestamp
      : null;
  previous.audioMediaId = audioMediaId;
  previous.audioSsrc = audioSsrc;
  previous.audioTrackIdentifier = audioTrackIdentifier;
  previous.audioLossSourceId = audioLossSourceId;
  previous.audioBytes = audioBytes;
  previous.audioTimestamp = audioTimestamp;
  previous.previousAudioPacketsReceived = audioPacketsReceived;
  previous.previousAudioPacketsLost = audioPacketsLost;
  previous.previousAudioJitterBufferDelay = audioJitterBufferDelay;
  previous.previousAudioJitterBufferEmittedCount =
    audioJitterBufferEmittedCount;
  previous.previousAudioTotalSamplesReceived = audioTotalSamplesReceived;
  previous.previousAudioConcealedSamples = audioConcealedSamples;
  previous.previousAudioConcealmentEvents = audioConcealmentEvents;
  const linkedAudioCodec = linkedMediaCodec(
    report,
    audio,
    audioTransport,
    "audio",
  );
  const width = numberValue(media, "frameWidth");
  const height = numberValue(media, "frameHeight");
  const iceProtocol =
    stringValue(localCandidate, "protocol") ??
    stringValue(remoteCandidate, "protocol");
  return {
    ...EMPTY_METRICS,
    sampleTimestampMs: timestamp,
    sampleWindowMs,
    rtpStatsId: mediaId,
    rtpSsrc: ssrc,
    rtpMid: stringValue(media, "mid"),
    rtpRid: stringValue(media, "rid"),
    trackIdentifier,
    selectedCandidatePairId: pair?.id ?? null,
    path,
    natTraversalPath,
    iceProtocol,
    localCandidateType: localType,
    remoteCandidateType: remoteType,
    localCandidateAddress: candidateAddressValue(localCandidate),
    localCandidatePort: candidatePortValue(localCandidate),
    remoteCandidateAddress: candidateAddressValue(remoteCandidate),
    remoteCandidatePort: candidatePortValue(remoteCandidate),
    rttMs:
      numberValue(pair, "currentRoundTripTime") !== null
        ? numberValue(pair, "currentRoundTripTime")! * 1_000
        : numberValue(remoteInbound, "roundTripTime") !== null
          ? numberValue(remoteInbound, "roundTripTime")! * 1_000
          : null,
    bitrateKbps,
    availableOutgoingKbps:
      numberValue(pair, "availableOutgoingBitrate") !== null
        ? numberValue(pair, "availableOutgoingBitrate")! / 1_000
        : null,
    mediaSourceFramesPerSecond: numberValue(mediaSource, "framesPerSecond"),
    framesPerSecond: numberValue(media, "framesPerSecond") ?? derivedFps,
    frameWidth: width,
    frameHeight: height,
    resolution: width !== null && height !== null ? `${width}x${height}` : null,
    packetsLost,
    intervalPacketsSent,
    intervalPacketsReceived,
    intervalPacketsLost,
    packetLossPercent:
      direction === "send"
        ? senderPacketLossPercent
        : packetLossPercentFromDeltas(
            lossPacketsReceivedDelta,
            intervalPacketsLost,
          ),
    jitterMs:
      numberValue(direction === "send" ? remoteInbound : media, "jitter") !== null
        ? numberValue(direction === "send" ? remoteInbound : media, "jitter")! *
          1_000
        : null,
    framesDropped,
    intervalFramesDecoded,
    intervalFramesDropped,
    intervalFreezeCount,
    intervalFreezeDurationMs:
      freezeDurationDelta === null ? null : freezeDurationDelta * 1_000,
    intervalPauseCount,
    intervalPauseDurationMs:
      pauseDurationDelta === null ? null : pauseDurationDelta * 1_000,
    intervalRetransmittedPackets,
    intervalRetransmittedBytes,
    codec: codecEvidence.codec,
    codecProfile: codecEvidence.profile,
    codecParameters: codecEvidence.parameters,
    audioBitrateKbps,
    audioPacketLossPercent: packetLossPercentFromDeltas(
      audioPacketsReceivedDelta,
      audioPacketsLostDelta,
    ),
    audioJitterMs:
      numberValue(audioLossSource, "jitter") !== null
        ? numberValue(audioLossSource, "jitter")! * 1_000
        : null,
    audioVideoPlayoutDeltaMs,
    videoJitterBufferDelayMs,
    audioJitterBufferDelayMs,
    audioConcealedSamplesPercent: percentOfInterval(
      intervalAudioConcealedSamples,
      intervalAudioTotalSamplesReceived,
    ),
    intervalAudioConcealmentEvents,
    audioCodec: stringValue(linkedAudioCodec, "mimeType"),
    audioCodecClockRate: positiveIntegerValue(linkedAudioCodec, "clockRate"),
    audioCodecChannels: positiveIntegerValue(linkedAudioCodec, "channels"),
    audioCodecParameters: audioCodecParameters(linkedAudioCodec),
    scalabilityMode:
      direction === "send" ? scalabilityModeValue(media) : null,
    encoderImplementation: stringValue(media, "encoderImplementation"),
    powerEfficientEncoder: booleanValue(media, "powerEfficientEncoder"),
    intervalFramesEncoded,
    intervalEncodeTimeMs:
      encodeTimeDelta === null ? null : encodeTimeDelta * 1_000,
    intervalEncodeMs,
    intervalDecodeMs,
    qualityLimitationReason,
    nativeEdgeQualityState: currentNativeEdgeQualityState,
  };
}