mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Portal: map scaled GNOME input through EIS regions (#24)
* fix(portal): map scaled GNOME input through EIS regions Keep unsupported portals on legacy input and leave capture/uinput independent of EIS. Cache logical geometry without the native handle lock and reject geometry changes during recovery. Add native capability, handshake, geometry and lifecycle regression coverage with sanitizer checks; preserve existing non-portal paths. Refs #23. * fix(portal): keep version 4 capture settings in pixel coordinates Keep native, selectable and current screen rectangles in pixels with DPR 1 so legacy setting requests cannot implicitly downscale a scaled desktop. Leave Portal and EIS coordinate mapping local and unchanged. Add inventory/request/ack/sync roundtrip regression coverage, including repeated settings changes and restoring native output. Refs #23.
This commit is contained in:
1 parent
51b489b1e2
commit
b20fd6ccef
14 files changed
+1134
-41
No files matched your search
+131
-2
@@ -148,7 +148,7 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
|
||||
Some(CHROMA_420) => next.chroma = CHROMA_420,
|
||||
_ => {}
|
||||
}
|
||||
// ChooseResolutionType 3 = follow remote (native); otherwise pixel size, else logical size.
|
||||
// ChooseResolutionType 3 = follow remote (native); v4 uses pixels in both size pairs.
|
||||
if number(&fields, 10) == Some(3) { next.output = None; }
|
||||
else if let Some((w, h)) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6))) {
|
||||
next.output = clamp_output(native, w, h);
|
||||
@@ -180,11 +180,13 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// Message 7 ScreenSources for the single desktop: native size, scaled choices, current size.
|
||||
/// Message 7 ScreenSources in pixels for capture-setting v4: native, choices, current size.
|
||||
pub fn screen_sources(seq: u64, timestamp: u64, native: (u32, u32), output: Option<(u32, u32)>, name: &str) -> Result<Vec<u8>, String> {
|
||||
use crate::initialization::{Screen, WinRect};
|
||||
let (w, h) = (native.0 as i32, native.1 as i32);
|
||||
let scaled: Vec<(i32, i32)> = scaled_sizes(native).into_iter().map(|(w, h)| (w as i32, h as i32)).collect();
|
||||
// DPI_SCALE starts at version 5; the observed v4 request uses fields 5/6 as pixels.
|
||||
// Keep every advertised rectangle in that space; Portal/EIS maps input independently.
|
||||
let resolution = WinRect { left: 0, top: 0, width: w, height: h, pixel_width: w, pixel_height: h };
|
||||
let screens = [Screen { id: 0, fps: crate::video::FPS as i32, resolution, primary: true, dpr: 1.0,
|
||||
display_name: name, video_track_index: 0, screen_type: 0, builtin_screen_type: 0,
|
||||
@@ -300,6 +302,133 @@ mod tests {
|
||||
assert_eq!(scaled_sizes((1920, 1080)), vec![(1600, 900), (1280, 720), (960, 540), (640, 360)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_four_native_inventory_roundtrips_without_downscaling() {
|
||||
assert_eq!(FEATURE_VERSION, 4);
|
||||
let native = (3840, 2160);
|
||||
let inventory = screen_sources(1, 2, native, None, "test").unwrap();
|
||||
let envelope = decode_wire(&inventory).unwrap();
|
||||
let sources = decode_wire(message(&envelope, 7).unwrap()).unwrap();
|
||||
let display = decode_wire(message(&sources, 1).unwrap()).unwrap();
|
||||
let rect = decode_wire(message(&display, 4).unwrap()).unwrap();
|
||||
let mut body = Vec::new();
|
||||
put_varint(5, number(&rect, 3).unwrap(), &mut body);
|
||||
put_varint(6, number(&rect, 4).unwrap(), &mut body);
|
||||
put_varint(2, QUALITY_BLURAY, &mut body);
|
||||
let (tx, rx) = watch::channel(VideoSettings::default());
|
||||
handle_rpc(&decode_wire(&rpc(77, 2, &body)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, None, "native selection must preserve the full frame");
|
||||
let sync = sync_payload(&rx.borrow(), native);
|
||||
let fields = decode_wire(&sync).unwrap();
|
||||
assert_eq!(number(&fields, 5), Some(3840));
|
||||
assert_eq!(number(&fields, 6), Some(2160));
|
||||
}
|
||||
|
||||
fn advertised_display(native: (u32, u32), output: Option<(u32, u32)>) -> Vec<u8> {
|
||||
let inventory = screen_sources(1, 2, native, output, "test").unwrap();
|
||||
let envelope = decode_wire(&inventory).unwrap();
|
||||
let sources = decode_wire(message(&envelope, 7).unwrap()).unwrap();
|
||||
message(&sources, 1).unwrap().to_vec()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_four_resolution_choices_and_settings_roundtrip_in_pixels() {
|
||||
assert_eq!(FEATURE_VERSION, 4);
|
||||
for native in [(1920, 1080), (2560, 1440), (3840, 2160), (5120, 2880),
|
||||
(7680, 4320), (3440, 1440), (2160, 3840), (2257, 1505)] {
|
||||
let display = advertised_display(native, None);
|
||||
let fields = decode_wire(&display).unwrap();
|
||||
assert!(fields.iter().any(|f| f.number == 8 && f.value == WireValue::Fixed64(1.0f64.to_le_bytes())));
|
||||
assert_eq!(message(&fields, 6), message(&fields, 4));
|
||||
let choices: Vec<_> = fields.iter().filter_map(|f| match f.value {
|
||||
WireValue::Bytes(rect) if f.number == 3 => Some(rect), _ => None,
|
||||
}).collect();
|
||||
assert_eq!(choices.len(), 1 + scaled_sizes(native).len());
|
||||
assert_eq!(choices[0], message(&fields, 6).unwrap());
|
||||
for rect in choices {
|
||||
let rect = decode_wire(rect).unwrap();
|
||||
let (w, h) = (number(&rect, 3).unwrap(), number(&rect, 4).unwrap());
|
||||
assert_eq!(number(&rect, 5), Some(w));
|
||||
assert_eq!(number(&rect, 6), Some(h));
|
||||
let selected = (w as u32, h as u32);
|
||||
let expected = (selected != native).then_some(selected);
|
||||
// Exercise both the observed legacy capture request and the resolution-only RPC.
|
||||
for case in [2, 6] {
|
||||
let (tx, rx) = watch::channel(VideoSettings::default());
|
||||
let mut body = Vec::new();
|
||||
let (wf, hf) = if case == 2 { (5, 6) } else { (1, 2) };
|
||||
put_varint(wf, w, &mut body); put_varint(hf, h, &mut body);
|
||||
if case == 2 {
|
||||
put_varint(2, QUALITY_GENERAL, &mut body);
|
||||
put_varint(18, 30, &mut body);
|
||||
}
|
||||
let response = handle_rpc(&decode_wire(&rpc(77, case, &body)).unwrap(), &tx, native).unwrap();
|
||||
let response = decode_wire(&response).unwrap();
|
||||
assert_eq!(message(&response, 1), Some(&[8u8, 77][..]));
|
||||
assert_eq!(message(&response, 2), Some(&[][..]));
|
||||
assert_eq!(rx.borrow().output, expected);
|
||||
if case == 2 {
|
||||
assert_eq!(rx.borrow().quality, QUALITY_GENERAL);
|
||||
assert_eq!(rx.borrow().fps, 30);
|
||||
}
|
||||
let sync = sync_payload(&rx.borrow(), native);
|
||||
let sync = decode_wire(&sync).unwrap();
|
||||
for (wf, hf) in [(5, 6), (9, 10)] {
|
||||
assert_eq!(number(&sync, wf), Some(w));
|
||||
assert_eq!(number(&sync, hf), Some(h));
|
||||
}
|
||||
let updated = advertised_display(native, rx.borrow().output);
|
||||
let updated = decode_wire(&updated).unwrap();
|
||||
assert_eq!(message(&updated, 6), message(&fields, 6));
|
||||
assert_eq!(message(&updated, 3), message(&fields, 3));
|
||||
let current = decode_wire(message(&updated, 4).unwrap()).unwrap();
|
||||
for (wf, hf) in [(3, 4), (5, 6)] {
|
||||
assert_eq!(number(¤t, wf), Some(w));
|
||||
assert_eq!(number(¤t, hf), Some(h));
|
||||
}
|
||||
// Echo synchronized dimensions with a quality/fps change, then restore native.
|
||||
let mut body = Vec::new();
|
||||
put_varint(5, number(&sync, 5).unwrap(), &mut body);
|
||||
put_varint(6, number(&sync, 6).unwrap(), &mut body);
|
||||
put_varint(2, QUALITY_BLURAY, &mut body);
|
||||
put_varint(18, 60, &mut body);
|
||||
handle_rpc(&decode_wire(&rpc(78, 2, &body)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, expected);
|
||||
assert_eq!(rx.borrow().quality, QUALITY_BLURAY);
|
||||
assert_eq!(rx.borrow().fps, 60);
|
||||
let mut native_request = Vec::new();
|
||||
put_varint(5, u64::from(native.0), &mut native_request);
|
||||
put_varint(6, u64::from(native.1), &mut native_request);
|
||||
handle_rpc(&decode_wire(&rpc(79, 2, &native_request)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, None);
|
||||
handle_rpc(&decode_wire(&rpc(80, 2, &body)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, expected);
|
||||
handle_rpc(&decode_wire(&rpc(81, 2, &[80, 3])).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_pixel_size_takes_precedence_and_follow_remote_restores_native() {
|
||||
let native = (3840, 2160);
|
||||
let (tx, rx) = watch::channel(VideoSettings { output: Some((1280, 720)), ..Default::default() });
|
||||
let mut body = Vec::new();
|
||||
for (field, value) in [(5, 1920), (6, 1080), (16, 2560), (17, 1440)] {
|
||||
put_varint(field, value, &mut body);
|
||||
}
|
||||
handle_rpc(&decode_wire(&rpc(1, 2, &body)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, Some((2560, 1440)));
|
||||
put_varint(10, 3, &mut body);
|
||||
handle_rpc(&decode_wire(&rpc(2, 2, &body)).unwrap(), &tx, native).unwrap();
|
||||
assert_eq!(rx.borrow().output, None);
|
||||
let sync = sync_payload(&rx.borrow(), native);
|
||||
let fields = decode_wire(&sync).unwrap();
|
||||
assert_eq!(number(&fields, 5), Some(3840));
|
||||
assert_eq!(number(&fields, 6), Some(2160));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_quality_keeps_constant_quality_encoding() {
|
||||
assert_eq!(VideoSettings::default().max_kbps(), None);
|
||||
|
||||
@@ -62,7 +62,7 @@ pub struct Screen<'a> {
|
||||
pub fps: i32,
|
||||
pub resolution: WinRect,
|
||||
pub primary: bool,
|
||||
/// Measured pixel/logical scale; never zero or guessed from a display name.
|
||||
/// Pixel/logical scale of the advertised coordinate space (1.0 for capture-setting v4).
|
||||
pub dpr: f64,
|
||||
pub display_name: &'a str,
|
||||
pub video_track_index: i32,
|
||||
|
||||
+79
-7
@@ -18,11 +18,13 @@ mod native {
|
||||
fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32;
|
||||
fn uu_portal_close(portal: *mut c_void);
|
||||
fn uu_portal_alive(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_input_dispatch(portal: *mut c_void);
|
||||
fn uu_portal_logical_size(portal: *mut c_void, width: *mut u32, height: *mut u32);
|
||||
fn uu_portal_reset_frame(portal: *mut c_void);
|
||||
fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32;
|
||||
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
|
||||
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
|
||||
fn uu_portal_key(portal: *mut c_void, keysym: u32, pressed: i32) -> i32;
|
||||
fn uu_portal_key(portal: *mut c_void, keysym: u32, keycode: i32, pressed: i32) -> i32;
|
||||
}
|
||||
struct Handle(NonNull<c_void>);
|
||||
// The engine owns callback threads; public calls are serialized by Mutex.
|
||||
@@ -32,8 +34,17 @@ mod native {
|
||||
if *version == Some(super::FrameVersion(0, 0)) { return false; }
|
||||
super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true
|
||||
}
|
||||
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, retry_at: Mutex<Option<std::time::Instant>>, pub width: u32, pub height: u32 }
|
||||
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, retry_at: Mutex<Option<std::time::Instant>>, pub width: u32, pub height: u32, logical_size: (u32, u32) }
|
||||
impl Session {
|
||||
pub fn logical_size(&self) -> (u32, u32) { self.logical_size }
|
||||
fn check_geometry(&self, replacement: &Self) -> Result<(), String> {
|
||||
if (self.width, self.height) != (replacement.width, replacement.height)
|
||||
|| self.logical_size != replacement.logical_size {
|
||||
Err("Portal dimensions changed; reconnect required".into())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub fn is_alive(&self) -> bool {
|
||||
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
|
||||
}
|
||||
@@ -56,10 +67,12 @@ mod native {
|
||||
}
|
||||
let pointer = unsafe { uu_portal_open_persist(token.as_ref().map_or(std::ptr::null(), |v| v.as_ptr()), save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height) };
|
||||
let handle = NonNull::new(pointer).ok_or_else(|| super::error(error))?;
|
||||
let (mut logical_width, mut logical_height) = (0, 0);
|
||||
unsafe { uu_portal_logical_size(handle.as_ptr(), &mut logical_width, &mut logical_height) };
|
||||
// A freshly opened session holds no lock-screen frame: only an observed lock (or a
|
||||
// closed stream) must discard the cached frame. Starting "locked" cleared the first
|
||||
// valid frame, and a static desktop sends no new one, so the viewer stayed black (#2).
|
||||
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), retry_at: Mutex::new(None), width, height })
|
||||
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), retry_at: Mutex::new(None), width, height, logical_size: (logical_width, logical_height) })
|
||||
}
|
||||
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
|
||||
self.capture_changed(frame, &mut None).map(|_| ())
|
||||
@@ -67,6 +80,9 @@ mod native {
|
||||
pub fn capture_changed(&self, frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> Result<bool, String> {
|
||||
if frame.len() != self.width as usize * self.height as usize * 4 { return Err(super::error(11)); }
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
// Drain EIS even on a static desktop so pause/disconnect and sync
|
||||
// events are processed without waiting for remote input.
|
||||
unsafe { uu_portal_input_dispatch(handle.0.as_ptr()) };
|
||||
let state = *self.locked.borrow();
|
||||
if state != Some(false) {
|
||||
// Unknown state (watcher not reported yet): show nothing but keep the cached frame.
|
||||
@@ -101,9 +117,7 @@ mod native {
|
||||
}
|
||||
};
|
||||
*retry = None;
|
||||
if replacement.width != self.width || replacement.height != self.height {
|
||||
return Err("Portal dimensions changed; reconnect required".into());
|
||||
}
|
||||
self.check_geometry(&replacement)?;
|
||||
*handle = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
log::info!("Portal capture session restored after closure");
|
||||
}
|
||||
@@ -150,7 +164,64 @@ mod native {
|
||||
if pressed && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
|
||||
let symbol = u32::try_from(symbol).map_err(|_| "Invalid Portal keysym")?;
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, i32::from(pressed)) })
|
||||
let keycode = crate::uinput::keysym_to_evdev(u64::from(symbol)).map_or(-1, i32::from);
|
||||
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, keycode, i32::from(pressed)) })
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::mem::ManuallyDrop;
|
||||
|
||||
struct Fixture(ManuallyDrop<Session>);
|
||||
impl Fixture {
|
||||
fn new(physical: (u32, u32), logical_size: (u32, u32)) -> Self {
|
||||
let (_, locked) = tokio::sync::watch::channel(None);
|
||||
Self(ManuallyDrop::new(Session {
|
||||
handle: Mutex::new(Handle(NonNull::dangling())),
|
||||
locked,
|
||||
was_locked: std::sync::atomic::AtomicBool::new(false),
|
||||
retry_at: Mutex::new(None),
|
||||
width: physical.0,
|
||||
height: physical.1,
|
||||
logical_size,
|
||||
}))
|
||||
}
|
||||
|
||||
fn session(&self) -> &Session { &self.0 }
|
||||
}
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
let Session { handle, locked, was_locked, retry_at, .. } =
|
||||
unsafe { ManuallyDrop::take(&mut self.0) };
|
||||
let handle = handle.into_inner().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
std::mem::forget(handle);
|
||||
drop((locked, was_locked, retry_at));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn logical_size_does_not_depend_on_handle_mutex() {
|
||||
let session = Fixture::new((1920, 1080), (1280, 720));
|
||||
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||||
let _handle = session.session().handle.lock().unwrap();
|
||||
panic!("poison test handle mutex");
|
||||
}));
|
||||
|
||||
assert_eq!(session.session().logical_size(), (1280, 720));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recovery_rejects_physical_or_logical_geometry_changes() {
|
||||
let original = Fixture::new((1920, 1080), (1280, 720));
|
||||
let same = Fixture::new((1920, 1080), (1280, 720));
|
||||
let physical_changed = Fixture::new((2560, 1440), (1280, 720));
|
||||
let logical_changed = Fixture::new((1920, 1080), (1600, 900));
|
||||
|
||||
assert!(original.session().check_geometry(same.session()).is_ok());
|
||||
assert!(original.session().check_geometry(physical_changed.session()).is_err());
|
||||
assert!(original.session().check_geometry(logical_changed.session()).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -175,6 +246,7 @@ pub use native::Session as PortalSession;
|
||||
pub struct PortalSession { pub width: u32, pub height: u32 }
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
impl PortalSession {
|
||||
pub fn logical_size(&self) -> (u32, u32) { (self.width, self.height) }
|
||||
pub fn clipboard_supported(&self) -> bool { false }
|
||||
pub fn clipboard_ready(&self) -> bool { false }
|
||||
pub fn clipboard_set(&self, _: &str) -> Result<(), String> { Err(error(2)) }
|
||||
|
||||
Reference in new issue
Block a user