Method startCaptureStream

app/src/utils/tauriStreamCapture.ts:878–1266

* Start capture with channel-based streaming. * Works on both desktop and iOS - frames are pushed from Rust as they arrive. * * On desktop: Shows selector window, waits for target selection, then starts xcap with channel * On iOS: Triggers ReplayKit picker, then HTTP-received frames are

(targetId?: string)

   * Returns MediaStreams for display and a cleanup function.
   */
  async startCaptureStream(targetId?: string): Promise<CaptureStreamResult> {
    if (!isTauri()) {
      throw new Error('Screen capture only available in Tauri');
    }

    Logger.info("TAURI_STREAM", `Starting channel-based capture stream`);

    // On desktop, show selector and wait for target selection (unless a target is provided
    // explicitly or was pre-seated via setPreselectedTarget).
    let selectedTargetId: string | undefined = targetId ?? this.preselectedTargetId ?? undefined;
    this.preselectedTargetId = null; // consume once
    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 capture with target: ${selectedTargetId || 'default'}`);

    // 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');
    // Initial size - will be adapted to actual frame dimensions
    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');
      }
    }

    // Create MediaStreams from canvases
    const cleanStream = canvasClean.captureStream(30);
    const pipStream = canvasPip ? canvasPip.captureStream(30) : cleanStream;

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

    // Create channels to receive frames and audio from Rust
    const frameChannel = new Channel<FrameData>();
    const audioChannel = new Channel<AudioData>();