feat(windows): pf-vdisplay IDD-push — HDR + pipelined zero-copy capture

HDR (display-driven, matching the WGC path):
- CTA-861.3 HDR EDID (BT.2020 primaries + HDR Static Metadata block) so Windows
  offers "Use HDR" on the virtual display. The host FOLLOWS the display's live
  advanced-color state, recreating the shared ring at the matching format
  (FP16 in HDR / BGRA in SDR) on a toggle — no freeze.
- Always emit Main10/BT.2020-PQ Rgb10a2 while the display is HDR; the client
  auto-detects PQ from the HEVC VUI (clients under-report VIDEO_CAP_10BIT).
  Generic HDR10 mastering SEI on every IDR.
- Generation-tagged `latest` (gen<<40|seq<<8|slot) + driver `is_stale` re-attach
  kill the toggle-time garbage frame and any stale-ring read.

Perf:
- Pipeline the encode loop (Capturer::pipeline_depth; IDD-push = 2): submit N+1
  before polling N so the convert/copy on the 3D engine overlaps the NVENC encode
  of N on the ASIC. PUNKTFUNK_IDD_DEPTH overrides (1 = synchronous).
- Rotating host output ring (OUT_RING) so the in-flight encode and the next
  convert never touch the same texture.
- HDR converts directly from the keyed-mutex slot's SRV into the output ring
  (drops the redundant slot->fp16 scratch copy); SDR copies the BGRA slot in.
  The slot mutex is held only across the convert/copy, not the encode.
  RING_LEN 3->6 for publish headroom.
- Capture-health diagnostic: new_fps vs repeat_fps under PUNKTFUNK_PERF (a low
  new_fps at a high send rate means the source isn't compositing, not an encode
  stall).

Validated live on the RTX box: 5120x1440@240 HDR streams; driver composes
~180 new fps, encode 240 fps @ ~4.3 ms p50.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

packaging/windows/vdisplay-driver/pf-vdisplay/src/logger.rs

@@ -1,12 +1,22 @@
-//! Minimal `log` backend that writes to `OutputDebugString` — no `driver-logger`/event-log/`tokio`.
-//! View with DebugView/WinDbg. Keeping the `log` facade lets the ported callbacks/context use
-//! `error!`/`info!`/`debug!` unchanged.
+//! Minimal `log` backend that writes to `OutputDebugString` AND tees to a file — UMDF redirects a
+//! hosted driver's `OutputDebugString` to ETW (invisible to DebugView), so the file tee is how we
+//! actually read driver logs during bring-up. Keeping the `log` facade lets the ported
+//! callbacks/context use `error!`/`info!`/`debug!` unchanged.
+
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::sync::Mutex;
 
 use log::{LevelFilter, Metadata, Record};
 use windows::core::PCSTR;
 use windows::Win32::System::Diagnostics::Debug::OutputDebugStringA;
 
-struct DbgLogger;
+/// World-writable so the restricted WUDFHost token can append. Read it during bring-up.
+const LOG_PATH: &str = r"C:\Users\Public\pfvd-driver.log";
+
+struct DbgLogger {
+    file: Mutex<()>,
+}
 
 impl log::Log for DbgLogger {
     fn enabled(&self, _metadata: &Metadata) -> bool {
@@ -17,12 +27,19 @@ impl log::Log for DbgLogger {
         let msg = format!("[pf-vdisplay] {:<5} {}\0", record.level(), record.args());
         // SAFETY: `msg` is a NUL-terminated byte string valid for the call.
         unsafe { OutputDebugStringA(PCSTR(msg.as_ptr())) };
+        // Tee to the file (best-effort): the real channel during bring-up.
+        let _guard = self.file.lock();
+        if let Ok(mut f) = OpenOptions::new().create(true).append(true).open(LOG_PATH) {
+            let _ = writeln!(f, "{:<5} {}", record.level(), record.args());
+        }
     }
 
     fn flush(&self) {}
 }
 
-static LOGGER: DbgLogger = DbgLogger;
+static LOGGER: DbgLogger = DbgLogger {
+    file: Mutex::new(()),
+};
 
 pub fn init() {
     let _ = log::set_logger(&LOGGER);
@@ -31,4 +48,8 @@ pub fn init() {
     } else {
         LevelFilter::Info
     });
+    // Boot marker so each load is distinguishable in the file.
+    if let Ok(mut f) = OpenOptions::new().create(true).append(true).open(LOG_PATH) {
+        let _ = writeln!(f, "==== pf-vdisplay logger init ====");
+    }
 }