diff --git a/src/terminal.rs b/src/terminal.rs index 40b49f1..4fa0579 100644 --- a/src/terminal.rs +++ b/src/terminal.rs @@ -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) { - 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); diff --git a/src/video.rs b/src/video.rs index 2a72174..46e7e6e 100644 --- a/src/video.rs +++ b/src/video.rs @@ -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")?; diff --git a/src/wayland.rs b/src/wayland.rs index a940831..da7c92e 100644 --- a/src/wayland.rs +++ b/src/wayland.rs @@ -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::>(1); + let (free_tx,free_rx)=std::sync::mpsc::sync_channel::>(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 {