refactor(host/W6.2): extract the video encode backends into the pf-encode crate

encode.rs + encode/* (NVENC, VAAPI, native AMF, AMF/QSV ffmpeg, direct-SDK
NVENC/CUDA, raw Vulkan-Video, PyroWave, openh264) move into crates/pf-encode
behind one Encoder trait + open_video selector (plan §W6). The crate speaks the
shared frame vocabulary (pf-frame: CapturedFrame/PixelFormat + the DXGI identity
D3d11Frame/make_device) and pf-zerocopy (CUDA context/buffers), and NEVER
pf-capture — the capture→encode edge is one-way (ZeroCopyPolicy, prior commit).

Dep moves: the heavy encoder deps (ffmpeg-next, the NVENC SDK, openh264,
pyrowave-sys) move from the host to pf-encode; the host's
nvenc/amf-qsv/vulkan-encode/pyrowave features now FORWARD to pf-encode/*. The
host keeps a mod-encode shim (pub use pf_encode) so every crate::encode::* path
(negotiator + GameStream/native/mgmt planes) is unchanged.

resolve_render_adapter_luid moves from the host's windows/win_adapter.rs into
pf-gpu (both pf-encode and pf-capture need it as a peer of GPU selection); its 5
call sites (encode amf/nvenc, capture idd_push/synthetic_nv12, vdisplay manager)
rewire to pf_gpu::resolve_render_adapter_luid and win_adapter.rs is deleted.
pf-frame's make_device gains a # Safety section (public-unsafe-fn lint, latent
since the pf-frame carve — a full-workspace -D warnings clippy catches it).

Verified: Linux clippy -D warnings (pf-encode + host nvenc,vulkan-encode,pyrowave
--all-targets) + 13/13 pf-encode + 299/299 host tests; Windows clippy -D warnings
(pf-encode nvenc,amf-qsv --all-targets + host nvenc,amf-qsv --all-targets)
Finished exit 0.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/pf-encode/src/enc/nvenc_status.rs

@@ -0,0 +1,80 @@
+//! Actionable explanations for `NVENCSTATUS` failures — shared by the direct-SDK NVENC backends on
+//! Windows (`encode/windows/nvenc.rs`) and Linux (`encode/linux/nvenc_cuda.rs`).
+//!
+//! Every NVENC entry-point failure used to be annotated `(no NVIDIA GPU?)`, which actively misled
+//! triage: the direct-NVENC path only loads on a machine that HAS an NVIDIA GPU, and the failure a
+//! user actually hit — `NV_ENC_ERR_INVALID_VERSION` from a userspace/kernel driver version skew,
+//! fixed by a reboot — has nothing to do with a missing GPU. This maps each status to what it really
+//! means and what the operator should do, and folds that cause into the `anyhow::Error` at
+//! construction, so every downstream `{e:#}` log (the encode-recovery loop, session teardown) says
+//! the useful thing without extra plumbing.
+
+use nvidia_video_codec_sdk::sys::nvEncodeAPI as nv;
+
+/// A one-line, operator-actionable cause for an NVENC status. Does not repeat the raw code —
+/// callers print that alongside (see [`call_err`]). Public for the few sites that build a
+/// `String`/`format!` error instead of an `anyhow::Error`.
+pub(super) fn explain(status: nv::NVENCSTATUS) -> String {
+    match status {
+        // The one this whole module exists for: a version word the driver rejects. Either the
+        // driver is genuinely older than our headers, or (the sneaky case) the userspace
+        // `libnvidia-encode` reports a new-enough version to the pre-flight probe but the running
+        // kernel module is older and rejects the session — the classic "updated the driver, didn't
+        // reboot" skew. Both heal the same way.
+        nv::NVENCSTATUS::NV_ENC_ERR_INVALID_VERSION => format!(
+            "the NVIDIA driver is older than this build's NVENC headers (needs NVENC API {}.{} or \
+             newer), or the userspace and kernel-module driver versions are mismatched — common \
+             right after a driver update without a reboot. Update the NVIDIA driver, or reboot if \
+             you just updated it (a host restart is the usual fix).",
+            nv::NVENCAPI_MAJOR_VERSION,
+            nv::NVENCAPI_MINOR_VERSION,
+        ),
+        nv::NVENCSTATUS::NV_ENC_ERR_NO_ENCODE_DEVICE => {
+            "this GPU exposes no usable NVENC engine — it has no hardware video encoder, or NVENC is \
+             disabled on this card"
+                .to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_UNSUPPORTED_DEVICE => {
+            "this GPU model is not supported by NVENC".to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_INVALID_ENCODERDEVICE
+        | nv::NVENCSTATUS::NV_ENC_ERR_INVALID_DEVICE => {
+            "the device/context handed to NVENC is invalid — a GPU reset or driver reload can cause \
+             this"
+                .to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_DEVICE_NOT_EXIST => {
+            "the NVENC device no longer exists — the driver reset, or the GPU fell off the bus"
+                .to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_OUT_OF_MEMORY => "the GPU is out of memory".to_string(),
+        nv::NVENCSTATUS::NV_ENC_ERR_INCOMPATIBLE_CLIENT_KEY => {
+            "NVENC rejected the client key — the GeForce concurrent-NVENC-session limit was reached, \
+             or the driver is unlicensed for this many encoders"
+                .to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_UNIMPLEMENTED
+        | nv::NVENCSTATUS::NV_ENC_ERR_UNSUPPORTED_PARAM => {
+            "this driver/GPU does not implement the requested NVENC encode mode".to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_INVALID_PARAM => {
+            "NVENC rejected a parameter — an encode mode this GPU does not support".to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_ENCODER_BUSY => {
+            "the NVENC engine is busy — retry, or reduce the number of concurrent encode sessions"
+                .to_string()
+        }
+        nv::NVENCSTATUS::NV_ENC_ERR_GENERIC => {
+            "the NVIDIA driver returned a generic NVENC failure — check dmesg and the driver install"
+                .to_string()
+        }
+        other => format!("unexpected NVENC status ({other:?})"),
+    }
+}
+
+/// Build an actionable `anyhow::Error` for a failed NVENC entry-point call. `call` names the API
+/// (e.g. `"open_encode_session_ex"`); the message carries both the raw status and its real-world
+/// cause, so triage never again reads a version mismatch as "(no NVIDIA GPU?)".
+pub(super) fn call_err(call: &str, status: nv::NVENCSTATUS) -> anyhow::Error {
+    anyhow::anyhow!("NVENC {call} failed: {status:?} — {}", explain(status))
+}