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),