Switch the desktop encoder on SIGUSR2 without dropping the session (#96)

set-encoder / set-codec signal the running host (only when /proc/<pid>/exe is this exact binary); the live desktop stream re-plans its encoder at the next frame boundary, sends CaptureSettingSync when 4:4:4 falls back, and prints a note when no host was notified. Step 3 of #85.

Co-authored-by: ferstar <[email protected]>
This commit is contained in:
Jeff Zhangandferstar authored and GitHub committed 2026-10-23 03:24:29 -07:00
1 parent 792408e6f5
commit 6a3da14961
9 files changed
+439 -28

No files matched your search

+2 -2
View File
@@ -117,7 +117,7 @@ viewer does not reconnect them automatically.
| Item | Meaning |
|---|---|
| `~/.config/uuremote/config.json` | user_id, device_id, client_id, system_id, machine_guid, token, csrf; optional `sign_key`, `ffmpeg_root`. `$UU_CONFIG` overrides the path |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent; optional `video_encoder` (`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by `set-encoder` / `set-codec` (0600, merge write). Non-`auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`. Applied on the next desktop stream |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent; optional `video_encoder` (`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by `set-encoder` / `set-codec` (0600, merge write). Non-`auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`. `set-encoder` and `set-codec` both send `SIGUSR2` to the pid in `host.pid` (same binary). Live desktop streams restart the encoder (`EncoderTask::restart`, sequence kept, first frame IDR) without dropping the peer. Codec preference is logged and applies on the next desktop stream. `SIGUSR2` does not re-probe. Hand edits: `kill -USR2 $(cat ~/.config/uuremote/host.pid)` |
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
@@ -168,7 +168,7 @@ for a new QR login.
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc`, `set-codec auto|h264|h265` (next desktop stream; illegal values exit 2), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc` and `set-codec auto|h264|h265` (both notify a running host with SIGUSR2; live encoder switch, negotiated codec unchanged, codec preference on the next desktop stream; illegal values exit 2), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_CHROMA=444` 真彩; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
`portal-acceptance`, `help`. Unknown arguments exit with code 2. Builds up to v0.1.0 did **not** reject them and
started a second full host server instead, so check that a subcommand exists in the binary you run.
+7 -1
View File
@@ -365,7 +365,13 @@ stays cached until the process exits, except when NVIDIA presence (`/proc/driver
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,
starts the same background re-probe while still using the cached encoder. `set-encoder` and
`set-codec` both send `SIGUSR2` to the host in `host.pid` when that process is this program.
An encoder change switches each live desktop stream without disconnecting and keeps the codec
negotiated for that session. A failed start follows the existing fallback (in-process, then the
FFmpeg process, then CPU). After a hand edit, `kill -USR2 $(cat ~/.config/uuremote/host.pid)`
does the same. `SIGUSR2` does not re-probe. A codec change takes effect the next time a desktop
connection starts; the running host only logs it. 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.
+1 -1
View File
@@ -321,7 +321,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` 或留空则落到环境变量,再落到 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。
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.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 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。`set-encoder` 和 `set-codec` 写完后若 `host.pid` 指向正在运行的本程序,都会发 `SIGUSR2`:编码器变化时进行中的桌面流立刻换编码器(不断开,沿用本会话已协商的 codec;新编码器起不来时按进程内 → FFmpeg 进程 → CPU 回退)。手改文件后可 `kill -USR2 $(cat ~/.config/uuremote/host.pid)`。`SIGUSR2` 不重新探测。codec 偏好仍在下次建立桌面连接时生效(运行中的 host 只记日志,不重开编码)。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。
自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。
+108 -6
View File
@@ -144,10 +144,46 @@ fn set_video_pref() -> Result<(), Box<dyn std::error::Error>> {
let selection = video_select::selection();
let codec = match selection.codec_pref { video_select::CodecPref::Auto => "auto", video_select::CodecPref::H264 => "h264", video_select::CodecPref::H265 => "h265" };
println!("encoder={:?} source={} codec_pref={codec} source={}", selection.encoder, video_select::encoder_source_label(selection.encoder_source), video_select::source_label(selection.codec_source));
println!("takes effect the next time a desktop connection starts");
// Both subcommands wake the host. Encoder changes restart live desktop streams; codec changes are logged only.
match notify_host(libc::SIGUSR2) {
Ok(()) => println!("notified the running host"),
Err(_) => println!(
"host not running, or the running host is not this binary: takes effect the next time a desktop connection starts, or after restarting the service"
),
}
if which == "set-codec" {
println!("takes effect the next time a desktop connection starts");
}
Ok(())
}
/// Signal the host recorded in host.pid only when `/proc/<pid>/exe` is exactly
/// `canonicalize(current_exe())`. A filename match is not enough: an older host
/// has no SIGUSR2 handler, and the default action terminates the process.
/// A replaced binary reads back as `… (deleted)` and does not match.
fn notify_host(signal: i32) -> Result<(), ()> {
let pid = std::fs::read_to_string(host_pid_path())
.ok()
.and_then(|s| s.trim().parse::<i32>().ok())
.filter(|p| *p > 1)
.ok_or(())?;
let exe = std::fs::read_link(format!("/proc/{pid}/exe")).map_err(|_| ())?;
let own = std::fs::canonicalize(std::env::current_exe().map_err(|_| ())?).map_err(|_| ())?;
if !same_host_binary(&exe, &own) {
return Err(());
}
if unsafe { libc::kill(pid, signal) } == 0 {
Ok(())
} else {
Err(())
}
}
/// `/proc/<pid>/exe` must equal the canonical path of this binary. A trailing ` (deleted)` does not match.
fn same_host_binary(proc_exe: &std::path::Path, own: &std::path::Path) -> bool {
proc_exe == own
}
/// Explicit command words for set-encoder / set-codec. Empty and whitespace are illegal.
pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
let value = value.trim();
@@ -196,13 +232,75 @@ mod cli_exit_tests {
assert_eq!(super::reject_cli(Some("set-encoder"), 3, super::cli_pref_ok("set-encoder", "")), Some(2));
assert_eq!(super::reject_cli(Some("set-codec"), 3, super::cli_pref_ok("set-codec", " ")), Some(2));
}
/// SIGUSR1 and SIGUSR2 are installed with no assist UI. `host.pid` is written only after both exist.
#[test]
fn signal_handlers_install_without_assist() {
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir =
std::env::temp_dir().join(format!("uuremote-signal-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::env::set_var("UU_CONFIG", dir.join("config.json"));
assert!(super::install_host_signals(None));
let pid = std::fs::read_to_string(super::host_pid_path()).unwrap();
assert_eq!(pid.trim(), std::process::id().to_string());
std::env::remove_var("UU_CONFIG");
let _ = std::fs::remove_dir_all(&dir);
});
}
#[test]
fn sigusr2_requires_the_same_canonical_binary() {
let own = std::path::Path::new("/home/user/.local/bin/uuremote-server");
assert!(super::same_host_binary(own, own));
assert!(!super::same_host_binary(
std::path::Path::new("/tmp/unpack/uuremote-server"),
own
));
assert!(!super::same_host_binary(
std::path::Path::new("/home/user/.local/bin/uuremote-server (deleted)"),
own
));
}
}
/// SIGUSR1 (`uuremote-server show`) opens the host window.
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
// Install the handler before publishing the pid: SIGUSR1's default action terminates the process.
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
/// SIGUSR2 (set-encoder, set-codec, or `kill -USR2`) re-reads host_settings. Encoder changes switch live desktop streams; codec changes are logged for the next connection.
/// The default action of either signal terminates the process, so both handlers are installed before `host.pid` is written.
/// SIGUSR2 is independent of remote assistance: `UU_REMOTE_ASSIST=0` and a failed assist setup still switch live encoders.
/// SIGUSR1 is installed first as a no-op so `show` cannot terminate a host that has no assist window yet.
fn install_host_signals(ui: Option<std::sync::Arc<assist::LocalUi>>) -> bool {
static USR1: std::sync::Once = std::sync::Once::new();
static USR2: std::sync::Once = std::sync::Once::new();
let mut usr1_ok = true;
USR1.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
Ok(mut usr1) => { tokio::spawn(async move { while usr1.recv().await.is_some() {} }); }
Err(_) => usr1_ok = false,
}
});
if !usr1_ok { return false; }
let mut usr2_ok = true;
USR2.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined2()) {
Ok(mut usr2) => { tokio::spawn(async move { while usr2.recv().await.is_some() { crate::video_select::publish_reload(); } }); }
Err(_) => usr2_ok = false,
}
});
if !usr2_ok { return false; }
// Assist attaches later and replaces the no-op with the window. A second registration replaces the first.
if let Some(ui) = ui {
if let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
}
}
write_host_pid();
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
true
}
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
let _ = install_host_signals(Some(ui));
}
fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.pid") }
@@ -210,7 +308,9 @@ fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.p
fn write_host_pid() {
use std::os::unix::fs::OpenOptionsExt;
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(host_pid_path()) {
let path = host_pid_path();
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(path) {
let _ = write!(f, "{}", std::process::id());
}
}
@@ -521,6 +621,8 @@ 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"));
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
let _ = install_host_signals(None);
video::warm_auto_probe();
video::check_ffmpeg_usable();
+59 -8
View File
@@ -1140,9 +1140,16 @@ fn keep_stream_display_awake() {
if result.is_err() { log::warn!("Display wake failed; continuing desktop stream and retrying next interval"); }
}
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
/// `sync_tx` receives a Message 25 payload when a live encoder switch changes the encoded chroma.
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>) -> Result<(), String> {
stream_desktop_at(pc, track, size, display, portal, settings, applied, idr, selection, sync_tx, crate::video_select::reload_generation_value()).await
}
pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection) -> Result<(), String> {
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>, reload_at_session: u64) -> Result<(), String> {
let _desktop_mode = crate::desktop_mode::StreamGuard::new();
loop {
if transport_closed(&pc) { return Ok(()); }
@@ -1163,7 +1170,14 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
applied.send_replace(current);
settings.borrow_and_update();
}
// Reader restarts reuse this snapshot, so set-encoder waits for the next desktop connection.
// SIGUSR2 re-reads host_settings and restarts this encoder when the effective encoder changes.
// The negotiated codec stays; a codec-only change is logged and applied on the next connection.
let mut live_selection = selection;
let mut seen_codec_pref = selection.codec_pref;
let mut reload = crate::video_select::subscribe_reload();
// Only a SIGUSR2 since the session snapshot. A probe that finishes during setup is not a reload
// (sessions started before the probe keep the legacy encoder for their lifetime).
let mut reload_pending = crate::video_select::reload_since_session(reload_at_session, *reload.borrow());
let open = {
let display = display.clone();
let portal = portal.clone();
@@ -1175,7 +1189,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
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 reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
let mut previous = None;
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
let mut settings_open = true;
@@ -1190,6 +1204,43 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
let (mut window_frames, mut window_skipped) = (0u64, 0u64);
let mut send_interrupted=false;
'stream: loop {
if reload.has_changed().unwrap_or(false) || reload_pending {
reload_pending = false;
// Mark the watch seen. An unconsumed has_changed stays true and restarts every frame.
let _ = reload.borrow_and_update();
let fresh = crate::video_select::selection();
let plan = crate::video_select::plan_switch(live_selection.encoder, seen_codec_pref, &fresh, current.chroma);
if let Some(plan) = plan.filter(|plan| plan.encoder.is_some()) {
let encoder = plan.encoder.unwrap();
let chroma = if plan.chroma_downgraded { "420" } else if current.chroma == crate::capture_setting::CHROMA_444 { "444" } else { "420" };
log::info!("Encoder switch: {} -> {} reason={} chroma={chroma}",
format!("{:?}", live_selection.encoder).to_ascii_lowercase(),
format!("{encoder:?}").to_ascii_lowercase(),
crate::video_select::encoder_source_label(fresh.encoder_source));
live_selection.encoder = encoder;
live_selection.encoder_source = fresh.encoder_source;
seen_codec_pref = fresh.codec_pref;
if plan.chroma_downgraded {
applied.send_modify(|value| value.chroma = plan.chroma);
current.chroma = plan.chroma;
settings.borrow_and_update();
if let Some(sync) = sync_tx.as_ref() {
// Wayland: x11_resized is None, and the connection size can be a previous output.
let native = x11_resized(&display, portal_stream, size).unwrap_or_else(|| crate::wayland::sync_native(&display, current.source_id, size));
let payload = crate::capture_setting::sync_payload(&current, native);
let _ = sync.send(payload);
}
}
// In-process engines honor this on the first frame; the process pipeline starts on an IDR.
idr.store(true, std::sync::atomic::Ordering::Relaxed);
reader.restart(open(size, live_selection, current)).await;
} else if plan.is_some() {
log::info!("Codec preference changed; takes effect the next time a desktop connection starts");
seen_codec_pref = fresh.codec_pref;
live_selection.codec_pref = fresh.codec_pref;
live_selection.codec_source = fresh.codec_source;
}
}
let next = *settings.borrow_and_update();
if next != current || send_interrupted {
let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted;
@@ -1201,9 +1252,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(open(size, selection, next));
reader.0 = tokio::spawn(open(size, live_selection, next));
} else {
reader.restart(open(size, selection, next)).await;
reader.restart(open(size, live_selection, next)).await;
}
send_interrupted=false;
}
@@ -1214,7 +1265,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(open(size, selection, current));
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
@@ -1222,7 +1273,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(open(size, selection, current));
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
+164
View File
@@ -234,11 +234,103 @@ pub fn cached_probe() -> Option<ProbeReport> {
#[cfg(test)]
pub(crate) static PROBE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
/// Tests that read or bump the process-global reload generation share this lock.
#[cfg(test)]
pub(crate) static RELOAD_TEST_LOCK:std::sync::Mutex<()> = std::sync::Mutex::new(());
#[cfg(test)]
pub fn clear_probe() {
if let Ok(mut slot) = cache().lock() { *slot = None; }
}
/// Why a live desktop encoder was asked to change.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SwitchReason {
/// Effective encoder differs. The log line uses `Selection::encoder_source`, not this variant.
Encoder,
/// Codec preference changed. The negotiated codec stays until the next stream.
CodecDeferred,
}
/// What SIGUSR2 should do to one live desktop stream.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SwitchPlan {
/// Restart the encoder. None keeps the running encoder (codec-only or no change).
pub encoder: Option<Encoder>,
pub reason: SwitchReason,
/// Chroma the restarted encoder can actually produce. VAAPI has no 4:4:4.
pub chroma: u64,
/// True when the request was 4:4:4 and the new encoder must report 4:2:0.
pub chroma_downgraded: bool,
}
/// Compare the selection this stream is using with a freshly read one.
/// Codec preference is the stored preference, not the negotiated m-line codec.
pub fn plan_switch(active_encoder: Encoder, previous_codec: CodecPref, next: &Selection, active_chroma: u64) -> Option<SwitchPlan> {
if next.encoder != active_encoder {
let chroma = if active_chroma == crate::capture_setting::CHROMA_444 && !crate::video::full_chroma_for(next.encoder) {
crate::capture_setting::CHROMA_420
} else {
active_chroma
};
return Some(SwitchPlan {
encoder: Some(next.encoder),
reason: SwitchReason::Encoder,
chroma,
chroma_downgraded: chroma != active_chroma,
});
}
if next.codec_pref != previous_codec {
return Some(SwitchPlan {
encoder: None,
reason: SwitchReason::CodecDeferred,
chroma: active_chroma,
chroma_downgraded: false,
});
}
None
}
/// Monotonic generation bumped by SIGUSR2. Streams watch it and re-read `selection()`.
fn reload_generation() -> &'static std::sync::atomic::AtomicU64 {
static GEN: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
&GEN
}
pub fn reload_generation_value() -> u64 {
reload_generation().load(std::sync::atomic::Ordering::Relaxed)
}
/// SIGUSR2: ask live desktop streams to re-read host_settings. Does not clear the probe cache.
pub fn notify_reload() {
reload_generation().fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
pub fn reload_watch() -> &'static tokio::sync::watch::Sender<u64> {
static WATCH: std::sync::OnceLock<tokio::sync::watch::Sender<u64>> = std::sync::OnceLock::new();
WATCH.get_or_init(|| {
let (tx, _) = tokio::sync::watch::channel(reload_generation_value());
tx
})
}
pub fn subscribe_reload() -> tokio::sync::watch::Receiver<u64> {
reload_watch().subscribe()
}
/// True when SIGUSR2 has bumped the generation since the session snapshot.
/// A background auto probe that finishes during setup does not bump it.
pub fn reload_since_session(at_session: u64, current: u64) -> bool {
current != at_session
}
/// Publish the generation so every subscribed desktop stream wakes.
pub fn publish_reload() {
notify_reload();
// send() drops the value when nobody is subscribed (the gap between desktop connections).
reload_watch().send_replace(reload_generation_value());
}
/// Setting (non-auto) beats the environment, which beats the NVIDIA/CPU default.
pub fn selection() -> Selection {
selection_with(cached_probe().as_ref())
@@ -486,6 +578,78 @@ mod tests {
assert_eq!(resolve_pair(None, None, None, Some("h264"), false, Some(&va)).codec_pref, CodecPref::H264);
}
fn selection_of(encoder: Encoder, codec: CodecPref) -> Selection {
Selection { encoder, encoder_source: Source::Setting, codec_pref: codec, codec_source: Source::Setting }
}
#[test]
fn live_switch_restarts_encoder_and_defers_codec() {
let nv = selection_of(Encoder::Nvenc, CodecPref::Auto);
assert!(plan_switch(Encoder::Nvenc, CodecPref::Auto, &nv, crate::capture_setting::CHROMA_420).is_none());
let to_cpu = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Cpu, CodecPref::Auto), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_cpu.encoder, Some(Encoder::Cpu));
assert_eq!(to_cpu.reason, SwitchReason::Encoder);
assert!(!to_cpu.chroma_downgraded);
assert_eq!(to_cpu.chroma, crate::capture_setting::CHROMA_444);
let to_vaapi = plan_switch(Encoder::Nvenc, CodecPref::H265, &selection_of(Encoder::Vaapi, CodecPref::H265), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_vaapi.encoder, Some(Encoder::Vaapi));
assert!(to_vaapi.chroma_downgraded);
assert_eq!(to_vaapi.chroma, crate::capture_setting::CHROMA_420);
let codec = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(codec.encoder, None);
assert_eq!(codec.reason, SwitchReason::CodecDeferred);
let both = plan_switch(Encoder::Cpu, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(both.encoder, Some(Encoder::Nvenc));
assert_eq!(both.reason, SwitchReason::Encoder);
// The log reason is the source of the new selection (setting / env / auto), not a fixed word.
for (source, label) in [(Source::Setting, "setting"), (Source::Env, "env"), (Source::Auto, "auto")] {
let mut next = selection_of(Encoder::Vaapi, CodecPref::Auto);
next.encoder_source = source;
let plan = plan_switch(Encoder::Nvenc, CodecPref::Auto, &next, crate::capture_setting::CHROMA_420).unwrap();
assert!(plan.encoder.is_some());
assert_eq!(encoder_source_label(next.encoder_source), label);
}
}
#[test]
fn reload_does_not_clear_the_probe_cache() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let report = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
store_probe(report.clone());
let before = reload_generation_value();
notify_reload();
assert_eq!(reload_generation_value(), before + 1);
assert_eq!(cached_probe(), Some(report));
assert!(reload_since_session(before, reload_generation_value()));
assert!(!reload_since_session(reload_generation_value(), reload_generation_value()));
clear_probe();
}
#[test]
fn probe_finish_is_not_a_reload_since_the_session_snapshot() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let at_session = reload_generation_value();
// A finished background probe updates the cache only. It does not bump the generation.
assert!(!reload_since_session(at_session, reload_generation_value()));
notify_reload();
assert!(reload_since_session(at_session, reload_generation_value()));
}
#[test]
fn mark_reload_seen_clears_has_changed() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let mut watch = subscribe_reload();
let _ = watch.borrow_and_update();
publish_reload();
assert!(watch.has_changed().unwrap());
let _ = watch.borrow_and_update();
assert!(!watch.has_changed().unwrap());
});
}
/// 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).
+1 -1
View File
@@ -78,7 +78,7 @@ async fn exercise(fail_wake: usize, fail_capture: bool) {
let (settings_tx, settings_rx) = tokio::sync::watch::channel(settings);
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));
DISPLAY.into(), None, settings_rx, Arc::new(settings_tx), Arc::new(AtomicBool::new(false)), selection, None));
let result = if fail_capture {
Some((&mut task).await.unwrap())
} else {
+35
View File
@@ -255,6 +255,25 @@ pub fn selection()->(usize,u64) {let s=SELECTION.lock().unwrap();(s.id,s.generat
pub fn selected()->usize {selection().0}
pub fn source(id:usize)->Option<&'static Output> {outputs().get(id)}
pub fn input_size(fallback:(u32,u32))->(u32,u32) {source(selected()).map_or(fallback,|s|(s.width,s.height))}
/// Pixel size of one advertised output. Unknown ids keep `fallback` (connection size).
pub fn source_size(id:usize,fallback:(u32,u32))->(u32,u32) {
#[cfg(test)]
if let Some(outputs)=*test_outputs().lock().unwrap_or_else(|e|e.into_inner()) {
return outputs.get(id).map_or(fallback,|s|(s.width,s.height));
}
source(id).map_or(fallback,|s|(s.width,s.height))
}
#[cfg(test)]
fn test_outputs()->&'static std::sync::Mutex<Option<&'static [Output]>> {
static SLOT:std::sync::OnceLock<std::sync::Mutex<Option<&'static [Output]>>>=std::sync::OnceLock::new();
SLOT.get_or_init(||std::sync::Mutex::new(None))
}
/// Native size written into CaptureSettingSync. Wayland uses the output the encoder is reading
/// (`source_id`), which can differ from the size captured when the connection opened. X11, portal
/// and KMS keep the connection size (X11 mode changes go through `x11_resized`).
pub fn sync_native(display:&str,source_id:usize,connection:(u32,u32))->(u32,u32) {
if display.starts_with("wayland:") {source_size(source_id,connection)} else {connection}
}
pub fn input_ready()->bool {outputs().is_empty() || SELECTION.lock().unwrap().ready()}
pub fn switch_failed()->bool {SELECTION.lock().unwrap().failed}
pub fn presented(id:usize,generation:u64) {SELECTION.lock().unwrap().sent(id,generation);}
@@ -353,4 +372,20 @@ mod selection_regressions {
assert_eq!(outputs.len(),1);assert_eq!(outputs[0].name,"normal");
assert!(parse_outputs(b"not JSON","").is_err());
}
#[test]
fn sync_native_follows_the_wayland_source_id() {
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
assert_eq!(sync_native("kms:/dev/dri/card0",1,(1920,1080)),(1920,1080));
let inventory:&'static [Output]=Box::leak(vec![
Output {name:"eDP-1".into(),width:1920,height:1080,fps:60},
Output {name:"HDMI-A-1".into(),width:2560,height:1440,fps:75},
].into_boxed_slice());
*test_outputs().lock().unwrap()=Some(inventory);
// Connection opened on the first output; the encoder is reading the second.
assert_eq!(sync_native("wayland:wayland-0",1,(1920,1080)),(2560,1440));
assert_eq!(source_size(0,(800,600)),(1920,1080));
assert_eq!(sync_native("wayland:wayland-0",9,(800,600)),(800,600));
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
*test_outputs().lock().unwrap()=None;
}
}
+62 -9
View File
@@ -65,6 +65,8 @@ impl WebRtcSession {
// Encoder, codec preference and 4:4:4 stay fixed for this peer (codec is negotiated at CONTROL open).
// Read once before the HEVC probe so a concurrent set-encoder/set-codec cannot split capability from CONTROL.
// reload_at_session is the generation at that snapshot. A probe that finishes later is not a reload.
let reload_at_session = crate::video_select::reload_generation_value();
let video_selection = crate::video_select::selection();
let hevc = desktop && crate::video::hevc_available(video_selection.encoder).await;
if hevc { crate::video_track::register_hevc(&mut m).map_err(|e| format!("Register HEVC failed: {e}"))?; }
@@ -305,6 +307,10 @@ impl WebRtcSession {
let portal=capture.portal.clone();
let stream_desktop = portal_desktop.clone();
let stream_selection = video_selection;
// Live encoder switch (SIGUSR2) sends CaptureSettingSync when chroma is downgraded.
let (chroma_sync_tx, chroma_sync_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let chroma_sync = (desktop && !cfg!(test)).then_some(chroma_sync_tx);
let chroma_sync_rx = Arc::new(std::sync::Mutex::new((!cfg!(test)).then_some(chroma_sync_rx)));
// File/terminal/port-mapping connections carry no desktop video.
let control_video_track = video_track.clone();
let stream_settings = video_settings.clone();
@@ -330,7 +336,7 @@ impl WebRtcSession {
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request, stream_selection).await {
if let Err(e) = crate::video::stream_desktop_at(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request, stream_selection, chroma_sync.clone(), reload_at_session).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
@@ -421,6 +427,7 @@ impl WebRtcSession {
let peer_video_track = control_video_track.clone();
let peer_actions = peer_actions.clone();
let peer_selection = video_selection;
let chroma_sync_rx = chroma_sync_rx.clone();
if label == "FILE_DATA_CHANNEL" { *file_channel.lock().unwrap() = Some(d.clone()); }
Box::pin(async move {
@@ -442,17 +449,47 @@ impl WebRtcSession {
}));
}
// Ordered outbound queue for protocol replies produced outside this callback.
let (outbound, mut outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
// Message 25 and every later reply. Start CONTROL from the on_open below
// (one handler; a second on_open replaces it). Receiver taken once.
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
if label == "CONTROL_DATA_CHANNEL" {
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
let sync_out = outbound.clone();
let sync_seq = reply_sequence.clone();
tokio::spawn(async move {
while let Some(payload) = chroma_sync_rx.recv().await {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let seq = sync_seq.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let _ = sync_out.send(crate::initialization::envelope(seq, timestamp, 25, &payload));
}
});
}
}
{
let out_channel = d.clone();
let out_label = label.clone();
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
let outbound_rx = outbound_rx.clone();
let start_drain = move || {
let out_channel = out_channel.clone();
let out_label = out_label.clone();
let outbound_rx = outbound_rx.clone();
Box::pin(async move {
let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; };
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
};
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
else { control_drain = Some(Box::new(start_drain)); }
}
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
@@ -640,6 +677,7 @@ impl WebRtcSession {
let open_screen = screen.clone();
let open_selection = peer_selection;
d.on_open(Box::new(move || {
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
let init_actions = open_actions.clone();
let init_video = open_video.clone();
let init_track = open_track.clone();
@@ -1422,6 +1460,11 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
None
}
/// First drain owns the outbound receiver; a later open must not start another.
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
slot.lock().await.take()
}
#[cfg(test)]
mod tests {
use super::negotiated_bundle_media;
@@ -1444,6 +1487,16 @@ mod tests {
let sdp = "a=group:BUNDLE data video\nm=video 9 RTP 98\na=mid:video\nm=application 9 SCTP 0\na=mid:data\n";
assert_eq!(negotiated_bundle_media(sdp), Some(("data".into(), 1)));
}
#[tokio::test]
async fn outbound_receiver_is_taken_once() {
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let slot = std::sync::Arc::new(tokio::sync::Mutex::new(Some(rx)));
let first = super::take_outbound_once(&slot).await;
let second = super::take_outbound_once(&slot).await;
assert!(first.is_some());
assert!(second.is_none());
drop(tx);
}
}
#[cfg(test)]