feat(hdr): GNOME 50 HDR screencast capture + Linux Main10 encode

GNOME 50 (Mutter MR 4928, PipeWire >= 1.6) added HDR screen sharing for
monitor streams: 10-bit PQ formats (xRGB_210LE/xBGR_210LE) with MANDATORY
BT.2020 + SMPTE-2084 colorimetry props, advertised while the mirrored
monitor is in BT.2100 colour mode. Wire the Linux host into it end-to-end
on the GameStream desktop-mirror path (PUNKTFUNK_VIDEO_SOURCE=portal):

* pf-frame: PixelFormat::X2Rgb10/X2Bgr10 (DRM XR30/XB30; X2Bgr10 is the
  Windows Rgb10a2 layout) + fourccs.
* pf-capture: want_hdr portal offer — HDR-only LINEAR-dmabuf pods with
  MANDATORY PQ/BT.2020 props (SHM excluded: Mutter's SHM record path
  paints 8-bit ARGB32 regardless of format; tiled excluded: the EGL
  de-tile blit is 8-bit RGBA8), negotiated-colorimetry parse, generic
  HDR10 hdr_meta(), packed-10-bit CPU cursor blend, a process-wide SDR
  downgrade latch on negotiation timeout, and a DisplayConfig BT.2100
  colour-mode probe (gnome_hdr_monitor_active).
* pf-encode: libav NVENC X2RGB10->P010 swscale (BT.2020 limited) ->
  HEVC Main10 / 10-bit AV1 with PQ VUI; VAAPI 10-bit on both paths (CPU
  P010 upload + dmabuf XR30 scale_vaapi p010/bt2020); can_encode_10bit
  now probes for real on Linux; 10-bit sessions route around the
  8-bit-only Vulkan-video/direct-NVENC backends.
* GameStream: host_hdr_capable() Linux arm, live monitor-HDR check at
  RTSP honor time, capturer-pool reuse keyed on HDR-ness, gs_bit_depth
  covers the new formats. New `punktfunk-host hdr-probe` diagnostic and
  a PUNKTFUNK_SPIKE_HDR spike lever.
* Native plane stays honestly 8-bit via capturer_supports_hdr(): Mutter
  RecordVirtual streams are SDR-only upstream (GNOME 50 and 51-dev), so
  virtual-display sources cannot deliver HDR yet.

Validated on the RTX 5070 Ti (GNOME 50.3 / PipeWire 1.6.8): the Main10
probes pass and the ignored nvenc_hdr10_smoke GPU test emits an IDR that
ffprobe reads as Main 10 / yuv420p10le / bt2020nc / smpte2084 / limited.
Live HDR capture negotiation still needs an HDR monitor on glass; VAAPI
10-bit needs the AMD box.

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

crates/punktfunk-host/src/gamestream/stream.rs

@@ -34,8 +34,9 @@ pub struct StreamConfig {
 }
 
 /// Slot for the persistent screen capturer, shared with the control plane and reused across
-/// streams so a reconnect doesn't open a second (conflicting) screencast session.
-pub type CapturerSlot = Arc<std::sync::Mutex<Option<Box<dyn Capturer>>>>;
+/// streams so a reconnect doesn't open a second (conflicting) screencast session. The `bool` is
+/// the pooled capturer's HDR-ness (see `AppState::video_cap`).
+pub type CapturerSlot = Arc<std::sync::Mutex<Option<(Box<dyn Capturer>, bool)>>>;
 
 /// A pending client reference-frame-invalidation range (lost `firstFrame..=lastFrame`), set by the
 /// control plane and drained by the video thread (see [`AppState::rfi_range`](super::AppState)).
@@ -120,7 +121,7 @@ fn run(
     running: &Arc<AtomicBool>,
     force_idr: &AtomicBool,
     rfi_range: &std::sync::Mutex<Option<(i64, i64)>>,
-    video_cap: &std::sync::Mutex<Option<Box<dyn Capturer>>>,
+    video_cap: &std::sync::Mutex<Option<(Box<dyn Capturer>, bool)>>,
     // Shared stats recorder for the web-console capture/graph. Threaded into `stream_body` (the
     // encode loop); per-frame sample emission is wired by a later pass.
     stats: &Arc<crate::stats_recorder::StatsRecorder>,
@@ -243,15 +244,31 @@ fn run(
     }
 
     // Reuse the persistent capturer (one screencast session → clean reconnect); create it on
-    // the first stream. Borrow it for this stream and return it on exit.
-    let mut capturer: Box<dyn Capturer> = match video_cap.lock().unwrap().take() {
+    // the first stream. Borrow it for this stream and return it on exit. Reuse is gated on the
+    // pooled capturer's HDR-ness matching this stream's negotiated `cfg.hdr` — the depth is a
+    // PipeWire-negotiation-time property of the screencast session, so an HDR↔SDR change needs a
+    // fresh session (same pattern as the audio capturer's channel-count gate).
+    let pooled = match video_cap.lock().unwrap().take() {
+        Some((c, was_hdr)) if was_hdr == cfg.hdr => Some(c),
+        Some((c, was_hdr)) => {
+            tracing::info!(
+                was_hdr,
+                want_hdr = cfg.hdr,
+                "video source: pooled capturer depth mismatch — opening a fresh screencast session"
+            );
+            drop(c);
+            None
+        }
+        None => None,
+    };
+    let mut capturer: Box<dyn Capturer> = match pooled {
         Some(c) => {
             tracing::info!("video source: reusing capturer");
             c
         }
         None if pf_host_config::config().video_source.as_deref() == Some("portal") => {
-            tracing::info!("video source: portal desktop capture");
-            capture::open_portal_monitor().context("open portal capturer")?
+            tracing::info!(hdr = cfg.hdr, "video source: portal desktop capture");
+            capture::open_portal_monitor(cfg.hdr).context("open portal capturer")?
         }
         None => {
             tracing::info!("video source: synthetic test pattern");
@@ -272,7 +289,7 @@ fn run(
         &client_label,
     );
     capturer.set_active(false);
-    *video_cap.lock().unwrap() = Some(capturer);
+    *video_cap.lock().unwrap() = Some((capturer, cfg.hdr));
     result
 }
 
@@ -380,7 +397,9 @@ fn open_gs_virtual_source(
     // HDR: pass the negotiated `cfg.hdr` (client asked for HDR AND the host can deliver it). On the
     // Windows IDD-push path this proactively enables advanced color on the virtual display so a Main10
     // PQ stream flows even from an SDR desktop; an already-HDR desktop streams PQ regardless (the
-    // capturer follows the display). No-op on Linux (8-bit, and `cfg.hdr` is always false there).
+    // capturer follows the display). No-op on Linux: virtual-output capture is SDR-only upstream
+    // (Mutter RecordVirtual), and `host_hdr_capable` therefore keeps `cfg.hdr` false for this
+    // source — the Linux HDR path is the portal monitor mirror (`video_source=portal`).
     let capturer = capture::capture_virtual_output(
         vout,
         capture::OutputFormat::resolve(cfg.hdr, crate::encode::resolved_backend_is_gpu()),
@@ -399,7 +418,11 @@ fn open_gs_virtual_source(
 fn gs_bit_depth(format: crate::capture::PixelFormat) -> u8 {
     use crate::capture::PixelFormat;
     match format {
-        PixelFormat::P010 | PixelFormat::Rgb10a2 => 10,
+        // Windows IDD-push HDR formats, and the Linux GNOME 50+ portal HDR formats.
+        PixelFormat::P010
+        | PixelFormat::Rgb10a2
+        | PixelFormat::X2Rgb10
+        | PixelFormat::X2Bgr10 => 10,
         _ => 8,
     }
 }