From d95053d490a3dcceaeefd466836d230bcc2531ef Mon Sep 17 00:00:00 2001 From: VallierDev <49166112@qq.com> Date: Thu, 22 Oct 2026 02:44:18 -0700 Subject: [PATCH] X11: change the desktop resolution for the viewer's choice; survive live resizes (#86) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Restart X11 capture at the new size when the desktop is resized mid-stream A RandR resize during a session made x11grab fail with BadMatch on the old size. read_encoder treated that as an encoder failure and walked the whole fallback chain (NVENC -> CPU, HEVC -> H.264) with the stale size, then the stream stopped ("Encoder output ended") and the viewer froze. New connections already re-probed the geometry (#18); live ones did not. - When an X11 stream fails and the root size differs, skip the encoder fallback and restart capture at the new size with the same settings. - Absolute pointer mapping follows the refreshed X11 size. - New connections compare the root size with their capture instead of the engine's change flag, which a live stream may already have consumed. Co-Authored-By: Claude Opus 5.5 * Change the X11 desktop resolution when the viewer picks one The official Windows host changes its display resolution for the viewer's 分辨率 choice; this host only scaled the encoded stream, so a smaller choice made text smaller and blurrier instead of larger. On X11 the capture/resolution RPC now switches the primary output's mode with xrandr (an existing mode of that size, else a CVT reduced-blanking mode at 60 Hz, or 30 Hz above an HDMI 2.0 pixel clock), re-applying it when mutter resets the mode after the list changes. resolution_type 3 (original) and the end of the last desktop stream restore the mode in use before the first change. The stream restarts capture at the new native size and reports it in the screen sources and CaptureSettingSync. UU_DESKTOP_RESIZE=0 keeps the old encoder scaling; Wayland is unchanged. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: VallierDev <24893073+VallierDev@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 --- AGENTS.md | 1 + README.en.md | 3 +- README.md | 3 +- src/capture.rs | 16 ++- src/capture_setting.rs | 15 +++ src/desktop_mode.rs | 222 +++++++++++++++++++++++++++++++++++++++++ src/main.rs | 4 +- src/video.rs | 23 ++++- src/webrtc.rs | 22 +++- 9 files changed, 297 insertions(+), 12 deletions(-) create mode 100644 src/desktop_mode.rs diff --git a/AGENTS.md b/AGENTS.md index 9a41b4d..5f1cc1b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -116,6 +116,7 @@ viewer does not reconnect them automatically. | `~/.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 | | `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_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) | | 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) | diff --git a/README.en.md b/README.en.md index 96f93af..f93b083 100644 --- a/README.en.md +++ b/README.en.md @@ -46,7 +46,7 @@ | Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) | | Pointer shape | Remote cursor shape is mirrored to the viewer (X11) | | Clipboard | Two-way text sync | -| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; "other resolutions" are scaled by the encoder, the host monitor is left untouched | +| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder | | Sound | System audio captured from PulseAudio / PipeWire and sent as Opus | | File transfer | Upload, download (including folders), create folder, rename, delete | | Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename | @@ -330,6 +330,7 @@ Common environment variables: |---|---| | `UU_CONFIG` | Config file path (default `~/.config/uuremote/config.json`) | | `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless) | +| `UU_DESKTOP_RESIZE=0` | on X11, keep the desktop resolution and only scale the encoded stream when the viewer picks a resolution | | `UU_WAYLAND_MULTISCREEN=1` | Enable Hyprland physical monitor switching (off by default) | | `UU_WAYLAND_OUTPUT` | Initial native Wayland output name, e.g. `HDMI-A-1` | | `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) | diff --git a/README.md b/README.md index 48ebf9c..1f45105 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ | Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) | | 鼠标指针样式 | 远端指针形状实时同步(X11) | | 剪贴板 | 双向文本同步 | -| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;「其他分辨率」由编码器缩放,不改动主机显示器 | +| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 | | 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 | | 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 | | 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 | @@ -299,6 +299,7 @@ systemctl --user restart uuremote-native.service |---|---| | `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) | | `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) | +| `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 | | `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) | | `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) | diff --git a/src/capture.rs b/src/capture.rs index 6f42712..a5dc09b 100644 --- a/src/capture.rs +++ b/src/capture.rs @@ -46,14 +46,22 @@ unsafe fn x11_display_name() -> *const libc::c_char { b":0\0".as_ptr().cast() } /// The X11 root can be resized while the host runs (RandR, xrdp reconnects); the /// geometry read at startup then makes x11grab reject every new connection. -pub fn x11_resized() -> bool { +/// Re-reads the root size; None when the X11 engine is not in use or the query fails. +pub fn x11_size() -> Option<(u32, u32)> { match unsafe { x11_refresh_geometry() } { - 1 => true, - 0 => false, - code => { log::warn!("X11 geometry query failed with code {code}"); false } + 0 | 1 => x11_last_size(), + -1 => None, + code => { log::warn!("X11 geometry query failed with code {code}"); None } } } +/// The root size from the last refresh, without an X round trip (pointer mapping). +pub fn x11_last_size() -> Option<(u32, u32)> { + let (mut w, mut h): (libc::c_int, libc::c_int) = (0, 0); + if unsafe { x11_get_dimensions(&mut w, &mut h) } != 0 || w <= 0 || h <= 0 { return None; } + Some((w as u32, h as u32)) +} + pub struct ScreenCapture { pub backend: crate::desktop_backend::DesktopBackend, pub init_error: Option, diff --git a/src/capture_setting.rs b/src/capture_setting.rs index eed91fa..ad7c15a 100644 --- a/src/capture_setting.rs +++ b/src/capture_setting.rs @@ -141,6 +141,21 @@ pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender Option { + use crate::desktop_mode::Request; + if let Some(request) = message(rpc, 2) { + let fields = decode_wire(request).ok()?; + if number(&fields, 10) == Some(3) { return Some(Request::Native); } + let (w, h) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6)))?; + Some(Request::Size(u32::try_from(w).ok()?, u32::try_from(h).ok()?)) + } else if let Some(request) = message(rpc, 6) { + let fields = decode_wire(request).ok()?; + Some(Request::Size(u32::try_from(number(&fields, 1)?).ok()?, u32::try_from(number(&fields, 2)?).ok()?)) + } else { None } +} + fn apply_rpc(rpc: &[WireField], settings: &watch::Sender, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option> { let header = message(rpc, 1).unwrap_or(&[]); let mut next = *settings.borrow(); diff --git a/src/desktop_mode.rs b/src/desktop_mode.rs new file mode 100644 index 0000000..2375104 --- /dev/null +++ b/src/desktop_mode.rs @@ -0,0 +1,222 @@ +//! X11 desktop resolution follows the viewer's 分辨率 choice, like the official Windows host: +//! the display mode itself changes (xrandr), not just the encoded size. The mode in use before +//! the first change is restored for 原始/follow-remote and when the last desktop stream ends. +//! Disable with UU_DESKTOP_RESIZE=0 (the viewer choice then scales the encoded stream instead). + +use std::process::Command; +use std::sync::Mutex; +use std::sync::atomic::{AtomicUsize, Ordering}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Request { Native, Size(u32, u32) } + +struct Original { display: String, output: String, mode: String } + +static ORIGINAL: Mutex> = Mutex::new(None); +static STREAMS: AtomicUsize = AtomicUsize::new(0); + +/// Upper bound per side (H.264 NVENC/VAAPI limit) and lower bound for a usable desktop. +const MAX_SIDE: u32 = 4096; +const MIN_SIZE: (u32, u32) = (640, 480); + +pub fn enabled() -> bool { std::env::var("UU_DESKTOP_RESIZE").map_or(true, |v| v != "0") } + +/// Keeps the changed mode while any desktop stream runs; the last one restores it. +pub struct StreamGuard; +impl StreamGuard { + pub fn new() -> Self { STREAMS.fetch_add(1, Ordering::SeqCst); Self } +} +impl Drop for StreamGuard { + fn drop(&mut self) { + if STREAMS.fetch_sub(1, Ordering::SeqCst) == 1 && ORIGINAL.lock().unwrap().is_some() { + // xrandr blocks; never run it on the async runtime thread dropping the stream. + std::thread::spawn(|| { + std::thread::sleep(std::time::Duration::from_secs(2)); + if STREAMS.load(Ordering::SeqCst) == 0 { restore(); } + }); + } + } +} + +/// Applies the viewer's resolution request to the X11 display; returns the desktop size now in +/// use, or None when nothing changed hands (the caller keeps encoder scaling as the fallback). +pub fn apply(display: &str, request: Request) -> Option<(u32, u32)> { + match request { + Request::Native => { restore(); crate::capture::x11_size() }, + Request::Size(w, h) => { + let target = fit(w, h)?; + match switch(display, target) { + Ok(()) => crate::capture::x11_size(), + Err(error) => { log::warn!("Desktop resolution change to {}x{} failed: {}", target.0, target.1, error); None }, + } + }, + } +} + +/// Even sides within MIN_SIZE..=MAX_SIDE, keeping the aspect ratio when scaled down. +fn fit(w: u32, h: u32) -> Option<(u32, u32)> { + if w == 0 || h == 0 { return None; } + let scale = (f64::from(MAX_SIDE) / f64::from(w.max(h))).min(1.0); + let (w, h) = ((f64::from(w) * scale).round() as u32, (f64::from(h) * scale).round() as u32); + Some((w.max(MIN_SIZE.0) & !1, h.max(MIN_SIZE.1) & !1)) +} + +fn switch(display: &str, target: (u32, u32)) -> Result<(), String> { + let state = query(display)?; + if state.current == Some(target) { return Ok(()); } + { + let mut original = ORIGINAL.lock().unwrap(); + if original.is_none() { + let mode = state.current_mode.clone().ok_or("current mode unknown")?; + log::info!("Desktop resolution: saving original mode {} on {}", mode, state.output); + *original = Some(Original { display: display.into(), output: state.output.clone(), mode }); + } + } + let mode = match state.modes.iter().find(|(_, size)| *size == target) { + Some((name, _)) => name.clone(), + None => { + let (name, timings) = cvt_reduced(target.0, target.1); + // An existing mode of this name (earlier session) makes --newmode fail harmlessly. + let mut args = vec!["--newmode", name.as_str()]; + args.extend(timings.iter().map(String::as_str)); + let _ = xrandr(display, &args); + xrandr(display, &["--addmode", &state.output, &name])?; + name + }, + }; + set_mode(display, &state.output, &mode, target)?; + log::info!("Desktop resolution changed to {}x{} ({})", target.0, target.1, mode); + Ok(()) +} + +/// Restores the mode saved before the first change, if any. +pub fn restore() { + let Some(original) = ORIGINAL.lock().unwrap().take() else { return; }; + let size = query(&original.display).ok().and_then(|state| state.modes.into_iter().find(|(name, _)| *name == original.mode).map(|(_, size)| size)); + match size.ok_or_else(|| "original mode no longer listed".to_owned()) + .and_then(|size| set_mode(&original.display, &original.output, &original.mode, size)) { + Ok(()) => log::info!("Desktop resolution restored to {}", original.mode), + Err(error) => log::warn!("Desktop resolution restore failed: {}", error), + } + let _ = crate::capture::x11_size(); +} + +/// GNOME/mutter may answer a mode list change by re-applying its preferred mode; set it again. +fn set_mode(display: &str, output: &str, mode: &str, size: (u32, u32)) -> Result<(), String> { + for _ in 0..3 { + xrandr(display, &["--output", output, "--mode", mode])?; + std::thread::sleep(std::time::Duration::from_millis(1500)); + if query(display)?.current == Some(size) { return Ok(()); } + } + Err(format!("{output} did not keep {mode}")) +} + +fn xrandr(display: &str, args: &[&str]) -> Result { + let output = Command::new("xrandr").arg("--display").arg(display).args(args).output() + .map_err(|e| format!("xrandr unavailable: {}", e.kind()))?; + if !output.status.success() { return Err(format!("xrandr {} exited with {}", args.first().unwrap_or(&""), output.status)); } + Ok(String::from_utf8_lossy(&output.stdout).into_owned()) +} + +struct State { output: String, current: Option<(u32, u32)>, current_mode: Option, modes: Vec<(String, (u32, u32))> } + +fn query(display: &str) -> Result { parse(&xrandr(display, &["--query"])?).ok_or_else(|| "no connected output".into()) } + +/// The primary connected output (else the first connected one with a mode) and its mode list. +fn parse(text: &str) -> Option { + let mut outputs: Vec<(bool, State)> = Vec::new(); + for line in text.lines() { + if let Some(rest) = line.strip_prefix(" ") { + let Some((_, state)) = outputs.last_mut() else { continue; }; + let mut parts = rest.split_whitespace(); + let Some(name) = parts.next() else { continue; }; + let Some(size) = mode_size(name) else { continue; }; + if parts.any(|rate| rate.contains('*')) { state.current = Some(size); state.current_mode = Some(name.into()); } + state.modes.push((name.into(), size)); + } else if !line.starts_with(' ') { + let mut parts = line.split_whitespace(); + let (Some(name), Some("connected")) = (parts.next(), parts.next()) else { outputs.push((false, State { output: String::new(), current: None, current_mode: None, modes: Vec::new() })); continue; }; + let primary = line.contains(" connected primary "); + outputs.push((primary, State { output: name.into(), current: None, current_mode: None, modes: Vec::new() })); + } + } + let mut connected: Vec<(bool, State)> = outputs.into_iter().filter(|(_, s)| !s.output.is_empty() && s.current.is_some()).collect(); + let index = connected.iter().position(|(primary, _)| *primary).unwrap_or(0); + (index < connected.len()).then(|| connected.swap_remove(index).1) +} + +/// "1920x1080", "1920x1080R", "1920x1080_60.00", "1920x1080i" → (1920, 1080). +fn mode_size(name: &str) -> Option<(u32, u32)> { + let (w, rest) = name.split_once('x')?; + let h: String = rest.chars().take_while(char::is_ascii_digit).collect(); + Some((w.parse().ok()?, h.parse().ok()?)) +} + +/// VESA CVT reduced-blanking (v1) timings: 60 Hz, or 30 Hz when 60 Hz exceeds an HDMI 2.0 +/// pixel clock (virtual/forced connectors on integrated GPUs reject faster modes). +fn cvt_reduced(w: u32, h: u32) -> (String, Vec) { + const H_BLANK: u32 = 160; const H_SYNC: u32 = 32; const H_FRONT: u32 = 48; + const V_FRONT: u32 = 3; const MIN_V_BACK: u32 = 6; const MIN_VBLANK_US: f64 = 460.0; + let v_sync = match (w * 3 == h * 4, w * 9 == h * 16, w * 10 == h * 16, w * 4 == h * 5, w * 9 == h * 15) { + (true, ..) => 4, (_, true, ..) => 5, (_, _, true, ..) => 6, (_, _, _, true, _) | (.., true) => 7, _ => 10, + }; + let timing = |refresh: f64| { + let h_period = (1_000_000.0 / refresh - MIN_VBLANK_US) / f64::from(h); + let vbi = ((MIN_VBLANK_US / h_period) as u32 + 1).max(V_FRONT + v_sync + MIN_V_BACK); + let (total_h, total_v) = (w + H_BLANK, h + vbi); + let clock = (refresh * f64::from(total_h) * f64::from(total_v) / 1_000_000.0 / 0.25).floor() * 0.25; + (clock, total_h, total_v) + }; + let (mut refresh, mut t) = (60, timing(60.0)); + if t.0 > 590.0 { refresh = 30; t = timing(30.0); } + let (clock, total_h, total_v) = t; + let name = format!("{w}x{h}_{refresh}R"); + let timings = [format!("{clock:.2}"), w.to_string(), (w + H_FRONT).to_string(), (w + H_FRONT + H_SYNC).to_string(), total_h.to_string(), + h.to_string(), (h + V_FRONT).to_string(), (h + V_FRONT + v_sync).to_string(), total_v.to_string(), "+hsync".into(), "-vsync".into()]; + (name, timings.into()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn reduced_blanking_matches_the_cvt_tool() { + // `cvt -r 1920 1080`: 138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync + let (name, t) = cvt_reduced(1920, 1080); + assert_eq!(name, "1920x1080_60R"); + assert_eq!(t.join(" "), "138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync"); + // `cvt -r 2560 1600`: 268.50 2560 2608 2640 2720 1600 1603 1609 1646 + assert_eq!(cvt_reduced(2560, 1600).1.join(" "), "268.50 2560 2608 2640 2720 1600 1603 1609 1646 +hsync -vsync"); + // 4K at 60 Hz needs 533 MHz (under the cap); a larger desktop drops to 30 Hz. + assert_eq!(cvt_reduced(3840, 2160).0, "3840x2160_60R"); + assert_eq!(cvt_reduced(4096, 2560).0, "4096x2560_30R"); + } + + #[test] + fn requested_sizes_are_even_and_bounded() { + assert_eq!(fit(1280, 720), Some((1280, 720))); + assert_eq!(fit(4112, 2580), Some((4096, 2570))); + assert_eq!(fit(301, 201), Some((640, 480))); + assert_eq!(fit(0, 1080), None); + } + + #[test] + fn parses_primary_output_modes_and_current_mode() { + let text = r"Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 16384 x 16384 +DP-1 disconnected (normal left inverted right x axis y axis) +HDMI-1 connected primary 1920x1080+0+0 (normal left inverted right x axis y axis) 0mm x 0mm + 1024x768 60.00 + 3840x2160R 29.98 + 1920x1080R 59.93*+ +HDMI-2 disconnected (normal left inverted right x axis y axis) +"; + let state = parse(text).unwrap(); + assert_eq!(state.output, "HDMI-1"); + assert_eq!(state.current, Some((1920, 1080))); + assert_eq!(state.current_mode.as_deref(), Some("1920x1080R")); + assert_eq!(state.modes.len(), 3); + assert_eq!(state.modes[1], ("3840x2160R".to_owned(), (3840, 2160))); + assert!(parse("Screen 0: minimum 320 x 200\nDP-1 disconnected (normal)\n").is_none()); + } +} diff --git a/src/main.rs b/src/main.rs index 272071a..06cdc19 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,6 +5,7 @@ mod engine_plugin; mod doctor; mod wol; mod desktop_backend; +mod desktop_mode; mod desktop_session; mod desktop_power; mod portal; @@ -784,7 +785,8 @@ async fn serve(mut capture: Arc, input: Arc, shutd continue; } let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11 - && tokio::task::spawn_blocking(crate::capture::x11_resized).await.unwrap_or(false); + // Compare with this capture, not the engine: a live stream may already have refreshed it. + && tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size!=(capture.width,capture.height)); if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); } let session_capture=if desktop && portal_desktop.is_none() && (capture.init_error.is_some() || resized) { match tokio::task::spawn_blocking(ScreenCapture::new).await { diff --git a/src/video.rs b/src/video.rs index 9f921bc..77c9911 100644 --- a/src/video.rs +++ b/src/video.rs @@ -510,14 +510,14 @@ async fn read_encoder( // A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline. #[cfg(feature = "inproc-av")] if let Err(error) = &result { - if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) { + if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() { log::warn!("In-process {} stream unavailable; switching to the FFmpeg process pipeline: {}",encoder.name_for(settings.codec),error); result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone()).await; } } match result { Ok(())=>Ok(()), - Err(error) if !latest.is_closed()=>{ + Err(error) if !latest.is_closed() && x11_resized(&display, portal.is_some(), size).is_none()=>{ log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error); read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await }, @@ -525,6 +525,13 @@ async fn read_encoder( } } +/// A resized X11 root fails every encoder alike (x11grab BadMatch on the old size); +/// returns the new size so the stream restarts capture instead of walking the fallback chain. +fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u32)> { + if portal || display.starts_with("wayland:") || display.starts_with("kms:") { return None; } + crate::capture::x11_size().filter(|current| *current != size) +} + /// 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 { @@ -915,8 +922,9 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option, track: Arc, size: (u32, u32), display: String, portal:Option>, +pub async fn stream_desktop(pc: Arc, track: Arc, mut size: (u32, u32), display: String, portal:Option>, mut settings: tokio::sync::watch::Receiver, applied: Arc>, idr: Arc) -> Result<(), String> { + let _desktop_mode = crate::desktop_mode::StreamGuard::new(); loop { if transport_closed(&pc) { return Ok(()); } if pc.connection_state() == RTCPeerConnectionState::Connected @@ -956,6 +964,8 @@ pub async fn stream_desktop(pc: Arc, track: Arc, track: Arc { let result = result.map_err(|e| format!("Encoder reader task: {e}"))?; + if let Some(resized) = result.as_ref().err().and_then(|_| x11_resized(&display, portal_stream, size)) { + 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())); + continue; + } if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) { log::warn!("HEVC stream failed ({error}); falling back to negotiated H264"); applied.send_modify(|value| value.codec = VideoCodec::H264); diff --git a/src/webrtc.rs b/src/webrtc.rs index ce4f664..a2467bd 100644 --- a/src/webrtc.rs +++ b/src/webrtc.rs @@ -560,6 +560,20 @@ impl WebRtcSession { (21, WireValue::Bytes(rpc)) => Some(*rpc), _ => None, }) else { continue; }; let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; }; + // X11: 分辨率 changes the display mode itself, like the official Windows host; the stream + // then carries the new native size instead of a scaled one (desktop_mode). + let resized = if desktop && active_screen.init_error.is_none() && active_screen.portal.is_none() + && active_screen.backend == crate::desktop_backend::DesktopBackend::X11 && crate::desktop_mode::enabled() { + match crate::capture_setting::requested_resolution(&rpc_fields) { + Some(request) => { + let display = active_screen.display.clone(); + tokio::task::spawn_blocking(move || crate::desktop_mode::apply(&display, request)).await.ok().flatten() + .filter(|size| *size != input_size) + }, + None => None, + } + } else { None }; + let input_size = resized.unwrap_or(input_size); let before = *settings.borrow(); let output_before = before.output; let revision = track.revision(); @@ -571,6 +585,8 @@ impl WebRtcSession { let mut response=None;owner.with_current(||response=apply());response } else {apply()}; let Some(response)=response else {continue;}; + // Restart capture even when the encoded settings are unchanged (native size, no scaling). + if resized.is_some() { settings.send_modify(|s| s.source_generation = s.source_generation.wrapping_add(1)); } let codec_changed = settings.borrow().codec != before.codec; if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await { log::warn!("Codec switch did not produce a transmitted frame; success reply withheld"); @@ -581,7 +597,7 @@ impl WebRtcSession { let next = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 22, &response)); let current = *settings.borrow(); - if current.output != output_before { + if current.output != output_before || resized.is_some() { match crate::capture_setting::screen_sources(next(), timestamp, input_size, current.output, "Linux desktop") { Ok(screens) => { let _ = response_tx.send(screens); } Err(error) => log::warn!("Screen sources update failed: {}", error), @@ -889,6 +905,8 @@ impl WebRtcSession { Box::pin(async move { let input_size = crate::wayland::input_size((screen.width, screen.height)); + // After a RandR resize the stream restarts capture at the new size; map the pointer to it. + let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11; if let Some(term) = &terminal_worker { if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; } } @@ -1160,7 +1178,7 @@ impl WebRtcSession { if let Some(session)=message_input_session.as_ref() {session.with_input(|| { if !crate::wayland::input_ready() {return;} match &event { - ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(input_size)), + ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})), ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy), ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy), ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),