fix(pyrowave): per-session raw-dmabuf zero-copy capture on the Linux NVIDIA host

A PyroWave session on an NVIDIA-auto host was forced onto CPU-RGB capture
(session_plan flipped gpu=false): Mutter blits tiled->LINEAR, we mmap +
de-pad ~30 MB, the encoder re-uploads it - three full-frame CPU touches
per frame at 5120x1440 while an HEVC session on the same box rides the
tiled EGL/CUDA zero-copy. The dmabuf passthrough + Vulkan tiled import
were already validated (8dc5d672) but only reachable via the global
PUNKTFUNK_ENCODER=pyrowave lab policy.

ZeroCopyPolicy gains pyrowave_session (from OutputFormat.pyrowave, i.e.
the negotiated codec): the capturer skips the NVENC-only EGL->CUDA
importer, takes the raw-dmabuf passthrough, and advertises the wavelet
encoder's Vulkan-importable modifiers so Mutter+NVIDIA negotiates tiled
zero-copy. The forced-CPU flip in session_plan is gone.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/punktfunk-host/src/capture.rs

@@ -26,24 +26,35 @@ pub use pf_capture::{dxgi, synthetic_nv12};
 /// capture→encode cycle). Resolved here (the host facade) and threaded in, so the edge stays one-way
 /// (plan §2.4 / §W6).
 #[cfg(target_os = "linux")]
-fn zero_copy_policy() -> pf_capture::ZeroCopyPolicy {
+fn zero_copy_policy(pyrowave_session: bool) -> pf_capture::ZeroCopyPolicy {
     let backend_is_vaapi = crate::encode::linux_zero_copy_is_vaapi();
+    // The raw-dmabuf passthrough serves a PyroWave session on ANY vendor (the wavelet encoder's
+    // own Vulkan device imports the dmabuf) — per-session from the negotiated codec, plus the
+    // global `PUNKTFUNK_ENCODER=pyrowave` lab lever (which also flips `backend_is_vaapi`).
     #[cfg(feature = "pyrowave")]
-    let pyrowave_modifiers =
-        if backend_is_vaapi && pf_host_config::config().encoder_pref.as_str() == "pyrowave" {
-            // BGRx is the capture path's canonical packed-RGB format (the modifier advertisement keys
-            // on it). `drm_fourcc(Bgrx)` is always `Some`.
-            pf_frame::drm_fourcc(PixelFormat::Bgrx)
-                .map(crate::encode::pyrowave_capture_modifiers)
-                .unwrap_or_default()
-        } else {
-            Vec::new()
-        };
+    let pyrowave_session =
+        pyrowave_session || pf_host_config::config().encoder_pref.as_str() == "pyrowave";
+    #[cfg(not(feature = "pyrowave"))]
+    let pyrowave_session = {
+        let _ = pyrowave_session;
+        false
+    };
+    #[cfg(feature = "pyrowave")]
+    let pyrowave_modifiers = if pyrowave_session {
+        // BGRx is the capture path's canonical packed-RGB format (the modifier advertisement keys
+        // on it). `drm_fourcc(Bgrx)` is always `Some`.
+        pf_frame::drm_fourcc(PixelFormat::Bgrx)
+            .map(crate::encode::pyrowave_capture_modifiers)
+            .unwrap_or_default()
+    } else {
+        Vec::new()
+    };
     #[cfg(not(feature = "pyrowave"))]
     let pyrowave_modifiers = Vec::new();
     pf_capture::ZeroCopyPolicy {
         backend_is_vaapi,
         backend_is_gpu: crate::encode::resolved_backend_is_gpu(),
+        pyrowave_session,
         pyrowave_modifiers,
     }
 }
@@ -57,7 +68,9 @@ pub fn open_portal_monitor(want_hdr: bool) -> Result<Box<dyn Capturer>> {
     // session so it inherits that grant headlessly; wlroots/Sway has no RemoteDesktop portal,
     // so use a plain ScreenCast session there.
     let anchored = crate::inject::default_backend() == crate::inject::Backend::Libei;
-    pf_capture::open_portal_monitor(anchored, want_hdr, zero_copy_policy())
+    // Monitor mirrors never carry the native PyroWave plane (GameStream protocol) — per-session
+    // passthrough is virtual-output-only; the global encoder-pref lever still applies inside.
+    pf_capture::open_portal_monitor(anchored, want_hdr, zero_copy_policy(false))
 }
 
 #[cfg(not(target_os = "linux"))]
@@ -88,7 +101,7 @@ pub fn capture_virtual_output(
         vout.keepalive,
         want.gpu,
         want.chroma_444,
-        zero_copy_policy(),
+        zero_copy_policy(want.pyrowave),
     )
 }
 

crates/punktfunk-host/src/session_plan.rs

@@ -155,36 +155,22 @@ impl SessionPlan {
             }
             gpu && !force_cpu_for_nvenc_444
         };
-        // PyroWave on an NVIDIA-auto host: the `gpu` capture path resolves to the EGL→CUDA
-        // import that only NVENC can consume — the wavelet backend ingests raw dmabufs
-        // (the AMD/Intel path) or CPU RGB. Flip THIS session to CPU RGB capture; the
-        // Phase-2 exit sessions ran exactly this shape at 60 fps (the encode itself stays
-        // sub-ms GPU compute). Per-session raw-dmabuf passthrough on NVIDIA (true
-        // zero-copy without the PUNKTFUNK_ENCODER=pyrowave capture policy) is the
-        // follow-up; the AMD/Intel dmabuf path is untouched.
-        #[cfg(target_os = "linux")]
-        let gpu = {
-            let pyro_needs_cpu = self.codec == crate::encode::Codec::PyroWave
-                && !crate::encode::linux_zero_copy_is_vaapi();
-            if gpu && pyro_needs_cpu {
-                tracing::info!(
-                    "PyroWave session on the NVIDIA capture path: GPU (CUDA) capture disabled \
-                     for this session — frames arrive as CPU RGB and upload to the wavelet \
-                     encoder (raw-dmabuf zero-copy on NVIDIA is a follow-up)"
-                );
-            }
-            gpu && !pyro_needs_cpu
-        };
+        // PyroWave on Linux keeps `gpu = true`: the capture facade sees `pyrowave` below and
+        // routes the session onto the raw-dmabuf passthrough (the wavelet encoder's own Vulkan
+        // device imports the compositor's dmabuf on ANY vendor — `ZeroCopyPolicy::pyrowave_session`
+        // advertises its importable modifiers, so Mutter+NVIDIA negotiates tiled zero-copy instead
+        // of the old forced CPU-RGB readback). The EGL→CUDA importer is skipped there — its
+        // payloads only NVENC consumes.
         crate::capture::OutputFormat {
             gpu,
             hdr: self.hdr,
             // 4:4:4 needs a full-chroma source: on Windows this keeps the capturer on RGB (not the
             // default NV12/P010 video-engine output) so NVENC can CSC to 4:4:4.
             chroma_444: self.chroma.is_444(),
-            // PyroWave (Windows): the IDD-push capturer makes its NV12 out-ring shareable + signals a
-            // shared fence so the wavelet encoder can zero-copy-import the texture into its own Vulkan
-            // device. Inert on Linux (the wavelet backend ingests dmabufs / CPU RGB there — handled
-            // by the `gpu` flips above, not this flag).
+            // PyroWave: on Windows the IDD-push capturer makes its NV12 out-ring shareable + signals
+            // a shared fence so the wavelet encoder can zero-copy-import the texture into its own
+            // Vulkan device; on Linux the capture facade flips the zero-copy policy to the
+            // raw-dmabuf passthrough (see above).
             pyrowave: self.codec == crate::encode::Codec::PyroWave,
         }
     }