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

22.1 KB
Raw Blame
import { createOpaqueId } from "../lib/opaque-id";
import { browserDebugEnabled, debugError, debugEvent } from "../lib/debug";
import { EMPTY_METRICS, type ConnectionMetrics } from "../types";
import { captureMetrics, collectConnectionMetricsFromReport, createStatsAccumulator } from "../webrtc/stats";
import { waitForConnectionOperation } from "../webrtc/connection-operation";
import { BrowserEncodingProducer } from "./browser-encoding-producer";
import { BROWSER_CARRIER_SIZE, type BrowserEncodingOutput } from "./browser-encoding-output";
import { codecIdentity, fits, nativeVideoBudget, negotiatedCodec, noRegression, observeVideo,
  projectEncodingMetrics, videoOutbound, type Observation } from "./browser-encoding-stats";
import { videoQualitySettingsEqual, type QualityProfile } from "./quality";

export interface BrowserPooledSender {
  updateProfile(profile: QualityProfile): Promise<void>;
  carrierScale(): number | undefined;
  setPaused(paused: boolean): void;
  metrics(transport: ConnectionMetrics): ConnectionMetrics;
  dispose(): void;
}

type Output = ReturnType<BrowserEncodingOutput["snapshot"]>;
type Group = {
  producer: BrowserEncodingProducer; source: MediaStreamTrack; profile: QualityProfile;
  codecKey: string; budget: number; ready: boolean; failed: boolean;
  report?: RTCStatsReport; previous?: RTCOutboundRtpStreamStats; output?: Observation;
  updating?: Promise<void>;
};
type Member = {
  id: string; source: MediaStreamTrack; sender: RTCRtpSender; connection: RTCPeerConnection;
  profile: QualityProfile; encoded: BrowserEncodingOutput;
  configureCarrier: () => Promise<boolean>;
  requestKey: () => Promise<void>; onFatal: () => void;
  paused: boolean; disabled: boolean; readonly disposed: boolean; abort: AbortController; mixed: boolean; carrier: boolean;
  codec?: RTCRtpCodec; codecKey?: string; budget?: number; raw?: RTCOutboundRtpStreamStats;
  encoderStats: ReturnType<typeof createStatsAccumulator>;
  current?: Group; pending?: { group: Group; selecting?: boolean };
  output?: Output; previousOutput?: Output; replacement?: Promise<void>;
};

// M152 exposes BWE through getStats, not a bandwidth callback. The paired
// weak-entry probe bounds observation lag at this cadence; it is not a retry.
const BUDGET_SAMPLE_MS = 500;

/** One owner per captured source tree; connections retain their own RTP and transport. */
export class BrowserEncodingPool {
  private readonly members = new Set<Member>();
  private readonly groups = new Set<Group>();
  private readonly failedSources = new WeakSet<MediaStreamTrack>();
  private timer: ReturnType<typeof setInterval> | undefined;
  private polling = false;
  private disposed = false;

  create(source: MediaStreamTrack, sender: RTCRtpSender, connection: RTCPeerConnection,
    profile: QualityProfile, encoded: BrowserEncodingOutput, configureCarrier: Member["configureCarrier"], requestKey: Member["requestKey"],
    onFatal: () => void): BrowserPooledSender | null {
    if (this.disposed || this.failedSources.has(source) || source.kind !== "video" || source.readyState !== "live") return null;
    const member: Member = { id: createOpaqueId(), source, sender, connection, profile: { ...profile }, encoded, configureCarrier, requestKey, onFatal,
      paused: !source.enabled, disabled: false, abort: new AbortController(),
      get disposed() { return this.abort.signal.aborted; }, mixed: false, carrier: encoded.snapshot().frames === 0,
      encoderStats: createStatsAccumulator() };
    this.members.add(member);
    // A fresh connection has no useful raw output to preserve. Start its
    // tiny clock immediately, rather than warming two full encoders first.
    if (!member.carrier) encoded.passthrough(requestKey);
    if (!this.timer) this.timer = setInterval(() => void this.poll(), BUDGET_SAMPLE_MS);
    return {
      carrierScale: () => {
        if (!member.carrier) return;
        const width = member.sender.track?.getSettings().width ?? member.profile.resolution.width;
        return Math.max(1, width / BROWSER_CARRIER_SIZE);
      },
      updateProfile: async (next) => {
        if (member.disposed || videoQualitySettingsEqual(member.profile, next)) return;
        member.profile = { ...next };
        member.encoderStats = createStatsAccumulator(); member.previousOutput = undefined;
        // HostPeer awaits this inside its sender queue. Handoffs run outside it.
      },
      setPaused: (paused) => {
        if (member.disposed || member.paused === paused) return;
        member.paused = paused;
        member.previousOutput = undefined;
        this.updatePauses();
      },
      metrics: (transport) => this.metrics(member, transport),
      dispose: () => this.remove(member),
    };
  }

  dispose(): void {
    this.disposed = true;
    for (const member of [...this.members]) this.remove(member);
    this.prune();
  }

  private compatible(member: Member, group: Group): boolean {
    return member.source === group.source && member.codecKey === group.codecKey &&
      videoQualitySettingsEqual(member.profile, group.profile) && !group.failed;
  }

  private references(group: Group): Member[] {
    return [...this.members].filter((member) => member.current === group || member.pending?.group === group);
  }

  private demand(group: Group, except?: Member): number | undefined {
    const budgets = this.references(group).flatMap((member) => member !== except &&
      this.compatible(member, group) && member.budget !== undefined ? [member.budget] : []);
    return budgets.length ? Math.max(...budgets) : undefined;
  }

  private hasHigherDemand(member: Member, group: Group): boolean {
    return (this.demand(group) ?? 0) > member.budget!;
  }

  private canJoin(member: Member, group: Group): boolean {
    // A pending newcomer cannot prove compatibility with its own demand or
    // raise the incumbent owner's allocation merely to reuse its encoder.
    const demand = this.demand(group, member);
    return demand === undefined || demand === member.budget;
  }

  private canReuse(member: Member, group: Group, current: Group): boolean {
    const output = group.output, previous = current.output;
    // A quiet scene does not make a higher rate owner compatible. Check both
    // allocations before pending membership can raise the candidate's budget.
    return this.compatible(member, group) && this.canJoin(member, group) &&
      group.budget <= member.budget! && group.budget >= current.budget &&
      fits(output, member.budget) && output?.reason === "none" && !!previous &&
      noRegression(output, previous.width, previous.height, previous.fps, member.profile);
  }

  private acceptsFrame(member: Member, group: Group, metadata: RTCEncodedVideoFrameMetadata): boolean {
    if (member.disabled || member.paused || !this.compatible(member, group) || group.updating ||
      member.budget === undefined || group.budget > member.budget || !this.canJoin(member, group)) return false;
    const current = member.current;
    const optional = current && this.compatible(member, current) &&
      !this.hasHigherDemand(member, current);
    // Initial output and necessary downgrades have no healthy picture to beat.
    if (current ? !optional : member.carrier) return true;
    const actual = member.encoded.snapshot();
    if (actual.lastProducerId !== (current?.producer.id ?? null)) return false;
    if (!metadata.width || !metadata.height || actual.width === null || actual.height === null ||
      metadata.width < actual.width || metadata.height < actual.height) {
      // A real key can disprove the last statistics sample. Do not let another
      // reconciliation reuse that sample before the normal poll replaces it.
      group.output = undefined;
      return false;
    }
    return current ? this.canReuse(member, group, current) : !!group.output &&
      noRegression(group.output, actual.width, actual.height, member.raw?.framesPerSecond ?? null, member.profile);
  }

  private async poll(): Promise<void> {
    if (this.polling || this.disposed) return;
    this.polling = true;
    try {
      await Promise.allSettled([
        ...[...this.members].map(async (member) => {
          if (member.disposed || member.disabled || member.connection.connectionState !== "connected") { member.budget = undefined; return; }
          const report = await waitForConnectionOperation(member.abort.signal, () => member.connection.getStats()).catch(() => null);
          if (member.disposed) return;
          if (!report) { member.budget = undefined; return; }
          const codec = negotiatedCodec(report);
          if (!codec) {
            if (member.current || member.pending) this.fallback(member);
            else {
              const outbound = videoOutbound(report);
              if (outbound?.codecId && report.get(outbound.codecId)) this.fallback(member);
            }
            return;
          }
          const key = codecIdentity(codec);
          if (member.codecKey && member.codecKey !== key && (member.current || member.pending)) {
            this.fallback(member); return;
          }
          member.codec = codec; member.codecKey = key;
          member.raw = videoOutbound(report);
          member.budget = nativeVideoBudget(member.raw, member.profile.maxBitrate);
        }),
        ...[...this.groups].map(async (group) => {
          if (!group.ready || group.failed) { group.output = undefined; return; }
          const report = await group.producer.report().catch(() => null);
          if (!this.groups.has(group)) return;
          if (!report) { group.output = undefined; return; }
          group.report = report;
          const video = videoOutbound(report);
          group.output = observeVideo(video, group.previous);
          group.previous = video;
        }),
      ]);
      if (this.disposed) return;
      this.reconcile();
      for (const member of this.members) {
        member.output = member.encoded.snapshot();
        if (!member.pending && !member.replacement && member.output.frames > 0 &&
          member.output.lastProducerId === (member.current?.producer.id ?? null)) member.mixed = false;
      }
      if (browserDebugEnabled) debugEvent("encoding-pool", "sample", {
        members: [...this.members].map((member) => ({ memberId: member.id, trackId: member.source.id,
          rtpStatsId: member.raw?.id, ssrc: member.raw?.ssrc,
          producerId: member.current?.producer.id, pendingProducerId: member.pending?.group.producer.id,
          budget: member.budget, carrier: member.carrier, paused: member.paused, disabled: member.disabled, output: member.output })),
        groups: [...this.groups].map((group) => ({ producerId: group.producer.id, budget: group.budget,
          ready: group.ready, failed: group.failed, output: group.output })),
      });
    } finally { this.polling = false; }
  }

  private reconcile(): void {
    // Remove obsolete requests before they can displace a current member in
    // this pass. Applied rates may still belong to the previous stats sample.
    for (const member of this.members) {
      if (member.pending && member.budget !== undefined && !this.canJoin(member, member.pending.group) &&
        member.encoded.cancelSelection(member.pending.group.producer.id)) member.pending = undefined;
    }
    const changing = new Set<Group>();
    for (const group of this.groups) {
      const references = this.references(group);
      const profile = references[0]?.profile;
      if (!profile || group.failed || videoQualitySettingsEqual(profile, group.profile) ||
        !references.every((member) => member.source === group.source && member.codecKey === group.codecKey &&
          videoQualitySettingsEqual(member.profile, profile))) continue;
      changing.add(group);
      if (!group.ready || group.updating) continue;
      for (const member of references) if (member.current === group && member.pending && !member.pending.selecting) member.pending = undefined;
      const next = { ...profile };
      const budget = Math.min(next.maxBitrate, Math.max(...references.map((member) => member.budget ?? group.budget)));
      group.budget = budget;
      group.updating = group.producer.update(next, budget).then(() => {
        if (!this.groups.has(group)) return;
        group.profile = next;
        for (const member of this.members) if (member.current === group || member.pending?.group === group) {
          member.encoderStats = createStatsAccumulator(); member.previousOutput = undefined;
        }
      }).catch(() => {
        if (this.groups.has(group)) this.failSource(group.source);
      }).finally(() => { group.updating = undefined; });
    }
    for (const member of this.members) {
      if (member.disposed || member.disabled || member.paused || member.replacement || !member.codec || member.budget === undefined) continue;
      if ([member.current, member.pending?.group].some((group) => group && (group.updating || changing.has(group)))) continue;
      if (member.pending) {
        const pending = member.pending;
        // A shared producer can outgrow a waiting child's native allocation.
        // Replan that membership; never wait forever for its budget to catch up.
        if (!pending.selecting && pending.group.budget > member.budget &&
          this.references(pending.group).some((other) => other !== member)) {
          member.pending = undefined;
          continue;
        }
        if (!pending.selecting && member.current && this.compatible(member, member.current) &&
          !this.hasHigherDemand(member, member.current) && !this.canReuse(member, pending.group, member.current)) {
          member.pending = undefined;
          continue;
        }
        if (!pending.selecting && !this.compatible(member, pending.group)) {
          member.pending = undefined;
          continue;
        }
        const ownedBudget = pending.group.budget <= member.budget;
        // The output already waits for a real recovery frame. A rate-owned
        // downgrade need not wait another statistics window while the old
        // high-rate output keeps congesting the same path.
        if (!pending.selecting && pending.group.ready &&
          (fits(pending.group.output, member.budget) || ((member.current || member.carrier) && ownedBudget))) {
          const output = pending.group.output;
          // A fresh carrier has delivered no picture. Its tiny encode cannot
          // establish a quality baseline for the first real output.
          if (member.current || member.carrier || (output && noRegression(output, member.raw?.frameWidth ?? null,
            member.raw?.frameHeight ?? null, member.raw?.framesPerSecond ?? null, member.profile))) {
            pending.selecting = true;
            member.mixed = true;
            member.encoded.select(pending.group.producer.id, () => pending.group.producer.requestKey(), () => {
              if (member.disposed || member.pending !== pending) return;
              member.current = pending.group;
              pending.group.producer.beginOutput();
              member.pending = undefined;
              member.encoderStats = createStatsAccumulator(); member.previousOutput = undefined;
              member.carrier = true;
              member.replacement = member.configureCarrier().then((applied) => {
                if (!applied) this.fallback(member);
              }).catch(() => this.fallback(member)).finally(() => { member.replacement = undefined; });
              this.prune();
            }, (metadata) => {
              if (member.disposed || member.pending !== pending) return false;
              if (this.acceptsFrame(member, pending.group, metadata)) return true;
              member.pending = undefined;
              this.prune();
              return false;
            });
          }
        }
        continue;
      }
      const current = member.current;
      if (current && this.compatible(member, current) &&
        (!current.output || current.output.bitrate === 0 || current.output.fps === 0)) continue;
      if (current?.output && this.compatible(member, current) && fits(current.output, member.budget)) {
        // Equal outputs converge to the earlier owner. A strictly better healthy
        // output is also reusable when this encoder has not recovered itself.
        let earlier = true;
        for (const group of this.groups) {
          if (group === current) { earlier = false; continue; }
          // A newer output must improve within the same Host ceilings used below.
          const improves = group.output && current.output && !noRegression(current.output,
            group.output.width, group.output.height, group.output.fps, member.profile);
          if ((earlier || improves) && this.canReuse(member, group, current)) {
            member.pending = { group }; break;
          }
        }
        continue;
      }
      // A short output-rate spike is not new demand. Keep the rate owner and
      // let its native encoder adapt unless another child needs a higher rate.
      if (current && this.compatible(member, current) && !this.hasHigherDemand(member, current)) continue;
      const candidates = [...this.groups].filter((group) => group !== current && this.compatible(member, group) &&
        this.demand(group) === member.budget);
      let target = candidates.find((group) => fits(group.output, member.budget)) ?? candidates[0];
      if (!target) {
        target = this.startGroup(member, member.budget);
      }
      member.pending = { group: target };
    }
    for (const group of this.groups) {
      const budget = this.demand(group);
      if (group.ready && budget !== undefined) {
        if (budget !== group.budget && !group.updating) {
          group.budget = budget;
          group.updating = group.producer.update(group.profile, budget).catch(() => {
            if (this.groups.has(group)) this.failSource(group.source);
          })
            .finally(() => {
              group.updating = undefined;
              // A ready downgrade can use this applied budget now. Waiting for
              // another sample compares the previous limit to falling demand again.
              if (!this.disposed && this.groups.has(group)) this.reconcile();
            });
        }
      }
    }
    this.updatePauses();
    this.prune();
  }

  private startGroup(member: Member, budget: number): Group {
    const profile = { ...member.profile };
    const producer = new BrowserEncodingProducer(member.source, profile, member.codec!, (frame) => {
      for (const output of this.members) if (output.current === group || output.pending?.group === group) {
        output.encoded.push(producer.id, frame);
      }
    },
      () => { group.failed = true; this.failSource(member.source); });
    const group: Group = { producer, source: member.source, profile, codecKey: member.codecKey!, budget, ready: false, failed: false };
    this.groups.add(group);
    debugEvent("encoding-pool", "producer-preparing", { producerId: producer.id, trackId: member.source.id, codec: member.codecKey, budget, profile });
    void producer.start(budget).then(() => {
      if (!this.groups.has(group)) return;
      group.ready = true;
      this.reconcile();
    }, (error) => {
      debugError("encoding-pool", "producer-start-failed", error, { producerId: producer.id });
      if (this.groups.has(group)) { group.failed = true; this.failSource(group.source); }
    });
    return group;
  }

  private restore(member: Member): void {
    if (member.disposed) return;
    member.mixed = true;
    member.pending = undefined;
    member.carrier = false;
    member.replacement = member.configureCarrier().then((applied) => {
      if (member.disposed) return;
      if (!applied) { member.onFatal(); return; }
      member.encoded.passthrough(member.requestKey);
      member.current = undefined;
      member.encoderStats = createStatsAccumulator(); member.previousOutput = undefined;
    }).catch(() => { if (!member.disposed) member.onFatal(); })
      .finally(() => { member.replacement = undefined; this.prune(); });
  }

  // Negotiated compatibility belongs to one connection. Its ordinary sender
  // remains available without retiring a healthy sibling's shared producer.
  private fallback(member: Member): void {
    if (member.disabled || member.disposed) return;
    member.disabled = true;
    if (member.replacement) void member.replacement.then(() => this.restore(member));
    else this.restore(member);
  }

  private failSource(source: MediaStreamTrack): void {
    if (this.failedSources.has(source)) return;
    this.failedSources.add(source);
    for (const member of this.members) if (member.source === source) this.fallback(member);
  }

  private updatePauses(): void {
    for (const group of this.groups) group.producer.setPaused(!this.references(group).some((member) => !member.paused));
  }

  private metrics(member: Member, transport: ConnectionMetrics): ConnectionMetrics {
    if (member.disposed || (!member.current && !member.mixed)) return transport;
    const group = member.current, input = group?.producer.track, sample = member.output, previous = member.previousOutput;
    member.previousOutput = sample;
    const measured = !member.mixed && !member.paused && input && group?.report && !group.failed && sample?.lastProducerId === group.producer.id &&
      previous?.lastProducerId === group.producer.id && sample.timestamp > previous.timestamp;
    const encoder = measured ? { ...collectConnectionMetricsFromReport(group.report!, "send", member.encoderStats),
      ...captureMetrics(input) } : EMPTY_METRICS;
    const qualityEligible = !!measured && !member.pending && !group.updating && this.compatible(member, group) &&
      (encoder.nativeEdgeQualityState === "degraded" || fits(group.output, member.budget));
    return projectEncodingMetrics(transport, encoder, measured ? sample : undefined, measured ? previous : undefined, qualityEligible);
  }

  private remove(member: Member): void {
    if (member.disposed) return;
    member.abort.abort();
    this.members.delete(member);
    member.encoded.passthrough(member.requestKey);
    member.carrier = false;
    member.current = undefined; member.pending = undefined;
    this.prune();
  }

  private prune(): void {
    for (const group of this.groups) if (!this.references(group).length) {
      this.groups.delete(group); group.producer.dispose();
    }
    if (!this.members.size) {
      if (this.timer) clearInterval(this.timer);
      this.timer = undefined;
    }
  }
}