mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Wayland: pipe capture straight into the encoder and overlap capture with writes; fix terminal races
The native Wayland session relayed each 33 MB 4K frame through this process and the capture loop wrote synchronously, so a slow encoder read delayed the next screencopy request (~65 fps at a 144 fps request versus 87-92 fps for bare capture, #16). Hand the capture stdout to FFmpeg directly, double-buffer capture against the pipe write on a separate thread, and enlarge the pipe. Terminal: hold the size lock across the ioctl so the delayed redraw restore cannot reapply a stale size, and record scrollback and live output under the sink lock so a reattach never replays a chunk that is also sent live. Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
1 parent
3d08d81b0d
commit
f0506bcf48
3 files changed
+67
-34
No files matched your search
+25
-15
@@ -75,6 +75,20 @@ struct Session {
|
||||
}
|
||||
|
||||
impl Session {
|
||||
/// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each
|
||||
/// chunk either in the replay or live, never both.
|
||||
fn record_output(&self, data: &[u8]) {
|
||||
let mut sink = self.sink.lock().unwrap();
|
||||
{
|
||||
let mut sb = self.scrollback.lock().unwrap();
|
||||
sb.extend(data);
|
||||
let excess = sb.len().saturating_sub(SCROLLBACK);
|
||||
sb.drain(..excess);
|
||||
}
|
||||
if let Some(tx) = sink.as_ref() {
|
||||
if tx.send(encode(STDOUT, self.id, data)).is_err() { *sink = None; }
|
||||
}
|
||||
}
|
||||
fn emit(&self, kind: u8, payload: &[u8]) -> bool {
|
||||
let mut sink = self.sink.lock().unwrap();
|
||||
if let Some(tx) = sink.as_ref() {
|
||||
@@ -83,8 +97,10 @@ impl Session {
|
||||
}
|
||||
false
|
||||
}
|
||||
// The size lock is held across the ioctl so a delayed restore cannot reapply a stale size.
|
||||
fn resize(&self, cols: u16, rows: u16) {
|
||||
*self.size.lock().unwrap() = (cols, rows);
|
||||
let mut size = self.size.lock().unwrap();
|
||||
*size = (cols, rows);
|
||||
self.set_winsize(cols, rows);
|
||||
}
|
||||
fn set_winsize(&self, cols: u16, rows: u16) {
|
||||
@@ -94,14 +110,16 @@ impl Session {
|
||||
/// Full-screen programs repaint only on SIGWINCH, which an unchanged size never raises:
|
||||
/// shrink by one row, then restore the latest requested size after a pause.
|
||||
fn force_redraw(self: &Arc<Self>) {
|
||||
let (cols, rows) = *self.size.lock().unwrap();
|
||||
if rows <= 1 { return; }
|
||||
self.set_winsize(cols, rows - 1);
|
||||
{
|
||||
let size = self.size.lock().unwrap();
|
||||
if size.1 <= 1 { return; }
|
||||
self.set_winsize(size.0, size.1 - 1);
|
||||
}
|
||||
let s = self.clone();
|
||||
std::thread::spawn(move || {
|
||||
std::thread::sleep(std::time::Duration::from_millis(150));
|
||||
let (cols, rows) = *s.size.lock().unwrap();
|
||||
s.set_winsize(cols, rows);
|
||||
let size = s.size.lock().unwrap();
|
||||
s.set_winsize(size.0, size.1);
|
||||
});
|
||||
}
|
||||
fn write(&self, data: &[u8]) {
|
||||
@@ -163,15 +181,7 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
|
||||
loop {
|
||||
match reader.read(&mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => {
|
||||
{
|
||||
let mut sb = worker.scrollback.lock().unwrap();
|
||||
sb.extend(&buf[..n]);
|
||||
let excess = sb.len().saturating_sub(SCROLLBACK);
|
||||
sb.drain(..excess);
|
||||
}
|
||||
worker.emit(STDOUT, &buf[..n]);
|
||||
}
|
||||
Ok(n) => worker.record_output(&buf[..n]),
|
||||
}
|
||||
}
|
||||
let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
|
||||
|
||||
+21
-16
@@ -386,7 +386,24 @@ async fn read_encoder_with(
|
||||
// back-to-back to "catch up" (measured 69 frames in 200ms). vfr on a 1/FPS
|
||||
// timebase drops those same-slot frames instead of encoding a burst.
|
||||
let time_base = format!("1/{fps}");
|
||||
if wayland { command.stdin(std::process::Stdio::piped()); }
|
||||
// Native Wayland: the capture process writes straight into the encoder's stdin;
|
||||
// relaying 33 MB 4K frames through this process cost a full extra copy per frame.
|
||||
let mut native_capture=None;
|
||||
if wayland && kms_capture.is_none() && portal.is_none() {
|
||||
// Linux keeps the running executable inode accessible after a scoped
|
||||
// development/release replacement; current_exe may name a deleted path.
|
||||
#[cfg(target_os="linux")]
|
||||
let executable=std::path::PathBuf::from("/proc/self/exe");
|
||||
#[cfg(not(target_os="linux"))]
|
||||
let executable=std::env::current_exe().map_err(|e|format!("Capture executable: {e}"))?;
|
||||
let mut capture=wayland_capture_command(&executable,settings.fps)
|
||||
.kill_on_drop(true).stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::inherit())
|
||||
.spawn().map_err(|e|format!("Start Wayland capture: {e}"))?;
|
||||
let source:std::process::Stdio=capture.stdout.take().ok_or("Capture stdout missing")?
|
||||
.try_into().map_err(|e|format!("Capture pipe: {e}"))?;
|
||||
command.stdin(source);
|
||||
native_capture=Some(capture);
|
||||
} else if wayland { command.stdin(std::process::Stdio::piped()); }
|
||||
let mut child=command.args(["-fps_mode","vfr","-enc_time_base",&time_base,"-f",if settings.codec == VideoCodec::H265 { "hevc" } else { "h264" },"pipe:1"])
|
||||
.kill_on_drop(true)
|
||||
.stdout(std::process::Stdio::piped())
|
||||
@@ -427,22 +444,10 @@ async fn read_encoder_with(
|
||||
sink.write_all(&frame).await.map_err(|e|format!("Portal encoder pipe: {e}"))?;
|
||||
}
|
||||
})))
|
||||
} else if wayland {
|
||||
// Linux keeps the running executable inode accessible after a scoped
|
||||
// development/release replacement; current_exe may name a deleted path.
|
||||
#[cfg(target_os="linux")]
|
||||
let executable=std::path::PathBuf::from("/proc/self/exe");
|
||||
#[cfg(not(target_os="linux"))]
|
||||
let executable=std::env::current_exe().map_err(|e|format!("Capture executable: {e}"))?;
|
||||
let mut capture=wayland_capture_command(&executable,settings.fps)
|
||||
.kill_on_drop(true).stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::inherit())
|
||||
.spawn().map_err(|e|format!("Start Wayland capture: {e}"))?;
|
||||
let mut source=capture.stdout.take().ok_or("Capture stdout missing")?;
|
||||
let mut sink=child.stdin.take().ok_or("Encoder stdin missing")?;
|
||||
} else if let Some(mut capture)=native_capture {
|
||||
Some(EncoderTask(tokio::spawn(async move {
|
||||
let result=tokio::io::copy(&mut source,&mut sink).await;
|
||||
drop(capture);
|
||||
result.map(|_|()).map_err(|e|format!("Wayland frame pipe: {e}"))
|
||||
let status=capture.wait().await.map_err(|e|format!("Wayland capture: {e}"))?;
|
||||
Err(format!("Wayland capture exited: {status}"))
|
||||
})))
|
||||
} else { None };
|
||||
let mut stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
|
||||
|
||||
+21
-3
@@ -60,19 +60,37 @@ pub fn key(symbol:u64,pressed:bool)->i32 {
|
||||
}
|
||||
|
||||
/// A separate process owns capture; encoder cancellation closes its pipe.
|
||||
/// Capture and the pipe write run on separate threads with two frame buffers, so a
|
||||
/// slow encoder read no longer delays the next screencopy request.
|
||||
pub fn capture_stdout() -> Result<(),String> {
|
||||
use std::io::Write;
|
||||
let (w,h)=init()?;
|
||||
let mut frame=vec![0u8;(w as usize)*(h as usize)*4];
|
||||
let mut stdout=std::io::stdout().lock();
|
||||
let size=(w as usize)*(h as usize)*4;
|
||||
let fps=capture_fps(std::env::var("UU_WAYLAND_FPS").ok().as_deref())?;
|
||||
let interval=std::time::Duration::from_nanos(1_000_000_000/u64::from(fps));
|
||||
// A larger pipe absorbs more of each frame per write; failure keeps the default.
|
||||
#[cfg(target_os="linux")]
|
||||
let _=unsafe { libc::fcntl(1, libc::F_SETPIPE_SZ, 1<<20) };
|
||||
let (full_tx,full_rx)=std::sync::mpsc::sync_channel::<Vec<u8>>(1);
|
||||
let (free_tx,free_rx)=std::sync::mpsc::sync_channel::<Vec<u8>>(2);
|
||||
for _ in 0..2 { free_tx.send(vec![0u8;size]).map_err(|_|"Capture buffers")?; }
|
||||
let writer=std::thread::Builder::new().name("uu-wl-write".into()).spawn(move || -> Result<(),String> {
|
||||
let mut stdout=std::io::stdout().lock();
|
||||
for frame in full_rx {
|
||||
stdout.write_all(&frame).map_err(|e|format!("Capture pipe: {e}"))?;
|
||||
if free_tx.send(frame).is_err() { break; }
|
||||
}
|
||||
Ok(())
|
||||
}).map_err(|e|format!("Capture writer: {e}"))?;
|
||||
loop {
|
||||
let start=std::time::Instant::now();
|
||||
let Ok(mut frame)=free_rx.recv() else { break };
|
||||
capture(&mut frame)?;
|
||||
stdout.write_all(&frame).map_err(|e|format!("Capture pipe: {e}"))?;
|
||||
if full_tx.send(frame).is_err() { break; }
|
||||
if let Some(left)=interval.checked_sub(start.elapsed()) { std::thread::sleep(left); }
|
||||
}
|
||||
drop(full_tx);
|
||||
writer.join().map_err(|_|"Capture writer panicked")?
|
||||
}
|
||||
|
||||
pub(crate) fn capture_fps(value:Option<&str>)->Result<u32,String> {
|
||||
|
||||
Reference in new issue
Block a user