mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Video: probe the auto encoder in the background (NVENC then CPU) (#93)
Refs #85 (step 2).
This commit is contained in:
1 parent
1009bdeaf2
commit
9d3b3da3f5
9 files changed
+752
-58
No files matched your search
@@ -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/<tag>.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
|
||||
|
||||
+17
-8
@@ -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).
|
||||
|
||||
@@ -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 上未单独验证。
|
||||
|
||||
|
||||
+21
-1
@@ -131,7 +131,7 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, 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)]
|
||||
|
||||
@@ -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::<Vec<_>>().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.
|
||||
|
||||
@@ -521,6 +521,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
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<ScreenCapture>, input: Arc<InputInjector>, 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; }
|
||||
|
||||
+179
-23
@@ -442,6 +442,109 @@ fn hevc_cell(cache: &HevcCache, spec: &FfmpegSpec, encoder: Encoder) -> Arc<toki
|
||||
/// passes the session's encoder so capability matches that snapshot. set-encoder
|
||||
/// changes the snapshot for the next session, so a process-wide bool would keep advertising
|
||||
/// the first session's result.
|
||||
const AUTO_PROBE_BUDGET: Duration = Duration::from_secs(3);
|
||||
|
||||
/// One synthetic H.264 IDR. Failure reasons stay enum values: stderr and device paths are not logged.
|
||||
pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> 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<tokio::sync::Mutex<()>> = 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<String> = 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<Arc<crate::portal::PortalSession>>,
|
||||
latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
mut settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
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<VideoSettings,String> {
|
||||
/// 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<VideoSettings,String> {
|
||||
None=>crate::capture_setting::QUALITY_AUTO,
|
||||
Some(v)=>v.parse::<u64>().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<String>)->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<String>)->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<Arc<crate::portal::PortalSession>>,path:Option<String>)->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<Arc<crate::portal
|
||||
};
|
||||
let (tx,mut rx)=mpsc::channel(4);
|
||||
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let settings=probe_settings()?;
|
||||
let selection = crate::video_select::selection();
|
||||
let (selection, settings)=probe_plan()?;
|
||||
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)),selection)));
|
||||
let mut count=0;
|
||||
let mut bytes=0;
|
||||
@@ -993,7 +1118,18 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
settings.borrow_and_update();
|
||||
}
|
||||
// Reader restarts reuse this snapshot, so set-encoder waits for the next desktop connection.
|
||||
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone(), selection)));
|
||||
let open = {
|
||||
let display = display.clone();
|
||||
let portal = portal.clone();
|
||||
let latest = latest.clone();
|
||||
let sequence = sequence.clone();
|
||||
let idr = idr.clone();
|
||||
let budget = budget.clone();
|
||||
move |size: (u32, u32), selection: crate::video_select::Selection, settings: VideoSettings| {
|
||||
read_encoder(size, display.clone(), portal.clone(), latest.clone(), settings, sequence.clone(), idr.clone(), budget.clone(), selection)
|
||||
}
|
||||
};
|
||||
let mut reader = EncoderTask(tokio::spawn(open(size, selection, current)));
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
let mut settings_open = true;
|
||||
@@ -1019,9 +1155,9 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone(), selection));
|
||||
reader.0 = tokio::spawn(open(size, selection, next));
|
||||
} else {
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone(), selection)).await;
|
||||
reader.restart(open(size, selection, next)).await;
|
||||
}
|
||||
send_interrupted=false;
|
||||
}
|
||||
@@ -1032,7 +1168,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
log::info!("Desktop geometry changed during the stream ({}x{} -> {}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<RTCPeerConnection>, track: Arc<crate::video_
|
||||
applied.send_modify(|value| value.codec = VideoCodec::H264);
|
||||
current = *settings.borrow_and_update();
|
||||
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 result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
|
||||
@@ -1255,6 +1391,26 @@ mod tests {
|
||||
assert!(!timing_args(FfmpegTimingMode::Modern, 60).contains(&"-r".to_owned()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_unprobed_only_when_x11_inproc_is_eligible() {
|
||||
use crate::video_select::{outcome_for_candidate, ProbeFail, ProbeOutcome};
|
||||
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
|
||||
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Portal, NativeDisplayKind::Kms, NativeDisplayKind::None] {
|
||||
assert!(!native_engine_eligible(Encoder::Nvenc, kind), "{kind:?}");
|
||||
assert_eq!(outcome_for_candidate(exit, native_engine_eligible(Encoder::Nvenc, kind)), exit);
|
||||
}
|
||||
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::X11));
|
||||
let x11 = native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11);
|
||||
let stored = outcome_for_candidate(exit, x11);
|
||||
if cfg!(feature = "inproc-av") && native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11) {
|
||||
assert!(x11);
|
||||
assert_eq!(stored, ProbeOutcome::NativeUnprobed);
|
||||
} else {
|
||||
assert!(!x11);
|
||||
assert_eq!(stored, exit);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timing_probe_failure_keeps_modern_args() {
|
||||
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
|
||||
|
||||
+504
-15
@@ -1,6 +1,8 @@
|
||||
//! Runtime encoder / codec preference. host_settings.json beats the environment,
|
||||
//! and "auto" or a missing field falls through. Illegal values are ignored.
|
||||
//! Auto keeps the v0.2.23 rule (NVENC when an NVIDIA driver is present, otherwise CPU).
|
||||
//! Auto follows `auto_order` (NVENC then CPU when NVIDIA is present, else CPU).
|
||||
//! A finished background probe can replace that choice; an unfinished probe keeps
|
||||
//! the legacy NVIDIA/CPU result so the first connection is not delayed.
|
||||
|
||||
use crate::video::Encoder;
|
||||
|
||||
@@ -65,22 +67,190 @@ fn file_fields() -> (Option<String>, Option<String>) {
|
||||
|
||||
/// 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<Encoder> {
|
||||
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<Encoder>,
|
||||
pub outcomes: Vec<ProbeOutcome>,
|
||||
pub chosen: Encoder,
|
||||
/// `None` means the result does not expire (success, or CPU-only `NotProbed`).
|
||||
pub expires_at: Option<std::time::Instant>,
|
||||
/// `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<Encoder>, outcomes: Vec<ProbeOutcome>, 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<std::time::Instant> {
|
||||
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<Option<ProbeReport>> {
|
||||
static CACHE: std::sync::OnceLock<std::sync::Mutex<Option<ProbeReport>>> = 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<ProbeReport> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
Reference in new issue
Block a user