From 9d3b3da3f56802656808ebf671f2cc23f1a50646 Mon Sep 17 00:00:00 2001 From: Jeff Zhang Date: Fri, 23 Oct 2026 15:24:31 +0800 Subject: [PATCH] Video: probe the auto encoder in the background (NVENC then CPU) (#93) Refs #85 (step 2). --- AGENTS.md | 10 +- README.en.md | 25 +- README.md | 13 +- src/capture_setting.rs | 22 +- src/doctor.rs | 14 ++ src/main.rs | 3 + src/video.rs | 202 ++++++++++++++-- src/video_select.rs | 519 ++++++++++++++++++++++++++++++++++++++-- src/video_wake_tests.rs | 2 +- 9 files changed, 752 insertions(+), 58 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index f6275ea..10f1dde 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -122,7 +122,7 @@ viewer does not reconnect them automatically. | Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super | | `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) | | `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` | -| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset/`auto`: NVENC only if `/proc/driver/nvidia/version` or `/dev/nvidia0` exists, else CPU (#10). Ignored when `host_settings.json` `video_encoder` is not `auto` | +| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset/`auto`: background probe, one synthetic IDR per candidate, 3 s each. While #33 is open, auto is NVENC then CPU when `/proc/driver/nvidia/version` or `/dev/nvidia0` exists; with no NVIDIA the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the legacy rule (NVENC if NVIDIA is present, else CPU). On `--features inproc-av`, a process-only failure of NVENC when the native engine would try it first on X11 is `native_unprobed` and keeps that legacy NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence (`/proc/driver/nvidia/version` or `/dev/nvidia0`) matches the report. A later desktop connection whose presence differs treats the report as stale and starts one background re-probe (`warm_auto_probe`, non-blocking, one at a time) and still uses the cached encoder. A hardware-candidate failure (NVENC failed, chosen CPU) is cached for 10 minutes (`PROBE_FAILURE_TTL`); the next desktop connection after that starts the same re-probe and still uses the cached encoder. Explicit `cpu` / `vaapi` / `nvenc` (setting file or `UU_VIDEO_ENCODER`) does not start the probe. A later success selects NVENC again; another failure restarts the 10 minutes. `native_unprobed` is not a failure cache. Ignored when `host_settings.json` `video_encoder` is not `auto`. Explicit `vaapi` with 真彩 encodes 4:2:0 and reports that in CaptureSettingSync (field 3). VAAPI is not an auto candidate until #33 | | `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it and the encoder is hardware). Same precedence as the encoder: setting file, then this variable, then auto | | `UU_FFMPEG_ROOT` | FFmpeg prefix (`bin/ffmpeg`, libs in `lib/x86_64-linux-gnu`) | | `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) | @@ -277,10 +277,12 @@ started a second full host server instead, so check that a subcommand exists in - Update README.md / README.en.md when user-visible features or limitations change, and add `docs/release-notes/.md` before tagging a release. -### VAAPI (opt-in / 显式启用) +### VAAPI -`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to -`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection. +`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly. +`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required). +Auto is NVENC then CPU when an NVIDIA driver is present, otherwise CPU. VAAPI is not an +auto candidate until #33. The FFmpeg process pipeline uploads NV12 frames to a VAAPI frame pool. With `--features inproc-av` on X11, VAAPI H.264/HEVC Main runs in process: a DRI3 DMA-BUF of the root (XShm upload without DRI3) goes through VPP to NV12 and VCN, with SPS/PPS(/VPS) and slice headers packed by the host as radeonsi (Mesa 26) needs; parameters follow diff --git a/README.en.md b/README.en.md index 86bbdeb..926bc02 100644 --- a/README.en.md +++ b/README.en.md @@ -337,7 +337,7 @@ Common environment variables: | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) | | `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` | | `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows | -| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: NVENC only when an NVIDIA driver is loaded, else CPU. A non-`auto` `video_encoder` in `host_settings.json` wins | +| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 | | `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution | | `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix | | `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source | @@ -353,10 +353,17 @@ Host settings such as "lock after remote session" and "mute host" are stored in (`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by `uuremote-server set-encoder` and `uuremote-server set-codec` (illegal arguments exit 2). A value other than `auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`; `auto` or a missing -field falls through to the environment, then to the default (NVENC when an NVIDIA driver is -loaded, otherwise CPU; codec stays H.265 on hardware and H.264 on CPU). They take effect the -next time a desktop connection starts. Explicit `vaapi` has no 4:4:4 and the stream drops to -4:2:0. If the chosen encoder cannot start, the stream falls back to CPU and logs a warning. +field falls through to the environment, then to auto (NVENC then CPU when an NVIDIA driver +is loaded; CPU with no probe when it is not; codec stays H.265 on hardware and H.264 on CPU). +The probe runs in the background at startup and does not delay the first picture. A success +stays cached until the process exits, except when NVIDIA presence (`/proc/driver/nvidia/version` +or `/dev/nvidia0`) no longer matches the report: the next desktop connection then starts one +background re-probe (`warm_auto_probe`) and still uses the cached encoder until the new result +is stored. An NVENC failure is kept for 10 minutes, and the next desktop connection after that +starts the same background re-probe while still using the cached encoder. They take effect the next time a desktop connection starts. Explicit `vaapi` with 真彩 stays on VAAPI, +encodes 4:2:0, and reports chroma 4:2:0 in CaptureSettingSync field 3. If the chosen encoder +cannot start, the stream falls back to CPU and logs a warning. VAAPI is not an auto candidate +until #33. Custom bitrate follows the Mbps value selected in the client; for example, 1 Mbps sets an encoder cap of 1000 kbit/s. @@ -434,10 +441,12 @@ AUD only at IRAPs and drops every other picture from the bitstream, so an AUD-ba one "frame" and the IRAP gate then rejects all of them: the connection stalls at "transferring" while the host sends about 12 kbit/s. `UU_VIDEO_CODEC=h265` selects H.265 explicitly for A/B diagnosis. -### VAAPI (opt-in / 显式启用) +### VAAPI -`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to -`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection. +`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly. +`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required). +`auto` is NVENC then CPU when an NVIDIA driver is present, and CPU otherwise. VAAPI is +selected only explicitly; putting it in auto waits on #33. The FFmpeg process uploads NV12 frames to a VAAPI frame pool; a self-built `--features inproc-av` binary instead runs VAAPI in process on X11 (a DRI3 DMA-BUF of the root window zero-copy, or XShm upload without DRI3, then VPP to NV12 and VCN; H.264/HEVC). diff --git a/README.md b/README.md index 9415e55..471edb7 100644 --- a/README.md +++ b/README.md @@ -306,7 +306,7 @@ systemctl --user restart uuremote-native.service | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) | | `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` | | `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 | -| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时检测到 NVIDIA 驱动才用 NVENC,否则用 CPU。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder` | +| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto | | `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 | | `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg | | `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 | @@ -317,7 +317,7 @@ systemctl --user restart uuremote-native.service | `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) | | `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 | -「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到默认(有 NVIDIA 驱动用 NVENC,否则 CPU;codec 仍是硬件优先 H.265、CPU 用 H.264)。下次建立桌面连接时生效。显式 `vaapi` 不支持真彩,画面降为 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。 +「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到 auto(有 NVIDIA 时 NVENC 优先,失败再 CPU;没有 NVIDIA 时就是 CPU,不探测;codec 仍是硬件优先 H.265、CPU 用 H.264)。探测在启动时后台进行,不挡住第一路出图。成功结果缓存到进程退出,但 NVIDIA 是否存在(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)与报告不一致时,下一次桌面连接会在后台再探测一次(`warm_auto_probe`),这一路仍用缓存的编码器,直到新结果写入。NVENC 失败只缓存 10 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。下次建立桌面连接时生效。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。 自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。 @@ -383,11 +383,12 @@ HEVC 的访问单元按 RFC 7798 的图片边界切分,不依赖 AUD:`hevc_v 画面从码流里丢掉,读取端按 AUD 切分就会把整个 GOP 当成一帧,再被 IRAP 门控全部拒绝——对外表现为连接停在 「正在传输画面」,而主机侧只有约 12 kbit/s。`UU_VIDEO_CODEC=h265` 可显式选中 H.265,便于对照排查。 -### VAAPI 硬件编码(显式启用) +### VAAPI 硬件编码 -设置 `UU_VIDEO_ENCODER=vaapi` 使用 Intel/AMD H.264 VAAPI;`UU_VAAPI_DEVICE` 默认 -`/dev/dri/renderD128`,运行用户需要 render 节点权限。不会自动选择 VAAPI;设备或驱动初始化 -失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。 +`UU_VIDEO_ENCODER=vaapi` 或 `set-encoder vaapi` 显式选择 Intel/AMD H.264 VAAPI。 +`UU_VAAPI_DEVICE` 默认 `/dev/dri/renderD128`,运行用户需要 render 节点权限。 +`auto` 有 NVIDIA 驱动时是 NVENC → CPU,没有 NVIDIA 时是 CPU。VAAPI 只通过显式选择启用,进入 auto 要等 #33。 +设备或驱动初始化失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。 VBR 使用控制端码率预设及 CQ 对应的最小 QP,无 B 帧、async depth=1,并保留现有 GOP/VFR 规则。 Intel 核显(UHD 770,iHD 驱动)已实机验收:默认的外部 FFmpeg 管线用官方 Mac 控制端测试了各档画质、帧率、缩放和重连,全程硬件编码、无回退,CPU 占用比 libx264 低约 40%(该数字为 FFmpeg 进程管线时代的测量)。AMD 核显已在**进程内原生引擎**上实机验收(`--features inproc-av`):官方 Mac 客户端的端到端会话在 HawkPoint(Mesa 26.2.3)与 Cezanne(Mesa 26.2.5)上通过验收(HEVC,含画质档、帧率、缩放);Cezanne 上另以探测验证了 H.264 与两条采集路径——XShm 上传(码流可解码、画面正确)与 DRI3 DMA-BUF 零拷贝导入。同机实测(1920×1200@60,Cezanne iGPU + RTX 3050 Ti 双显卡):进程内 VAAPI 每帧编码 CPU 约为 libx264(FFmpeg 管线 superfast)的 **1/12**、进程内 NVENC 的 **1/5**;外部 FFmpeg 进程管线(预编译包使用)在 AMD 上未单独验证。 diff --git a/src/capture_setting.rs b/src/capture_setting.rs index 68a31da..eb5b4e5 100644 --- a/src/capture_setting.rs +++ b/src/capture_setting.rs @@ -131,7 +131,7 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender, na /// hosts default to H.264. UU_VIDEO_CODEC=h264 / h265 overrides. #[cfg(test)] fn test_selection() -> crate::video_select::Selection { - crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false) + crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false, None) } #[cfg(test)] @@ -601,6 +601,26 @@ mod codec_tests { apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h265")).unwrap(); assert_eq!(rx.borrow().codec, VideoCodec::H265); } + #[test] + fn true_color_keeps_codec_and_vaapi_reports_420() { + // Field 7 = 3 (真彩). full_chroma false is the VAAPI 4:2:0 drop; true encodes 4:4:4. + let request = decode_wire(&[18, 2, 56, 3]).unwrap(); + let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() }); + apply_rpc(&request, &tx, (1920, 1080), true, true, true, None).unwrap(); + assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265)); + // NVENC session (full chroma) that already chose H.265 stays H.265 when 真彩 is requested. + let nvenc = crate::video_select::resolve_pair(None, None, None, None, true, None); + assert_eq!(nvenc.encoder, crate::video::Encoder::Nvenc); + let (tx, rx) = watch::channel(VideoSettings { codec: preferred_codec_for(true, true, nvenc), ..VideoSettings::default() }); + assert_eq!(rx.borrow().codec, VideoCodec::H265); + handle_rpc_for(&request, &tx, (1920, 1080), true, true, nvenc).unwrap(); + assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265)); + let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() }); + apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap(); + assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_420, VideoCodec::H265)); + assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_420)); + assert!(decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap().iter().all(|f| f.number != 13)); + } } #[cfg(test)] diff --git a/src/doctor.rs b/src/doctor.rs index 5aed37f..44c1260 100644 --- a/src/doctor.rs +++ b/src/doctor.rs @@ -16,6 +16,13 @@ fn env_state(name: &str) -> String { fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); } +fn format_probe(probe: &crate::video_select::ProbeReport) -> String { + let body = probe.order.iter().zip(probe.outcomes.iter()) + .map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label())) + .collect::>().join(" "); + if probe.expires_at.is_some() { format!("{body} (failure result, retried after 10 min)") } else { body } +} + fn glibc() -> String { #[cfg(all(target_os = "linux", target_env = "gnu"))] { @@ -95,6 +102,13 @@ pub async fn run() -> Result<(), String> { let selection = crate::video_select::selection(); let env_enc = std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "unset".into()); let codec = match selection.codec_pref { crate::video_select::CodecPref::Auto => "auto", crate::video_select::CodecPref::H264 => "h264", crate::video_select::CodecPref::H265 => "h265" }; + let probe_text = if selection.encoder_source == crate::video_select::Source::Auto { + format_probe(&crate::video::run_auto_probe().await) + } else { + crate::video_select::cached_probe().as_ref().map(format_probe).unwrap_or_else(|| "not yet run".to_owned()) + }; + let selection = if selection.encoder_source == crate::video_select::Source::Auto { crate::video_select::selection() } else { selection }; + line("encoder probe", probe_text); line("encoder", format!("{:?} (source={}; UU_VIDEO_ENCODER={env_enc})", selection.encoder, crate::video_select::encoder_source_label(selection.encoder_source))); line("codec", format!("{codec} (source={})", crate::video_select::source_label(selection.codec_source))); // Both codecs offered: hardware prefers H.265, CPU stays H.264 unless the preference forces one. diff --git a/src/main.rs b/src/main.rs index 2cca43d..6006ffa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -521,6 +521,7 @@ async fn main() -> Result<(), Box> { virtual_audio::init(); let _audio_cleanup=virtual_audio::Cleanup; log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION")); + video::warm_auto_probe(); if !desktop_backend::headless() && desktop_backend::detect()? == desktop_backend::DesktopBackend::X11 && desktop_backend::wayland_session_running() { // X11 capture inside a Wayland session reads XWayland's root window: all black, no error (#61). @@ -850,6 +851,8 @@ async fn serve(mut capture: Arc, input: Arc, shutd let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac); if desktop { input.set_mac_controller(controller_mac); } log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len()); + // An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder. + if desktop { video::warm_auto_probe(); } // Replace only this ICE id or a previous desktop, never tool peers. for id in superseded_peer_ids(&sessions, &ice, desktop) { if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; } diff --git a/src/video.rs b/src/video.rs index f95537c..dc01a1a 100644 --- a/src/video.rs +++ b/src/video.rs @@ -442,6 +442,109 @@ fn hevc_cell(cache: &HevcCache, spec: &FfmpegSpec, encoder: Encoder) -> Arc crate::video_select::ProbeOutcome { + use crate::video_select::{ProbeFail, ProbeOutcome}; + let settings = VideoSettings { codec: VideoCodec::H264, ..Default::default() }; + let mut command = ffmpeg_command(); + command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]); + if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); } + command.args(["-f", "lavfi", "-i", "color=c=black:s=256x256:r=1", "-frames:v", "1", "-an"]); + if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); } + command.args(encoder_options(&settings, encoder, "30", None)); + command.args(["-f", "h264", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null()); + let process = match tokio::time::timeout(AUTO_PROBE_BUDGET, command.output()).await { + Ok(Ok(output)) if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H264) => ProbeOutcome::Ok, + Ok(Ok(output)) if output.status.success() => ProbeOutcome::Fail(ProbeFail::NoIdr), + Ok(Ok(_)) => ProbeOutcome::Fail(ProbeFail::Exit), + Ok(Err(_)) => ProbeOutcome::Fail(ProbeFail::Spawn), + Err(_) => ProbeOutcome::Fail(ProbeFail::Timeout), + }; + // The native engine opens against a real X display, so a synthetic lavfi frame cannot + // exercise it. When this build would try that engine first, a process-only failure must + // not drop the candidate (NativeUnprobed → legacy auto for it). + crate::video_select::outcome_for_candidate(process, native_engine_would_run(encoder)) +} + +/// True when `read_encoder_with` would open the in-process engine for this candidate +/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless). +fn native_engine_would_run(encoder: Encoder) -> bool { + native_engine_eligible(encoder, native_display_kind()) +} + +fn native_display_kind() -> NativeDisplayKind { + if crate::desktop_backend::headless() { return NativeDisplayKind::None; } + match crate::desktop_backend::detect() { + Ok(crate::desktop_backend::DesktopBackend::Wayland) => NativeDisplayKind::Wayland, + Ok(crate::desktop_backend::DesktopBackend::Kms) => NativeDisplayKind::Kms, + Ok(crate::desktop_backend::DesktopBackend::Portal) => NativeDisplayKind::Portal, + _ => NativeDisplayKind::X11, + } +} + +fn auto_probe_flight() -> &'static tokio::sync::Mutex<()> { + static FLIGHT: std::sync::OnceLock> = std::sync::OnceLock::new(); + FLIGHT.get_or_init(|| tokio::sync::Mutex::new(())) +} + +/// Start the auto probe when auto is selected and the cache is empty or stale +/// (TTL, or NVIDIA presence changed since the report). Returns immediately. +/// One probe runs at a time; an in-flight probe is left alone. +/// Explicit encoder (setting or `UU_VIDEO_ENCODER`) does not spawn a probe. +pub fn warm_auto_probe() { + if !crate::video_select::should_warm_auto_probe(crate::video_select::selection().encoder_source) { return; } + if !crate::video_select::probe_needs_run(std::time::Instant::now(), nvidia_present()) { return; } + tokio::spawn(async { let _ = run_auto_probe().await; }); +} + +/// Diagnostics that encode must see the same auto choice as a warmed-up host. +/// An explicit encoder (setting or env) skips the probe. +pub async fn ensure_auto_probed() { + if crate::video_select::selection().encoder_source == crate::video_select::Source::Auto { + let _ = run_auto_probe().await; + } +} + +/// Run the probe to completion (doctor, or the background warm-up). +/// A success or a CPU-only skip stays cached. A hardware failure expires after +/// `PROBE_FAILURE_TTL`; the next `warm_auto_probe` starts one background retry. +pub async fn run_auto_probe() -> crate::video_select::ProbeReport { + let now = std::time::Instant::now(); + let nvidia = nvidia_present(); + if let Some(cached) = crate::video_select::cached_probe() { + if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; } + } + let _flight = auto_probe_flight().lock().await; + let now = std::time::Instant::now(); + let nvidia = nvidia_present(); + if let Some(cached) = crate::video_select::cached_probe() { + if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; } + } + let reason = crate::video_select::reprobe_reason(crate::video_select::cached_probe().as_ref(), nvidia); + let nvidia = nvidia_present(); + let order = crate::video_select::auto_order(nvidia); + // One candidate (CPU, no NVIDIA) has nothing to choose; skip the synthetic IDR. + let mut outcomes = Vec::with_capacity(order.len()); + if order.len() == 1 { + outcomes.push(crate::video_select::ProbeOutcome::NotProbed); + } else { + for encoder in &order { outcomes.push(probe_encoder_idr(*encoder).await); } + } + let probed = crate::video_select::choose_from_probe(&order, &outcomes); + let chosen = crate::video_select::chosen_after_native(nvidia, &order, &outcomes, probed); + let report = crate::video_select::ProbeReport::fresh(order, outcomes, chosen, now, nvidia); + let parts: Vec = report.order.iter().zip(report.outcomes.iter()).map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label())).collect(); + if let Some(reason) = reason { + log::info!("Encoder probe: {reason} {}", parts.join(" ")); + } else { + log::info!("Encoder probe: {}", parts.join(" ")); + } + crate::video_select::store_probe(report.clone()); + report +} + pub async fn hevc_available(requested: Encoder) -> bool { let spec = ffmpeg_spec(); let cell = hevc_cell(hevc_cache(), &spec, requested); @@ -531,7 +634,7 @@ impl Drop for StopOnDrop { fn drop(&mut self) { self.0.store(true, std::sync::at async fn read_encoder( size: (u32, u32), display: String, portal:Option>, latest: mpsc::Sender>, - settings: VideoSettings, sequence: Arc, idr: Arc, budget: Arc, + mut settings: VideoSettings, sequence: Arc, idr: Arc, budget: Arc, selection: crate::video_select::Selection, ) -> Result<(), String> { #[cfg(test)] @@ -539,6 +642,10 @@ async fn read_encoder( // The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct). // `selection` is fixed for this desktop connection (taken where the codec is negotiated). let encoder = selection.encoder; + if settings.chroma == crate::capture_setting::CHROMA_444 && !full_chroma_for(encoder) { + settings.chroma = crate::capture_setting::CHROMA_420; + log::info!("Chroma 4:4:4 requested; encoder={} source={} encodes 4:2:0", format!("{encoder:?}").to_ascii_lowercase(), crate::video_select::encoder_source_label(selection.encoder_source)); + } if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; } #[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))] let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await; @@ -567,10 +674,29 @@ fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u3 crate::capture::x11_size().filter(|current| *current != size) } +/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None } + +pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool { + #[cfg(feature = "inproc-av")] + { kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) } + #[cfg(not(feature = "inproc-av"))] + { let _ = (encoder, kind); false } +} + /// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session). #[cfg(feature = "inproc-av")] fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool { - !display.starts_with("wayland:") && !display.starts_with("kms:") && !portal && crate::inproc_encoder::selected(encoder) + native_engine_eligible(encoder, display_kind(display, portal)) +} + +#[cfg(feature = "inproc-av")] +fn display_kind(display: &str, portal: bool) -> NativeDisplayKind { + if portal { NativeDisplayKind::Portal } + else if display.starts_with("wayland:") { NativeDisplayKind::Wayland } + else if display.starts_with("kms:") { NativeDisplayKind::Kms } + else { NativeDisplayKind::X11 } } /// Capture and encode inside this process; each packet is one access unit. @@ -828,7 +954,9 @@ pub(crate) fn transport_closed(pc: &RTCPeerConnection) -> bool { || pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Closed } -fn probe_settings() -> Result { +/// Encoder and settings for `desktop-video-probe` / `UU_PROBE_INPUT`. +/// `UU_PROBE_CHROMA=444` is the viewer's 真彩 request, applied when the selected encoder can do 4:4:4. +pub(crate) fn probe_plan() -> Result<(crate::video_select::Selection, VideoSettings), String> { let fps=crate::wayland::capture_fps(std::env::var("UU_PROBE_FPS").ok().as_deref())?; // UU_PROBE_QUALITY selects a viewer preset (1 fast 1M, 2 general 2M, 3 HD 8M, 4 bluray 20M, // 5 auto); bitrate presets exercise the capped/ABR encoder path instead of CRF. @@ -836,19 +964,15 @@ fn probe_settings() -> Result { None=>crate::capture_setting::QUALITY_AUTO, Some(v)=>v.parse::().ok().filter(|q|(1..=5).contains(q)).ok_or("UU_PROBE_QUALITY must be 1-5")?, }; - let mut settings=VideoSettings {fps,quality,codec:probe_codec(),..VideoSettings::default()}; - // UU_PROBE_CHROMA=444 requests 真彩 like the viewer does (only where full_chroma_available()). - if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") && full_chroma_for(crate::video_select::selection().encoder) { settings.chroma=crate::capture_setting::CHROMA_444; } - Ok(settings) -} - -/// The probe follows `UU_VIDEO_CODEC` so the HEVC path can be measured at all (H.264 otherwise), -/// and its first access unit is then checked against that codec instead of always H.264. -fn probe_codec() -> VideoCodec { - match crate::video_select::codec_force(crate::video_select::selection().codec_pref) { + let mut settings=VideoSettings {fps,quality,..VideoSettings::default()}; + let selection = crate::video_select::selection(); + let chroma = if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") { crate::capture_setting::CHROMA_444 } else { crate::capture_setting::CHROMA_420 }; + settings.codec = match crate::video_select::codec_force(selection.codec_pref) { Some("h265") => VideoCodec::H265, _ => VideoCodec::H264, - } + }; + if chroma == crate::capture_setting::CHROMA_444 && full_chroma_for(selection.encoder) { settings.chroma = chroma; } + Ok((selection, settings)) } fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,settings:&VideoSettings, @@ -883,13 +1007,14 @@ async fn probe_input_size(spec:&FfmpegSpec,input:&std::ffi::OsStr)->Result<(u32, /// Fixed input bypasses desktop initialization and always uses the FFmpeg process encoder. pub async fn probe_input(input:OsString,path:Option)->Result<(),String> { + ensure_auto_probed().await; use std::io::Write; - let settings=probe_settings()?; + let (selection, settings)=probe_plan()?; let wanted:u64=std::env::var("UU_PROBE_FRAMES").ok().and_then(|v|v.parse().ok()).unwrap_or(5); if wanted==0 { return Err("Fixed-input UU_PROBE_FRAMES must be positive".into()); } let spec=ffmpeg_spec(); let size=probe_input_size(&spec,&input).await?; - let encoder = crate::video_select::selection().encoder; + let encoder = selection.encoder; let (maxrate,_)=rate_args(&settings,encoder); let output=settings.output.unwrap_or(size); println!("Fixed input probe: source={}x{} output={}x{} fps={} cq={} maxrate={} encoder={}", @@ -933,6 +1058,7 @@ pub async fn probe_input(input:OsString,path:Option)->Result<(),String> /// Exercise the real capture/encoder chain without UU auth or a network peer. pub async fn probe(size:(u32,u32),display:String,portal:Option>,path:Option)->Result<(),String> { + ensure_auto_probed().await; use std::io::Write; let mut file=match path { Some(path)=>Some(std::fs::OpenOptions::new().write(true).create_new(true).open(path).map_err(|e|format!("Video probe file: {e}"))?), @@ -940,8 +1066,7 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option, track: Arc, track: Arc, track: Arc {}x{}); restarting capture", size.0, size.1, resized.0, resized.1); size = resized; while receiver.try_recv().is_ok() {} - reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone(), selection)); + reader.0 = tokio::spawn(open(size, selection, current)); continue; } if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) { @@ -1040,7 +1176,7 @@ pub async fn stream_desktop(pc: Arc, track: Arc (Option, Option) { /// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc /// on any machine, so without this every stream start first ran a doomed NVENC process (#10). -fn legacy_auto(nvidia: bool) -> Encoder { +pub fn legacy_auto(nvidia: bool) -> Encoder { if nvidia { Encoder::Nvenc } else { Encoder::Cpu } } +/// Auto candidate order. NVIDIA present: NVENC then CPU. No NVIDIA: CPU only. +/// VAAPI is not an auto candidate until #33 (FFmpeg-process VAAPI ignores maxrate). +/// Explicit vaapi (setting or `UU_VIDEO_ENCODER`) is unchanged. +pub fn auto_order(nvidia: bool) -> Vec { + if nvidia { vec![Encoder::Nvenc, Encoder::Cpu] } else { vec![Encoder::Cpu] } +} + +/// Why one candidate's synthetic IDR did not count. Logged as the variant name only. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ProbeFail { Timeout, NoIdr, Spawn, Exit } + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ProbeOutcome { + Ok, + Fail(ProbeFail), + /// inproc-av only: the FFmpeg process probe failed, but this session would try the native + /// engine first (`read_encoder_with`) on an X11 display (not Wayland, portal, or KMS). + /// Opening that engine needs a display, so the candidate is not failed here; auto falls + /// back to the pre-probe NVIDIA/CPU choice for it. + NativeUnprobed, + /// Single auto candidate (CPU, no NVIDIA): the synthetic IDR is skipped. + NotProbed, +} + +impl ProbeOutcome { + /// Counts as a successful probe for `choose_from_probe`. + /// `NativeUnprobed` does not: that candidate was not shown to encode. + pub fn ok(self) -> bool { matches!(self, Self::Ok) } + pub fn label(self) -> &'static str { + match self { + Self::Ok => "ok", + Self::Fail(ProbeFail::Timeout) => "timeout", + Self::Fail(ProbeFail::NoIdr) => "no_idr", + Self::Fail(ProbeFail::Spawn) => "spawn", + Self::Fail(ProbeFail::Exit) => "exit", + Self::NativeUnprobed => "native_unprobed", + Self::NotProbed => "not probed (only candidate)", + } + } +} + +/// How a process-probe result becomes the stored outcome. +/// `native_would_run` is true only on inproc-av when `inproc_encoder::selected` is true +/// (hardware, not `UU_VIDEO_PIPELINE=process` / `UU_CAPTURE=grab` / a bundled FFmpeg). +/// A process failure then becomes `NativeUnprobed` instead of disqualifying that candidate. +/// Default builds pass `native_would_run = false`, so the process result is unchanged. +pub fn outcome_for_candidate(process: ProbeOutcome, native_would_run: bool) -> ProbeOutcome { + if process.ok() || !native_would_run { process } else { ProbeOutcome::NativeUnprobed } +} + +/// Encoder auto should use when a hardware candidate was left `NativeUnprobed`. +/// That candidate is skipped by `choose_from_probe`; if it was the legacy pick (NVENC when +/// NVIDIA is present), keep the legacy encoder. Otherwise use the probe choice. +pub fn chosen_after_native(nvidia: bool, order: &[Encoder], outcomes: &[ProbeOutcome], probed: Encoder) -> Encoder { + let legacy = legacy_auto(nvidia); + let native_legacy = order.iter().zip(outcomes.iter()).any(|(e, o)| { + *e == legacy && matches!(o, ProbeOutcome::NativeUnprobed) + }); + if native_legacy { legacy } else { probed } +} + +/// How long a hardware-candidate failure stays cached. A boot-time NVENC miss +/// (module not ready, GPU busy, consumer session limit) must not stick until exit. +pub const PROBE_FAILURE_TTL: std::time::Duration = std::time::Duration::from_secs(600); + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ProbeReport { + pub order: Vec, + pub outcomes: Vec, + pub chosen: Encoder, + /// `None` means the result does not expire (success, or CPU-only `NotProbed`). + pub expires_at: Option, + /// `nvidia_present()` at the time the report was stored. A later desktop + /// connection whose presence differs treats the report as stale. + pub nvidia: bool, +} + +impl ProbeReport { + pub fn fresh(order: Vec, outcomes: Vec, chosen: Encoder, now: std::time::Instant, nvidia: bool) -> Self { + let expires_at = probe_failure_deadline(&order, &outcomes, chosen, now); + Self { order, outcomes, chosen, expires_at, nvidia } + } +} + +/// Expiry is only for the hardware candidate that caused the CPU fallback +/// (NVENC `Fail` and `chosen == Cpu`). A `Fail` on CPU while NVENC is `Ok` +/// does not expire, and doctor does not label that report a failure. +/// `NotProbed` and `Ok` do not. `NativeUnprobed` keeps the legacy encoder +/// and is not a failure cache. +pub fn probe_failure_deadline( + order: &[Encoder], + outcomes: &[ProbeOutcome], + chosen: Encoder, + now: std::time::Instant, +) -> Option { + let hardware_failed = order.iter().zip(outcomes).any(|(encoder, outcome)| { + *encoder != Encoder::Cpu && matches!(outcome, ProbeOutcome::Fail(_)) + }); + (hardware_failed && chosen == Encoder::Cpu).then_some(now + PROBE_FAILURE_TTL) +} + +pub fn probe_expired(report: &ProbeReport, now: std::time::Instant) -> bool { + report.expires_at.is_some_and(|at| now >= at) +} + +/// Time-to-live elapsed, or NVIDIA presence no longer matches the report. +/// Presence is `nvidia_present()` (proc version or `/dev/nvidia0`). +pub fn probe_stale(report: &ProbeReport, now: std::time::Instant, nvidia: bool) -> bool { + probe_expired(report, now) || report.nvidia != nvidia +} + +/// Log suffix for a probe that replaces `previous`. `None` is a first probe. +/// A failure deadline (`expires_at`) is "retry after failure". A presence +/// mismatch without that deadline is "NVIDIA availability changed". +pub fn reprobe_reason(previous: Option<&ProbeReport>, nvidia_now: bool) -> Option<&'static str> { + let previous = previous?; + if previous.expires_at.is_some() { + Some("retry after failure") + } else if previous.nvidia != nvidia_now { + Some("NVIDIA availability changed") + } else { + None + } +} + +/// Empty cache, or the cached report is stale for `nvidia` at `now`. +/// Callers still use the cached encoder until the replacement probe is stored. +pub fn probe_needs_run(now: std::time::Instant, nvidia: bool) -> bool { + match cached_probe() { + None => true, + Some(report) => probe_stale(&report, now, nvidia), + } +} + +/// Background warm-up (startup and each new desktop connection) runs only for auto. +/// Setting or `UU_VIDEO_ENCODER` (non-auto) matches v0.2.23: no GPU probe. +pub fn should_warm_auto_probe(source: Source) -> bool { + source == Source::Auto +} + +/// First candidate that produced an IDR, else CPU. +pub fn choose_from_probe(order: &[Encoder], outcomes: &[ProbeOutcome]) -> Encoder { + order.iter().zip(outcomes.iter()).find_map(|(e, o)| o.ok().then_some(*e)).unwrap_or(Encoder::Cpu) +} + +fn cache() -> &'static std::sync::Mutex> { + static CACHE: std::sync::OnceLock>> = std::sync::OnceLock::new(); + CACHE.get_or_init(|| std::sync::Mutex::new(None)) +} + +pub fn store_probe(report: ProbeReport) { + if let Ok(mut slot) = cache().lock() { *slot = Some(report); } +} + +pub fn cached_probe() -> Option { + cache().lock().ok().and_then(|g| g.clone()) +} + +/// Tests that call `clear_probe` / `store_probe` share this lock. The probe +/// cache is process-global and `cargo test` runs tests in parallel. +#[cfg(test)] +pub(crate) static PROBE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + +#[cfg(test)] +pub fn clear_probe() { + if let Ok(mut slot) = cache().lock() { *slot = None; } +} + /// Setting (non-auto) beats the environment, which beats the NVIDIA/CPU default. pub fn selection() -> Selection { + selection_with(cached_probe().as_ref()) +} + +/// Same as `selection`, but auto uses `report` when it is already cached. +/// `None` keeps the legacy NVIDIA/CPU result (the probe is still running or has not started). +pub fn selection_with(report: Option<&ProbeReport>) -> Selection { let (file_enc, file_codec) = file_fields(); let env_enc = std::env::var("UU_VIDEO_ENCODER").ok(); let env_codec = std::env::var("UU_VIDEO_CODEC").ok(); - resolve_pair( - file_enc.as_deref(), - env_enc.as_deref(), - file_codec.as_deref(), - env_codec.as_deref(), - crate::video::nvidia_present(), - ) + resolve_pair(file_enc.as_deref(), env_enc.as_deref(), file_codec.as_deref(), env_codec.as_deref(), crate::video::nvidia_present(), report) } pub fn resolve_pair( @@ -89,14 +259,15 @@ pub fn resolve_pair( codec_setting: Option<&str>, codec_env: Option<&str>, nvidia: bool, + probed: Option<&ProbeReport>, ) -> Selection { let (encoder, encoder_source) = match parse_encoder(enc_setting) { Some(Some(e)) => (e, Source::Setting), None => { log::warn!("Ignoring video_encoder value (not auto/cpu/vaapi/nvenc)"); - pick_encoder(enc_env, nvidia) + pick_encoder(enc_env, nvidia, probed) } - Some(None) => pick_encoder(enc_env, nvidia), + Some(None) => pick_encoder(enc_env, nvidia, probed), }; let (codec_pref, codec_source) = match parse_codec(codec_setting) { Some(Some(p)) => (p, Source::Setting), @@ -114,17 +285,21 @@ pub fn resolve_pair( } } -fn pick_encoder(env: Option<&str>, nvidia: bool) -> (Encoder, Source) { +fn pick_encoder(env: Option<&str>, nvidia: bool, probed: Option<&ProbeReport>) -> (Encoder, Source) { match parse_encoder(env) { Some(Some(e)) => (e, Source::Env), None => { log::warn!("Ignoring UU_VIDEO_ENCODER value (not auto/cpu/vaapi/nvenc)"); - (legacy_auto(nvidia), Source::Auto) + (auto_encoder(nvidia, probed), Source::Auto) } - Some(None) => (legacy_auto(nvidia), Source::Auto), + Some(None) => (auto_encoder(nvidia, probed), Source::Auto), } } +fn auto_encoder(nvidia: bool, probed: Option<&ProbeReport>) -> Encoder { + probed.map(|p| p.chosen).unwrap_or_else(|| legacy_auto(nvidia)) +} + fn pick_codec(env: Option<&str>) -> (CodecPref, Source) { match parse_codec(env) { Some(Some(p)) => (p, Source::Env), @@ -176,7 +351,7 @@ mod tests { ce: Option<&str>, nvidia: bool, ) -> Selection { - resolve_pair(es, ee, cs, ce, nvidia) + resolve_pair(es, ee, cs, ce, nvidia, None) } #[test] @@ -241,4 +416,318 @@ mod tests { CodecPref::H265 ); } + + #[test] + fn process_failure_keeps_native_candidate_unprobed() { + let exit = ProbeOutcome::Fail(ProbeFail::Exit); + assert_eq!(outcome_for_candidate(ProbeOutcome::Ok, true), ProbeOutcome::Ok); + assert_eq!(outcome_for_candidate(exit, false), exit, "default build keeps the process result"); + assert_eq!(outcome_for_candidate(exit, true), ProbeOutcome::NativeUnprobed); + assert!(!ProbeOutcome::NativeUnprobed.ok()); + assert_eq!(ProbeOutcome::NativeUnprobed.label(), "native_unprobed"); + } + + #[test] + fn native_unprobed_hardware_uses_legacy_choice() { + let order = auto_order(true); + let outcomes = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok]; + let probed = choose_from_probe(&order, &outcomes); + assert_eq!(probed, Encoder::Cpu); + assert_eq!(chosen_after_native(true, &order, &outcomes, probed), Encoder::Nvenc); + let cpu_only = auto_order(false); + assert_eq!(chosen_after_native(false, &cpu_only, &[ProbeOutcome::Ok], Encoder::Cpu), Encoder::Cpu); + let both_ok = [ProbeOutcome::Ok, ProbeOutcome::Ok]; + assert_eq!(chosen_after_native(true, &order, &both_ok, Encoder::Nvenc), Encoder::Nvenc); + } + + fn probe_report(nvidia: bool, outcomes: &[ProbeOutcome]) -> ProbeReport { + let order = auto_order(nvidia); + let chosen = choose_from_probe(&order, outcomes); + ProbeReport::fresh(order, outcomes.to_vec(), chosen, std::time::Instant::now(), nvidia) + } + + #[test] + fn auto_order_keeps_nvenc_when_nvidia_is_present() { + assert_eq!(auto_order(true), vec![Encoder::Nvenc, Encoder::Cpu]); + assert_eq!(auto_order(false), vec![Encoder::Cpu]); + assert_eq!(legacy_auto(true), Encoder::Nvenc); + assert_eq!(legacy_auto(false), Encoder::Cpu); + } + + #[test] + fn auto_falls_back_when_the_first_candidate_fails() { + let both = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Fail(ProbeFail::Exit)]); + assert_eq!(both.chosen, Encoder::Cpu); + let nv = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]); + assert_eq!(nv.chosen, Encoder::Nvenc); + let failed = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok]); + assert_eq!(failed.chosen, Encoder::Cpu); + assert_eq!(resolve_pair(None, None, None, None, true, Some(&nv)).encoder, Encoder::Nvenc); + assert_eq!(resolve_pair(None, None, None, None, true, Some(&failed)).encoder, Encoder::Cpu); + let cpu = probe_report(false, &[ProbeOutcome::Ok]); + assert_eq!(cpu.chosen, Encoder::Cpu); + assert_eq!(resolve_pair(None, None, None, None, false, Some(&cpu)).encoder, Encoder::Cpu); + let skipped = probe_report(false, &[ProbeOutcome::NotProbed]); + assert_eq!(skipped.chosen, Encoder::Cpu); + assert_eq!(ProbeOutcome::NotProbed.label(), "not probed (only candidate)"); + assert!(!ProbeOutcome::NotProbed.ok()); + assert_eq!(resolve_pair(None, None, None, None, false, Some(&skipped)).encoder, Encoder::Cpu); + } + + #[test] + fn explicit_env_and_setting_ignore_the_probe() { + let va = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]); + assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, Some(&va)).encoder, Encoder::Nvenc); + assert_eq!(resolve_pair(None, Some("cpu"), None, None, true, Some(&va)).encoder, Encoder::Cpu); + assert_eq!(resolve_pair(Some("vaapi"), Some("nvenc"), None, None, true, Some(&va)).encoder, Encoder::Vaapi); + assert_eq!(resolve_pair(Some("nvenc"), None, None, None, false, Some(&va)).encoder_source, Source::Setting); + assert_eq!(resolve_pair(None, Some("cpu"), None, None, false, Some(&va)).encoder_source, Source::Env); + assert_eq!(resolve_pair(Some("auto"), Some("vaapi"), None, None, false, None).encoder, Encoder::Vaapi); + assert_eq!(resolve_pair(None, None, None, Some("h264"), false, Some(&va)).codec_pref, CodecPref::H264); + } + + /// Codec at CONTROL open is `preferred_codec_for` on the session snapshot. + /// Auto + CPU uses H.264 when both codecs are negotiated; auto + NVENC keeps H.265. + /// Forced codec ignores the encoder. 真彩 does not switch codec (true_color_keeps_codec_and_vaapi_reports_420). + #[test] + fn auto_codec_follows_the_encoder_chosen_at_session_setup() { + use crate::capture_setting::{preferred_codec_for, VideoCodec}; + + let cpu_fallback = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Ok]); + let session = resolve_pair(None, None, None, None, true, Some(&cpu_fallback)); + assert_eq!((session.encoder, session.encoder_source, session.codec_pref), (Encoder::Cpu, Source::Auto, CodecPref::Auto)); + assert_eq!(preferred_codec_for(true, true, session), VideoCodec::H264); + // Not the H.265 an unfinished probe would pick for legacy NVENC. + let early_nvenc = resolve_pair(None, None, None, None, true, None); + assert_eq!(early_nvenc.encoder, Encoder::Nvenc); + assert_eq!(preferred_codec_for(true, true, early_nvenc), VideoCodec::H265); + + let nvenc_ok = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]); + let nvenc = resolve_pair(None, None, None, None, true, Some(&nvenc_ok)); + assert_eq!(nvenc.encoder, Encoder::Nvenc); + assert_eq!(preferred_codec_for(true, true, nvenc), VideoCodec::H265); + + let order = auto_order(true); + let unprobed = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok]; + let chosen = chosen_after_native(true, &order, &unprobed, choose_from_probe(&order, &unprobed)); + let report = ProbeReport::fresh(order.clone(), unprobed.to_vec(), chosen, std::time::Instant::now(), true); + let native = resolve_pair(None, None, None, None, true, Some(&report)); + assert_eq!(native.encoder, Encoder::Nvenc); + assert_eq!(preferred_codec_for(true, true, native), VideoCodec::H265); + + let forced_h264 = resolve_pair(None, None, Some("h264"), None, true, Some(&nvenc_ok)); + assert_eq!(forced_h264.encoder, Encoder::Nvenc); + assert_eq!(preferred_codec_for(true, true, forced_h264), VideoCodec::H264); + let forced_h265 = resolve_pair(None, None, None, Some("h265"), true, Some(&cpu_fallback)); + assert_eq!(forced_h265.encoder, Encoder::Cpu); + assert_eq!(preferred_codec_for(true, true, forced_h265), VideoCodec::H265); + } + + #[test] + fn session_before_probe_uses_legacy_auto() { + let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner()); + clear_probe(); + assert!(cached_probe().is_none()); + let early = resolve_pair(None, None, None, None, false, None); + assert_eq!((early.encoder, early.encoder_source), (Encoder::Cpu, Source::Auto)); + assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc); + store_probe(probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok])); + assert_eq!(cached_probe().unwrap().chosen, Encoder::Cpu); + assert_eq!(resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, Encoder::Cpu); + // A snapshot taken before the cache filled stays on the legacy encoder. + assert_eq!(early.encoder, Encoder::Cpu); + assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc); + clear_probe(); + } + + #[test] + fn success_and_not_probed_do_not_expire() { + let now = std::time::Instant::now(); + let later = now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1); + let ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true); + assert!(ok.expires_at.is_none()); + assert!(!probe_expired(&ok, later)); + let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false); + assert!(skipped.expires_at.is_none()); + assert!(!probe_expired(&skipped, later)); + let native = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok], + Encoder::Nvenc, + now, + true, + ); + assert!(native.expires_at.is_none(), "native_unprobed is not a recorded process failure"); + assert!(!probe_expired(&native, later)); + } + + #[test] + fn hardware_failure_expires_after_ttl() { + let now = std::time::Instant::now(); + let failed = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok], + Encoder::Cpu, + now, + true, + ); + assert!(!probe_expired(&failed, now + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1))); + assert!(probe_expired(&failed, now + PROBE_FAILURE_TTL)); + assert_eq!(failed.chosen, Encoder::Cpu); + } + + /// NVENC produced an IDR and CPU failed: the session uses NVENC, so this is + /// not the hardware-fallback cache. No TTL, and doctor (which keys off + /// `expires_at`) does not append the failure label. + #[test] + fn nvenc_ok_cpu_fail_does_not_expire() { + let now = std::time::Instant::now(); + let report = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Ok, ProbeOutcome::Fail(ProbeFail::Exit)], + Encoder::Nvenc, + now, + true, + ); + assert_eq!(report.chosen, Encoder::Nvenc); + assert!(report.expires_at.is_none()); + assert!(!probe_expired(&report, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1))); + let cpu_only_fail = ProbeReport::fresh( + auto_order(false), + vec![ProbeOutcome::Fail(ProbeFail::Exit)], + Encoder::Cpu, + now, + false, + ); + assert!(cpu_only_fail.expires_at.is_none(), "a CPU-only Fail is not a hardware fallback"); + } + + /// Failed NVENC stays CPU until `PROBE_FAILURE_TTL`. After that a desktop connection + /// asks for one background re-probe (`probe_needs_run`, what `warm_auto_probe` checks) + /// and still selects the cached CPU encoder. A successful re-probe selects NVENC and + /// does not expire. A second failure restarts the TTL. + #[test] + fn failure_then_reprobe_success_selects_nvenc() { + let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner()); + clear_probe(); + let t0 = std::time::Instant::now(); + let failed = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok], + Encoder::Cpu, + t0, + true, + ); + store_probe(failed); + let before = t0 + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1); + assert!(!probe_needs_run(before, true), "no re-probe before the failure expires"); + assert_eq!( + resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, + Encoder::Cpu + ); + let after = t0 + PROBE_FAILURE_TTL; + assert!(probe_expired(cached_probe().as_ref().unwrap(), after)); + assert!(probe_needs_run(after, true), "desktop connection starts one background re-probe"); + assert_eq!( + resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, + Encoder::Cpu, + "the connection that notices expiry still uses the cached encoder" + ); + let retried = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Ok, ProbeOutcome::Ok], + Encoder::Nvenc, + after, + true, + ); + store_probe(retried); + assert_eq!( + resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, + Encoder::Nvenc + ); + assert!(!probe_needs_run(after + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), true)); + let failed_again = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok], + Encoder::Cpu, + after, + true, + ); + store_probe(failed_again); + assert!(!probe_needs_run(after + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1), true)); + assert!(probe_needs_run(after + PROBE_FAILURE_TTL, true)); + clear_probe(); + } + + /// A CPU-only `NotProbed` report does not expire by time. When NVIDIA appears + /// (module or device after the user service started), the next desktop + /// connection treats it as stale and `probe_needs_run` asks for one background + /// re-probe. The inverse (NVENC success, device gone) is stale the same way. + /// The connection that notices still selects the cached encoder. + #[test] + fn nvidia_presence_change_makes_probe_stale() { + let now = std::time::Instant::now(); + let cpu_only = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false); + assert!(!probe_stale(&cpu_only, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), false)); + assert!(probe_stale(&cpu_only, now, true), "NVIDIA appeared after the CPU-only skip"); + let nvenc_ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true); + assert!(!probe_stale(&nvenc_ok, now, true)); + assert!(probe_stale(&nvenc_ok, now, false), "NVIDIA gone after a successful NVENC probe"); + + let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner()); + clear_probe(); + store_probe(cpu_only); + assert!(!probe_needs_run(now, false)); + assert!(probe_needs_run(now, true)); + assert_eq!( + resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, + Encoder::Cpu, + "the connection that notices the presence change still uses the cached encoder" + ); + clear_probe(); + } + + #[test] + fn reprobe_reason_follows_previous_state() { + let now = std::time::Instant::now(); + assert_eq!(reprobe_reason(None, false), None); + assert_eq!(reprobe_reason(None, true), None); + + let failed = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok], + Encoder::Cpu, + now, + true, + ); + assert!(failed.expires_at.is_some()); + assert_eq!(reprobe_reason(Some(&failed), true), Some("retry after failure")); + assert_eq!(reprobe_reason(Some(&failed), false), Some("retry after failure")); + + let nvenc_ok = ProbeReport::fresh( + auto_order(true), + vec![ProbeOutcome::Ok, ProbeOutcome::Ok], + Encoder::Nvenc, + now, + true, + ); + assert_eq!(reprobe_reason(Some(&nvenc_ok), true), None); + assert_eq!(reprobe_reason(Some(&nvenc_ok), false), Some("NVIDIA availability changed")); + + let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false); + assert_eq!(reprobe_reason(Some(&skipped), false), None); + assert_eq!(reprobe_reason(Some(&skipped), true), Some("NVIDIA availability changed")); + assert_ne!(reprobe_reason(Some(&nvenc_ok), false), Some("retry after failure")); + assert_ne!(reprobe_reason(Some(&skipped), true), Some("retry after failure")); + } + + #[test] + fn warm_probe_only_when_encoder_source_is_auto() { + assert!(should_warm_auto_probe(Source::Auto)); + assert!(!should_warm_auto_probe(Source::Setting)); + assert!(!should_warm_auto_probe(Source::Env)); + assert_eq!(resolve_pair(Some("cpu"), None, None, None, true, None).encoder_source, Source::Setting); + assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, None).encoder_source, Source::Env); + assert_eq!(resolve_pair(None, Some("auto"), None, None, false, None).encoder_source, Source::Auto); + } } diff --git a/src/video_wake_tests.rs b/src/video_wake_tests.rs index ef575e2..5caf0d3 100644 --- a/src/video_wake_tests.rs +++ b/src/video_wake_tests.rs @@ -76,7 +76,7 @@ async fn exercise(fail_wake: usize, fail_capture: bool) { remote.set_remote_description(host.local_description().await.unwrap()).await.unwrap(); let settings = VideoSettings { source_id: 0, source_generation: 0, ..Default::default() }; let (settings_tx, settings_rx) = tokio::sync::watch::channel(settings); - let selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false); + let selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false, None); let mut task = tokio::spawn(stream_desktop(host.clone(), track.clone(), (640, 480), DISPLAY.into(), None, settings_rx, Arc::new(settings_tx), Arc::new(AtomicBool::new(false)), selection)); let result = if fail_capture {