Method startVideoStream

app/src/utils/tauriStreamCapture.ts:463–658

* Start video-only capture stream. * Independent from audio - use startAudioStream separately if you also need audio. * Works on both desktop and iOS.

(targetId?: string)

   * Works on both desktop and iOS.
   */
  async startVideoStream(targetId?: string): Promise<VideoStreamResult> {
    if (!isTauri()) {
      throw new Error('Screen capture only available in Tauri');
    }

    Logger.info("TAURI_STREAM", `Starting video-only capture stream`);

    // Desktop: Show selector and wait for target selection (unless a target is provided
    // explicitly or was pre-seated via setPreselectedTarget). iOS: ReplayKit picker later.
    let selectedTargetId: string | undefined = targetId ?? this.preselectedTargetId ?? undefined;
    this.preselectedTargetId = null; // consume once, regardless of platform
    if (isDesktop() && !selectedTargetId) {
      const selected = await this.waitForTargetSelection();
      if (!selected) {
        throw new Error('Screen capture cancelled by user');
      }
      selectedTargetId = selected;
    }

    Logger.info("TAURI_STREAM", `Starting video capture with target: ${selectedTargetId || 'iOS broadcast'}`);

    // Clean canvas (for AI/recording/preview). The PiP canvas only exists on mobile,
    // where the status/timer overlay is baked into a separate stream. On desktop the
    // overlay never draws (it's mobile-only), so a PiP canvas would be a pixel-identical
    // copy of clean — a wasted per-frame drawImage plus a second canvas.captureStream()
    // read-back. So on desktop we skip it and reuse the clean stream for the with-pip slot.
    const usePip = !isDesktop();

    const canvasClean = document.createElement('canvas');
    canvasClean.width = 1920;
    canvasClean.height = 1080;
    const ctxClean = canvasClean.getContext('2d');
    if (!ctxClean) {
      throw new Error('Failed to create canvas context');
    }

    const canvasPip = usePip ? document.createElement('canvas') : null;
    const ctxPip = canvasPip ? canvasPip.getContext('2d') : null;
    if (canvasPip) {
      canvasPip.width = 1920;
      canvasPip.height = 1080;
      if (!ctxPip) {
        throw new Error('Failed to create PiP canvas context');
      }
    }

    const cleanStream = canvasClean.captureStream(30);
    const pipStream = canvasPip ? canvasPip.captureStream(30) : cleanStream;

    let canvasSizeInitialized = false;
    let frameCount = 0;
    let isActive = true;

    const frameChannel = new Channel<FrameData>();

    // Coalescing decode pump: we only ever hold the NEWEST undecoded frame and decode
    // one at a time. If frames arrive faster than we can decode+draw, the intermediate
    // ones are dropped instead of queuing — so latency stays at ~one frame no matter how