Files
uu-remote-linux/src/inproc_encoder.rs
T
Jeff Zhang 73293318b4 feat(portal): VAAPI DMA-BUF zero-copy, in-process Opus audio and lock-screen uinput control (#145)
* feat(audio): capture and encode Opus in process

* feat(portal): encode VAAPI from leased DMA-BUF frames

* fix(input): route Portal controls and committed ASCII through uinput

* docs(portal): shorten setup notes and colocate hardware acceptance guidance

* fix(input): preserve GNOME IME guard for committed uinput text

* build: link pulse/opus after the static C archive (--as-needed)
2026-11-01 22:12:04 +08:00

1119 lines
46 KiB
Rust

//! In-process X11 capture (XDamage + XShm) and NVENC encoding through the NVIDIA driver.
//! With UU_VIDEO_ENCODER=vaapi, H.264 / HEVC go through VAAPI instead: a DRI3 DMA-BUF of the root window is
//! imported as a VA surface and converted/scaled by VPP, so the CPU never touches the pixels (XShm upload
//! when DRI3 is unavailable).
//! Portal sessions can instead upload their existing BGRA frames, sharing the same GPU VPP and encoder.
//! When capture and encoder sizes match, the XShm buffer is registered as CUDA pinned memory and
//! NVENC reads it by DMA, so there is no host-to-device copy (the X server still writes XShm).
use std::collections::VecDeque;
use std::ffi::CString;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::{mpsc, OwnedSemaphorePermit, Semaphore};
use crate::damage_capture::DamageCapture;
#[repr(C)]
struct NvencEngineOpaque {
_private: [u8; 0],
}
#[repr(C)]
struct NvencConfigFFI {
width: u32,
height: u32,
fps: u32,
gop: u32,
cq: u32,
target_bps: i64,
max_bps: i64,
buffer_bits: i64,
is_hevc: libc::c_int,
chroma_444: libc::c_int,
}
#[repr(C)]
struct VaapiEngineOpaque {
_private: [u8; 0],
}
#[repr(C)]
struct VaapiConfigFFI {
width: u32,
height: u32,
cap_width: u32,
cap_height: u32,
fps: u32,
gop: u32,
target_bps: i64,
max_bps: i64,
buffer_bits: i64,
is_hevc: libc::c_int,
device: *const libc::c_char,
}
#[repr(C)]
struct Dri3CaptureOpaque {
_private: [u8; 0],
}
extern "C" {
fn nvenc_create(config: *const NvencConfigFFI) -> *mut NvencEngineOpaque;
fn nvenc_register_host_buffer(
engine: *mut NvencEngineOpaque,
host_ptr: *mut libc::c_void,
size: usize,
) -> libc::c_int;
fn nvenc_encode_frame(
engine: *mut NvencEngineOpaque,
input_argb: *const u8,
pitch: u32,
force_idr: libc::c_int,
out_data: *mut *const u8,
out_len: *mut u32,
) -> libc::c_int;
fn nvenc_destroy(engine: *mut NvencEngineOpaque);
fn vaapi_create(config: *const VaapiConfigFFI) -> *mut VaapiEngineOpaque;
fn vaapi_import_dma_buffer(engine: *mut VaapiEngineOpaque, dma_fd: libc::c_int, stride: u32) -> libc::c_int;
fn vaapi_import_frame(engine: *mut VaapiEngineOpaque, frame: *const crate::portal::DmaFrame) -> libc::c_int;
fn vaapi_upload_host_buffer(engine: *mut VaapiEngineOpaque, host_ptr: *const u8, pitch: u32) -> libc::c_int;
fn vaapi_encode_frame(
engine: *mut VaapiEngineOpaque,
force_idr: libc::c_int,
out_data: *mut *const u8,
out_len: *mut u32,
) -> libc::c_int;
fn vaapi_destroy(engine: *mut VaapiEngineOpaque);
fn dri3_capture_create(display_name: *const libc::c_char, width: u32, height: u32) -> *mut Dri3CaptureOpaque;
fn dri3_capture_blit(cap: *mut Dri3CaptureOpaque) -> libc::c_int;
fn dri3_capture_wait_damage(cap: *mut Dri3CaptureOpaque, timeout_ms: libc::c_int) -> libc::c_int;
fn dri3_capture_get_dma_fd(cap: *mut Dri3CaptureOpaque) -> libc::c_int;
fn dri3_capture_get_stride(cap: *mut Dri3CaptureOpaque) -> u32;
fn dri3_capture_destroy(cap: *mut Dri3CaptureOpaque);
}
struct SafeNvencEngine(*mut NvencEngineOpaque);
unsafe impl Send for SafeNvencEngine {}
impl Drop for SafeNvencEngine {
fn drop(&mut self) {
if !self.0.is_null() {
unsafe { nvenc_destroy(self.0) };
self.0 = std::ptr::null_mut();
}
}
}
struct SafeVaapiEngine(*mut VaapiEngineOpaque);
unsafe impl Send for SafeVaapiEngine {}
impl Drop for SafeVaapiEngine {
fn drop(&mut self) {
if !self.0.is_null() {
unsafe { vaapi_destroy(self.0) };
self.0 = std::ptr::null_mut();
}
}
}
struct SafeDri3Capture(*mut Dri3CaptureOpaque);
unsafe impl Send for SafeDri3Capture {}
impl Drop for SafeDri3Capture {
fn drop(&mut self) {
if !self.0.is_null() {
unsafe { dri3_capture_destroy(self.0) };
self.0 = std::ptr::null_mut();
}
}
}
pub struct Config {
pub portal: Option<Arc<crate::portal::PortalSession>>,
pub display: String,
pub input: (u32, u32),
pub output: Option<(u32, u32)>,
pub fps: u32,
pub gop: u32,
pub cq: u32,
pub target_bps: i64,
pub max_bps: i64,
pub buffer_bits: i64,
pub codec: crate::capture_setting::VideoCodec,
/// ChromaFormat (capture_setting::CHROMA_444 = 4:4:4).
pub chroma: u64,
/// UU_VIDEO_ENCODER=vaapi: the VAAPI engine (H.264 / HEVC Main) instead of NVENC.
pub vaapi: bool,
}
pub fn disabled() -> bool {
std::env::var("UU_VIDEO_PIPELINE").is_ok_and(|v| v == "process")
}
pub fn damage_enabled() -> bool {
std::env::var("UU_CAPTURE").map_or(true, |v| v != "grab")
}
pub fn selected(encoder: crate::video::Encoder) -> bool {
matches!(encoder, crate::video::Encoder::Nvenc | crate::video::Encoder::Vaapi) && damage_enabled() && !disabled() && crate::config::ffmpeg_root().is_none()
}
/// One encoder thread per stream. Aborting the reader only asks the blocking thread to stop at its
/// next wake-up, so a restart waits here until the previous NVENC session and XShm are released.
/// The key is the stream's IDR flag, which survives encoder restarts.
pub async fn stream_slot(stream: &Arc<AtomicBool>) -> tokio::sync::OwnedMutexGuard<()> {
type Slots = Vec<(std::sync::Weak<AtomicBool>, Arc<tokio::sync::Mutex<()>>)>;
static SLOTS: std::sync::Mutex<Slots> = std::sync::Mutex::new(Vec::new());
let slot = {
let mut slots = SLOTS.lock().unwrap_or_else(|e| e.into_inner());
slots.retain(|(key, _)| key.strong_count() > 0);
match slots.iter().find(|(key, _)| std::ptr::eq(key.as_ptr(), Arc::as_ptr(stream))) {
Some((_, slot)) => slot.clone(),
None => {
let slot = Arc::new(tokio::sync::Mutex::new(()));
slots.push((Arc::downgrade(stream), slot.clone()));
slot
}
}
};
slot.lock_owned().await
}
pub struct EncodedUnit {
pub data: Vec<u8>,
pub permit: OwnedSemaphorePermit,
pub completed_at: Instant,
}
fn acquire(
budget: &Arc<Semaphore>,
units: &mpsc::Sender<EncodedUnit>,
) -> Option<OwnedSemaphorePermit> {
tokio::runtime::Handle::current().block_on(async {
tokio::select! {
permit = budget.clone().acquire_owned() => permit.ok(),
_ = units.closed() => None,
}
})
}
fn random_keepalive(seed: &mut u32) -> Duration {
*seed ^= *seed << 13;
*seed ^= *seed >> 17;
*seed ^= *seed << 5;
Duration::from_micros(40_000 + u64::from(*seed % 26_700))
}
pub fn run(
config: Config,
units: mpsc::Sender<EncodedUnit>,
stop: Arc<AtomicBool>,
idr: Arc<AtomicBool>,
budget: Arc<Semaphore>,
) -> Result<(), String> {
if config.vaapi {
run_vaapi(config, units, stop, idr, budget)
} else {
run_nvenc(config, units, stop, idr, budget)
}
}
pub fn black_frame(codec: crate::capture_setting::VideoCodec) -> Result<bytes::Bytes, String> {
let device = CString::new(crate::video::vaapi_device()).map_err(|_| "Invalid VAAPI device")?;
let config = VaapiConfigFFI {
width: 1280, height: 720, cap_width: 1280, cap_height: 720, fps: 1, gop: 1,
target_bps: 1_000_000, max_bps: 2_000_000, buffer_bits: 500_000,
is_hevc: libc::c_int::from(codec == crate::capture_setting::VideoCodec::H265),
device: device.as_ptr(),
};
let engine = SafeVaapiEngine(unsafe { vaapi_create(&config) });
if engine.0.is_null() { return Err("Locked video VAAPI initialization failed".into()); }
let pixels = vec![0; 1280 * 720 * 4];
if unsafe { vaapi_upload_host_buffer(engine.0, pixels.as_ptr(), 1280 * 4) } != 0 {
return Err("Locked video VAAPI upload failed".into());
}
let mut data = std::ptr::null();
let mut length = 0;
if unsafe { vaapi_encode_frame(engine.0, 1, &mut data, &mut length) } != 0 || data.is_null() || length == 0 {
return Err("Locked video VAAPI encode failed".into());
}
Ok(bytes::Bytes::copy_from_slice(unsafe { std::slice::from_raw_parts(data, length as usize) }))
}
fn run_vaapi(
config: Config,
units: mpsc::Sender<EncodedUnit>,
stop: Arc<AtomicBool>,
idr: Arc<AtomicBool>,
budget: Arc<Semaphore>,
) -> Result<(), String> {
let (width, height) = config.output.unwrap_or(config.input);
let (width, height) = (width + width % 2, height + height % 2);
let (cap_width, cap_height) = config.input;
log::info!(
"Initializing Native In-Process VAAPI: {}x{} -> {}x{}, {} fps, GOP {}, HEVC={}",
cap_width,
cap_height,
width,
height,
config.fps,
config.gop,
config.codec == crate::capture_setting::VideoCodec::H265
);
let device = CString::new(crate::video::vaapi_device()).map_err(|_| "UU_VAAPI_DEVICE contains NUL".to_string())?;
let ffi_cfg = VaapiConfigFFI {
width,
height,
cap_width,
cap_height,
fps: config.fps,
gop: config.gop,
target_bps: config.target_bps,
max_bps: config.max_bps,
buffer_bits: config.buffer_bits,
is_hevc: libc::c_int::from(config.codec == crate::capture_setting::VideoCodec::H265),
device: device.as_ptr(),
};
let raw_engine = unsafe { vaapi_create(&ffi_cfg) };
if raw_engine.is_null() {
return Err("Failed to create native VAAPI engine".into());
}
let engine = SafeVaapiEngine(raw_engine);
if let Some(portal) = config.portal.as_ref() {
return run_portal_vaapi(&config, portal, &engine, units, stop, idr, budget);
}
// Capture stays at the full input size; VPP scales (or pads) to the encoder size.
let display = CString::new(config.display.as_str()).map_err(|_| "DISPLAY contains NUL".to_string())?;
let dri3 = Some(SafeDri3Capture(unsafe { dri3_capture_create(display.as_ptr(), cap_width, cap_height) }))
.filter(|c| !c.0.is_null())
.filter(|c| unsafe {
let (fd, stride) = (dri3_capture_get_dma_fd(c.0), dri3_capture_get_stride(c.0));
fd >= 0 && stride > 0 && vaapi_import_dma_buffer(engine.0, fd, stride) == 0
});
let mut capture = None;
if dri3.is_some() {
log::info!("Native VAAPI imports a DRI3 DMA-BUF of the root window (GPU blit, VPP to NV12)");
} else {
log::warn!("DRI3 DMA-BUF unavailable on {}, uploading XShm frames to VAAPI", config.display);
capture = Some(
DamageCapture::open(&config.display)
.map_err(|e| format!("DamageCapture::open failed on {}: {e}", config.display))?,
);
}
let frame_interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
let mut seed = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(1, |d| d.subsec_nanos())
| 1;
let mut keepalive = random_keepalive(&mut seed);
let mut dirty = true;
let mut next_tick = Instant::now();
let mut last_send = Instant::now();
let mut permits = VecDeque::with_capacity(4);
let locked = crate::session_lock::watch_locked();
let mut last_locked = *locked.borrow();
loop {
if stop.load(Ordering::Relaxed) {
return Ok(());
}
let deadline = if dirty {
next_tick
} else {
last_send + keepalive
};
let timeout = deadline.saturating_duration_since(Instant::now());
if vaapi_wait(&dri3, &mut capture, timeout.max(Duration::from_millis(1)))? {
dirty = true;
}
let now = Instant::now();
if dirty && now < next_tick {
continue;
}
if !dirty && now < last_send + keepalive {
continue;
}
let Some(permit) = acquire(&budget, &units) else {
return Ok(());
};
if stop.load(Ordering::Relaxed) {
return Ok(());
}
dirty |= vaapi_wait(&dri3, &mut capture, Duration::ZERO)?;
let state = *locked.borrow();
if state != last_locked {
dirty = true;
last_locked = state;
}
let force_idr = if idr.swap(false, Ordering::AcqRel) {
1
} else {
0
};
// Keepalive frames re-encode the last surface; only damage needs a new copy of the screen.
if dirty {
match (dri3.as_ref(), capture.as_mut()) {
(Some(c), _) => {
if unsafe { dri3_capture_blit(c.0) } != 0 {
return Err("DRI3 blit of the root window failed".into());
}
}
(None, Some(c)) => {
let pitch = c.size().0 * 4;
let res = unsafe { vaapi_upload_host_buffer(engine.0, c.capture()?.as_ptr(), pitch) };
if res != 0 {
return Err(format!("vaapi_upload_host_buffer failed with error {res}"));
}
}
(None, None) => unreachable!(),
}
}
let mut out_data: *const u8 = std::ptr::null();
let mut out_len: u32 = 0;
let res = unsafe { vaapi_encode_frame(engine.0, force_idr, &mut out_data, &mut out_len) };
if res != 0 {
return Err(format!("vaapi_encode_frame failed with error {res}"));
}
if out_len > 0 && !out_data.is_null() {
let data = unsafe { std::slice::from_raw_parts(out_data, out_len as usize) }.to_vec();
permits.push_back(permit);
let send_permit = permits.pop_front().unwrap();
if units
.blocking_send(EncodedUnit {
data,
permit: send_permit,
completed_at: Instant::now(),
})
.is_err()
{
return Ok(());
}
}
let now = Instant::now();
if dirty {
let next = next_tick + frame_interval;
next_tick = if next > now {
next
} else {
now + frame_interval
};
dirty = false;
}
last_send = now;
keepalive = random_keepalive(&mut seed);
}
}
fn vaapi_packet(engine: &SafeVaapiEngine, idr: &AtomicBool) -> Result<Vec<u8>, String> {
let mut data = std::ptr::null();
let mut length = 0;
let force_idr = libc::c_int::from(idr.swap(false, Ordering::AcqRel));
let result = unsafe { vaapi_encode_frame(engine.0, force_idr, &mut data, &mut length) };
if result != 0 { return Err(format!("VAAPI encode failed: {result}")); }
if data.is_null() || length == 0 { return Ok(Vec::new()); }
Ok(unsafe { std::slice::from_raw_parts(data, length as usize) }.to_vec())
}
fn run_portal_vaapi(
config: &Config, portal: &crate::portal::PortalSession, engine: &SafeVaapiEngine,
units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
) -> Result<(), String> {
use crate::portal::DmaCapture;
let interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
let mut next_poll = Instant::now();
let mut last_send = Instant::now();
let mut seed = 1;
let mut keepalive = random_keepalive(&mut seed);
let mut dma_version = None;
let mut cpu_version = None;
let mut cpu_frame = Vec::new();
let mut uploaded = false;
let mut input_dma = false;
let mut blank_frame = false;
let mut dma_disabled = std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0");
if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); }
loop {
if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); }
std::thread::sleep(next_poll.saturating_duration_since(Instant::now()).min(Duration::from_millis(20)));
let now = Instant::now();
if now < next_poll { continue; }
next_poll = (next_poll + interval).max(now);
if portal.size() != config.input { return Err("Portal size changed; restart encoder".into()); }
let Some(permit) = acquire(&budget, &units) else { return Ok(()); };
if stop.load(Ordering::Relaxed) { return Ok(()); }
let due = last_send.elapsed() >= keepalive || idr.load(Ordering::Acquire);
let captured = if dma_disabled { Ok(DmaCapture::Cpu) } else {
portal.with_dmabuf(&mut dma_version, |frame, changed| {
if !changed && input_dma && !due { return Ok(None); }
if changed || !input_dma {
let result = unsafe { vaapi_import_frame(engine.0, frame) };
if result != 0 { return Err(format!("VAAPI DMA-BUF import failed: {result}")); }
}
// vaapi_encode_frame waits for VA completion before the PipeWire lease is released.
let packet = vaapi_packet(engine, &idr)?;
if !input_dma {
log::info!("Portal VAAPI capture pipeline=dma-buf zero_cpu_copy=true source={}x{} fourcc={} modifier={}",
frame.width, frame.height, frame.fourcc, frame.modifier);
}
input_dma = true;
blank_frame = false;
uploaded = true;
Ok(Some(packet))
})
};
let captured = match captured {
Ok(DmaCapture::Unavailable(code)) => {
let reason = match code {
14 => "buffer layout unsupported or DMA-BUF disabled for this session",
16 => "compositor selected shared memory",
17 => "DMA-BUF negotiation or first frame timed out",
18 => "explicit synchronization unsupported",
19 => "nonlinear modifier unsupported",
_ => "DMA-BUF interface unavailable",
};
log::warn!("Portal DMA-BUF unavailable: {reason} (code={code}); falling back to native VAAPI host upload");
dma_disabled = true; portal.disable_dmabuf();
DmaCapture::Cpu
},
Err(error) => {
log::warn!("Portal DMA-BUF unavailable: {error}; falling back to native VAAPI host upload");
dma_disabled = true; portal.disable_dmabuf();
DmaCapture::Cpu
},
Ok(value) => value,
};
let data = match captured {
DmaCapture::Frame(Some(packet)) => packet,
DmaCapture::Frame(None) | DmaCapture::Pending => continue,
state @ (DmaCapture::Cpu | DmaCapture::Blank) => {
cpu_frame.resize(config.input.0 as usize * config.input.1 as usize * 4, 0);
let changed = if matches!(state, DmaCapture::Blank) {
let changed = !blank_frame;
if changed { cpu_frame.fill(0); }
blank_frame = true;
changed
} else {
blank_frame = false;
portal.capture_changed(&mut cpu_frame, &mut cpu_version)?
};
if !changed && !input_dma && uploaded && !due { continue; }
if changed || input_dma || !uploaded {
let result = unsafe { vaapi_upload_host_buffer(engine.0, cpu_frame.as_ptr(), config.input.0 * 4) };
if result != 0 { return Err(format!("Portal VAAPI upload failed: {result}")); }
input_dma = false; uploaded = true;
}
vaapi_packet(engine, &idr)?
},
DmaCapture::Unavailable(_) => unreachable!(),
};
if data.is_empty() { continue; }
if units.blocking_send(EncodedUnit { data, permit, completed_at: Instant::now() }).is_err() { return Ok(()); }
last_send = Instant::now();
keepalive = random_keepalive(&mut seed);
}
}
fn vaapi_wait(dri3: &Option<SafeDri3Capture>, capture: &mut Option<DamageCapture>, timeout: Duration) -> Result<bool, String> {
match (dri3, capture) {
(Some(c), _) => match unsafe { dri3_capture_wait_damage(c.0, timeout.as_millis().min(1000) as i32) } {
r if r < 0 => Err("XDamage wait on the DRI3 connection failed".into()),
r => Ok(r > 0),
},
(None, Some(c)) => c.wait(timeout),
(None, None) => unreachable!(),
}
}
fn run_nvenc(
config: Config,
units: mpsc::Sender<EncodedUnit>,
stop: Arc<AtomicBool>,
idr: Arc<AtomicBool>,
budget: Arc<Semaphore>,
) -> Result<(), String> {
let (width, height) = config.output.unwrap_or(config.input);
let (width, height) = (width + width % 2, height + height % 2);
let is_hevc = if config.codec == crate::capture_setting::VideoCodec::H265 {
1
} else {
0
};
let chroma_444 = libc::c_int::from(config.chroma == crate::capture_setting::CHROMA_444);
log::info!(
"Initializing Native In-Process NVENC: {}x{}, {} fps, GOP {}, CQ {}, HEVC={}, 4:4:4={}",
width,
height,
config.fps,
config.gop,
config.cq,
is_hevc == 1,
chroma_444 == 1
);
let ffi_cfg = NvencConfigFFI {
width,
height,
fps: config.fps,
gop: config.gop,
cq: config.cq,
target_bps: config.target_bps,
max_bps: config.max_bps,
buffer_bits: config.buffer_bits,
is_hevc,
chroma_444,
};
let mut capture = DamageCapture::open(&config.display)
.map_err(|e| format!("DamageCapture::open failed on {}: {e}", config.display))?;
let raw_engine = unsafe { nvenc_create(&ffi_cfg) };
if raw_engine.is_null() {
return Err("Failed to create native NVENC engine".into());
}
let engine = SafeNvencEngine(raw_engine);
let (cap_width, cap_height) = capture.size();
// Check if capture buffer can be Zero-Copy registered directly
let mut zero_copy = false;
if cap_width == width && cap_height == height {
let shm_ptr = capture.shm_raw_ptr() as *mut libc::c_void;
let shm_len = capture.shm_size();
let res = unsafe { nvenc_register_host_buffer(engine.0, shm_ptr, shm_len) };
if res == 0 {
zero_copy = true;
log::info!("Native NVENC reads the registered XShm buffer directly (no host-to-device copy)");
} else {
log::warn!("nvenc_register_host_buffer returned {res}, copying frames with cuMemcpyHtoD");
}
} else {
log::info!(
"Capture size ({}x{}) != encoder size ({}x{}): {} on the CPU, then cuMemcpyHtoD",
cap_width,
cap_height,
width,
height,
if config.output.is_some() { "bilinear scaling" } else { "padding" }
);
}
let bytes_per_line = cap_width as usize * 4;
let frame_interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
let mut seed = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(1, |d| d.subsec_nanos())
| 1;
let mut keepalive = random_keepalive(&mut seed);
let mut dirty = true;
let mut next_tick = Instant::now();
let mut last_send = Instant::now();
let mut permits = VecDeque::with_capacity(4);
let mut frame_buf = Vec::new();
let locked = crate::session_lock::watch_locked();
let mut last_locked = *locked.borrow();
loop {
if stop.load(Ordering::Relaxed) {
return Ok(());
}
let deadline = if dirty {
next_tick
} else {
last_send + keepalive
};
let wait = deadline.saturating_duration_since(Instant::now());
if capture.wait(wait.max(Duration::from_millis(1)))? {
dirty = true;
}
let now = Instant::now();
if dirty && now < next_tick {
continue;
}
if !dirty && now < last_send + keepalive {
continue;
}
let Some(permit) = acquire(&budget, &units) else {
return Ok(());
};
if stop.load(Ordering::Relaxed) {
return Ok(());
}
dirty |= capture.wait(Duration::ZERO)?;
let state = *locked.borrow();
if state != last_locked {
dirty = true;
last_locked = state;
}
let force_idr = if idr.swap(false, Ordering::AcqRel) {
1
} else {
0
};
let mut out_data: *const u8 = std::ptr::null();
let mut out_len: u32 = 0;
let res = if zero_copy {
// In Zero-Copy mode: refresh XShm, then NVENC DMA-reads directly from shm_ptr
if dirty {
capture.refresh()?;
}
unsafe {
nvenc_encode_frame(
engine.0,
std::ptr::null(), // NULL means use zero-copy registered buffer
bytes_per_line as u32,
force_idr,
&mut out_data,
&mut out_len,
)
}
} else {
// Copy path: 其他分辨率 is scaled; an odd native size is padded with black to the even encoder size
let source = capture.capture()?;
let (target_ptr, pitch) = if cap_width == width && cap_height == height {
(source.as_ptr(), bytes_per_line as u32)
} else {
frame_buf.resize(width as usize * height as usize * 4, 0);
if config.output.is_some() {
scale_bilinear_argb32(source, cap_width, cap_height, &mut frame_buf, width, height);
} else {
pad_argb32(source, cap_width, cap_height, &mut frame_buf, width, height);
}
(frame_buf.as_ptr(), width * 4)
};
unsafe {
nvenc_encode_frame(
engine.0,
target_ptr,
pitch,
force_idr,
&mut out_data,
&mut out_len,
)
}
};
if res != 0 {
return Err(format!("nvenc_encode_frame failed with error {res}"));
}
if out_len > 0 && !out_data.is_null() {
let data = unsafe { std::slice::from_raw_parts(out_data, out_len as usize) }.to_vec();
permits.push_back(permit);
let send_permit = permits.pop_front().unwrap();
if units
.blocking_send(EncodedUnit {
data,
permit: send_permit,
completed_at: Instant::now(),
})
.is_err()
{
return Ok(());
}
}
let now = Instant::now();
if dirty {
let next = next_tick + frame_interval;
next_tick = if next > now {
next
} else {
now + frame_interval
};
dirty = false;
}
last_send = now;
keepalive = random_keepalive(&mut seed);
}
}
/// Bilinear ARGB32 scaling (the former swscale path used SWS_BILINEAR), with 8-bit fixed-point
/// weights and pixel centers aligned.
fn scale_bilinear_argb32(src: &[u8], src_w: u32, src_h: u32, dst: &mut [u8], dst_w: u32, dst_h: u32) {
if src_w == 0 || src_h == 0 || dst_w == 0 || dst_h == 0 {
return;
}
// Source position in 1/256 pixel units: (d + 0.5) * src / dst - 0.5, clamped to the image.
let taps = |dst_len: u32, src_len: u32| -> Vec<(usize, usize, u32)> {
(0..dst_len)
.map(|d| {
let pos = ((2 * u64::from(d) + 1) * u64::from(src_len) * 128 / u64::from(dst_len)).saturating_sub(128);
let first = ((pos >> 8) as usize).min(src_len as usize - 1);
let second = (first + 1).min(src_len as usize - 1);
(first, second, (pos & 255) as u32)
})
.collect()
};
let (columns, rows) = (taps(dst_w, src_w), taps(dst_h, src_h));
let src_stride = src_w as usize * 4;
for (dst_row, &(y0, y1, fy)) in dst.chunks_exact_mut(dst_w as usize * 4).zip(&rows) {
let (top, bottom) = (&src[y0 * src_stride..], &src[y1 * src_stride..]);
for (pixel, &(x0, x1, fx)) in dst_row.chunks_exact_mut(4).zip(&columns) {
for c in 0..4 {
let lerp = |row: &[u8]| u32::from(row[x0 * 4 + c]) * (256 - fx) + u32::from(row[x1 * 4 + c]) * fx;
pixel[c] = ((lerp(top) * (256 - fy) + lerp(bottom) * fy + 32768) >> 16) as u8;
}
}
}
}
/// Copies the capture into the top-left corner of the larger encoder frame; the rest stays black.
fn pad_argb32(src: &[u8], src_w: u32, src_h: u32, dst: &mut [u8], dst_w: u32, dst_h: u32) {
let (src_stride, dst_stride) = (src_w as usize * 4, dst_w as usize * 4);
let copy = src_stride.min(dst_stride);
for (y, dst_row) in dst.chunks_exact_mut(dst_stride).enumerate() {
if y < src_h.min(dst_h) as usize {
dst_row[..copy].copy_from_slice(&src[y * src_stride..y * src_stride + copy]);
dst_row[copy..].fill(0);
} else {
dst_row.fill(0);
}
}
}
#[cfg(test)]
mod budget_tests {
use super::*;
#[test]
#[ignore = "requires a VAAPI render node and FFmpeg for independent decode verification"]
fn vaapi_locked_frames_decode_as_black_in_both_codecs() {
use std::io::Write;
use std::process::{Command, Stdio};
for codec in [crate::capture_setting::VideoCodec::H264, crate::capture_setting::VideoCodec::H265] {
let frame = black_frame(codec).unwrap();
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-i", "pipe:0",
"-frames:v", "1", "-vf", "scale=1:1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
decoder.stdin.take().unwrap().write_all(&frame).unwrap();
let decoded = decoder.wait_with_output().unwrap();
assert!(decoded.status.success(), "decode failed for {codec:?}");
assert_eq!(decoded.stdout.len(), 3);
assert!(decoded.stdout.iter().all(|&value| value <= 3), "frame is not black for {codec:?}");
}
}
#[tokio::test]
async fn closing_encoder_output_wakes_a_blocked_capture() {
let budget = Arc::new(Semaphore::new(0));
let (tx, rx) = mpsc::channel(1);
let worker = tokio::task::spawn_blocking(move || acquire(&budget, &tx));
tokio::task::yield_now().await;
drop(rx);
assert!(tokio::time::timeout(Duration::from_secs(1), worker).await.unwrap().unwrap().is_none());
}
#[tokio::test]
async fn stream_slot_waits_for_the_previous_encoder_of_the_same_stream() {
let (stream, other) = (Arc::new(AtomicBool::new(false)), Arc::new(AtomicBool::new(false)));
let held = stream_slot(&stream).await;
// Another stream is independent.
drop(tokio::time::timeout(Duration::from_secs(1), stream_slot(&other)).await.unwrap());
assert!(tokio::time::timeout(Duration::from_millis(50), stream_slot(&stream)).await.is_err());
drop(held);
drop(tokio::time::timeout(Duration::from_secs(1), stream_slot(&stream)).await.unwrap());
}
}
#[cfg(test)]
mod frame_tests {
use super::*;
fn image(w: u32, h: u32, pixel: impl Fn(u32, u32) -> [u8; 4]) -> Vec<u8> {
let pixel = &pixel;
(0..h).flat_map(|y| (0..w).flat_map(move |x| pixel(x, y))).collect()
}
#[test]
fn bilinear_scaling_keeps_flat_areas_and_averages_edges() {
let flat = image(8, 6, |_, _| [10, 20, 30, 255]);
let mut out = vec![0; 4 * 3 * 4];
scale_bilinear_argb32(&flat, 8, 6, &mut out, 4, 3);
assert!(out.chunks(4).all(|p| p == [10, 20, 30, 255]));
// A 2:1 downscale of alternating black/white columns lands between the two, not on one of them.
let stripes = image(4, 2, |x, _| if x % 2 == 0 { [0; 4] } else { [255; 4] });
let mut out = vec![0; 2 * 1 * 4];
scale_bilinear_argb32(&stripes, 4, 2, &mut out, 2, 1);
assert!(out.iter().all(|&v| v == 128), "{out:?}");
// Upscaling interpolates and never reads past the last row/column.
let ramp = image(2, 1, |x, _| [(x * 200) as u8; 4]);
let mut out = vec![0; 4 * 2 * 4];
scale_bilinear_argb32(&ramp, 2, 1, &mut out, 4, 2);
let row: Vec<u8> = out[..16].chunks(4).map(|p| p[0]).collect();
assert_eq!(row, vec![0, 50, 150, 200]);
}
#[test]
fn odd_capture_is_padded_with_black_not_stretched() {
let src = image(3, 3, |x, y| [(x + 3 * y + 1) as u8; 4]);
let mut out = vec![9; 4 * 4 * 4];
pad_argb32(&src, 3, 3, &mut out, 4, 4);
for y in 0..4usize {
for x in 0..4usize {
let expected = if x < 3 && y < 3 { (x + 3 * y + 1) as u8 } else { 0 };
assert_eq!(out[(y * 4 + x) * 4], expected, "({x},{y})");
}
}
}
}
#[cfg(all(test, target_os = "linux", feature = "portal"))]
mod portal_hardware_tests {
// Run on an unlocked desktop with saved Portal consent and VAAPI selected.
// FFmpeg is used only for independent decode verification; desktop contents
// are neither saved nor printed. These tests do not lock the real desktop
// or replace system lock-screen acceptance in an isolated VM.
use super::*;
use crate::capture_setting::VideoCodec;
struct Runner {
stop: Arc<AtomicBool>,
idr: Arc<AtomicBool>,
rx: mpsc::Receiver<EncodedUnit>,
job: Option<tokio::task::JoinHandle<Result<(), String>>>,
}
impl Drop for Runner {
fn drop(&mut self) { self.stop.store(true, Ordering::Release); self.rx.close(); }
}
impl Runner {
fn start(portal: Arc<crate::portal::PortalSession>, codec: VideoCodec) -> Self {
let config = Config {
input: portal.size(), portal: Some(portal), display: "wayland:portal".into(),
output: None, fps: 60, gop: 120, cq: 18, target_bps: 16_000_000,
max_bps: 30_000_000, buffer_bits: 500_000, codec,
chroma: crate::capture_setting::CHROMA_420, vaapi: true,
};
let (tx, rx) = mpsc::channel(4);
let stop = Arc::new(AtomicBool::new(false));
let idr = Arc::new(AtomicBool::new(false));
let worker_stop = stop.clone();
let worker_idr = idr.clone();
let job = tokio::task::spawn_blocking(move || run(config, tx, worker_stop, worker_idr, Arc::new(Semaphore::new(4))));
Self { stop, idr, rx, job: Some(job) }
}
async fn frame(&mut self) -> Vec<u8> {
tokio::time::timeout(Duration::from_secs(10), self.rx.recv()).await.unwrap()
.expect("native capture stopped").data
}
async fn hevc_idr(&mut self) -> Vec<u8> {
tokio::time::timeout(Duration::from_secs(10), async {
loop {
let frame = self.frame().await;
let nals = crate::hevc::payload(usize::MAX, &frame).unwrap();
if nals.iter().any(|nal| (16..=21).contains(&((nal[0] >> 1) & 63))) { return frame; }
}
}).await.expect("requested HEVC IDR did not arrive")
}
async fn finish(mut self) {
self.stop.store(true, Ordering::Release);
self.rx.close();
tokio::time::timeout(Duration::from_secs(2), self.job.take().unwrap()).await
.expect("native encoder did not stop").unwrap().unwrap();
}
}
fn decoded_is_black(data: &[u8], codec: VideoCodec) -> bool {
use std::io::Write;
use std::process::{Command, Stdio};
let format = if codec == VideoCodec::H265 { "hevc" } else { "h264" };
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-f", format,
"-i", "pipe:0", "-frames:v", "1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
// Concurrent writing avoids filling stdin while the decoder is blocked on raw RGB output.
let mut input = decoder.stdin.take().unwrap();
let encoded = data.to_vec();
let writer = std::thread::spawn(move || input.write_all(&encoded));
let decoded = decoder.wait_with_output().unwrap();
writer.join().unwrap().unwrap();
assert!(decoded.status.success() && !decoded.stdout.is_empty(), "native frame decode failed");
decoded.stdout.iter().all(|&value| value <= 8)
}
fn resources() -> (usize, u64) {
let fds = std::fs::read_dir("/proc/self/fd").unwrap().count();
let rss = std::fs::read_to_string("/proc/self/status").unwrap().lines()
.find(|line| line.starts_with("VmRSS:")).unwrap().split_whitespace().nth(1).unwrap().parse().unwrap();
(fds, rss)
}
async fn reopen(portal: Arc<crate::portal::PortalSession>) {
tokio::task::spawn_blocking(move || {
portal.end();
assert!(portal.recover(&AtomicBool::new(false)).unwrap());
}).await.unwrap();
}
#[tokio::test]
#[ignore = "requires an unlocked Portal desktop and saved consent"]
async fn portal_snapshot_after_dma_initialization() {
let _ = env_logger::builder().is_test(true).try_init();
tokio::task::spawn_blocking(|| {
let mut portal = crate::portal::PortalSession::open().unwrap();
let (locked, watch) = tokio::sync::watch::channel(Some(false));
portal.test_lock_watch(watch);
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
let (width, height) = portal.size();
let mut pixels = vec![0; width as usize * height as usize * 4];
for state in [Some(true), None, Some(false)] {
locked.send(state).unwrap();
portal.pause();
portal.capture(&mut pixels).unwrap();
assert!(pixels.chunks_exact(4).any(|p| p[..3].iter().any(|&v| v > 8)),
"healthy snapshot was blanked for lock state {state:?}");
println!("snapshot_lock_state={state:?} valid_frame=true");
}
}).await.unwrap();
}
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_five_minute_endurance_with_full_decode -- --ignored --nocapture
// Run for five minutes, independently decode every output frame, require equal
// encoded/decoded counts and no decode errors, and report CPU, RSS and FDs.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "five-minute real Portal/VAAPI run; FFmpeg is used only as an independent decoder"]
async fn portal_five_minute_endurance_with_full_decode() {
use std::process::Stdio;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
let _ = env_logger::builder().is_test(true).try_init();
let session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
let mut runner = Runner::start(Arc::new(session), VideoCodec::H265);
let mut decoder = tokio::process::Command::new("ffmpeg").args([
"-hide_banner", "-loglevel", "error", "-nostats", "-threads", "2", "-f", "hevc", "-i", "pipe:0",
"-progress", "pipe:1", "-fps_mode", "passthrough", "-f", "null", "/dev/null",
]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true).spawn().unwrap();
let mut input = decoder.stdin.take().unwrap();
let mut errors = decoder.stderr.take().unwrap();
let error_reader = tokio::spawn(async move {
let mut total = 0usize;
let mut buffer = [0; 2048];
loop {
let count = errors.read(&mut buffer).await.unwrap();
if count == 0 { return total; }
total += count;
}
});
let output = decoder.stdout.take().unwrap();
let progress_reader = tokio::spawn(async move {
let mut lines = BufReader::new(output).lines();
let mut frames = 0u64;
while let Some(line) = lines.next_line().await.unwrap() {
if let Some(count) = line.strip_prefix("frame=") { frames = count.trim().parse().unwrap(); }
}
frames
});
let ticks = || {
let stat = std::fs::read_to_string("/proc/self/stat").unwrap();
let fields: Vec<_> = stat.split_once(") ").unwrap().1.split_whitespace().collect();
fields[11].parse::<u64>().unwrap() + fields[12].parse::<u64>().unwrap()
};
let hz = unsafe { libc::sysconf(libc::_SC_CLK_TCK) } as f64;
let started = Instant::now();
let mut last_report = started;
let mut last_ticks = ticks();
let mut frames = 0u64;
while started.elapsed() < Duration::from_secs(300) {
let data = runner.frame().await;
tokio::time::timeout(Duration::from_secs(5), input.write_all(&data)).await
.expect("verification decoder stopped consuming").unwrap();
frames += 1;
if last_report.elapsed() >= Duration::from_secs(30) {
let now_ticks = ticks();
let cpu = (now_ticks - last_ticks) as f64 / hz / last_report.elapsed().as_secs_f64() * 100.0;
let (fds, rss_kb) = resources();
println!("endurance elapsed_s={} encoded_frames={} cpu_percent={cpu:.2} fds={fds} rss_kb={rss_kb}",
started.elapsed().as_secs(), frames);
last_ticks = now_ticks; last_report = Instant::now();
}
}
runner.finish().await;
drop(input);
assert!(tokio::time::timeout(Duration::from_secs(15), decoder.wait()).await.unwrap().unwrap().success());
assert_eq!(error_reader.await.unwrap(), 0, "verification decoder reported errors");
let decoded = progress_reader.await.unwrap();
assert_eq!(decoded, frames, "decoder lost encoded frames");
println!("portal_endurance_passed duration_s={:.2} encoded_frames={} decoded_frames={} decode_errors=0",
started.elapsed().as_secs_f64(), frames, decoded);
}
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_restart_resources_and_injected_lock_recovery -- --ignored --nocapture
// Recreate the Portal session 20 times, check resource growth, then inject
// locked/unknown/unlocked observations to check healthy-frame passthrough.
// Actually close/restore the source to check placeholder black and recovery.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "requires an unlocked Portal desktop, saved consent, VAAPI and FFmpeg decode verification"]
async fn portal_restart_resources_and_injected_lock_recovery() {
let _ = env_logger::builder().is_test(true).try_init();
let mut session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
// Inject only the lock observation; actual session closure/recovery and GPU encoding remain real.
// This does not lock the user's desktop or bypass the isolated-VM acceptance guard.
let (locked, watch) = tokio::sync::watch::channel(Some(false));
session.test_lock_watch(watch);
let portal = Arc::new(session);
let mut snapshots = Vec::new();
for cycle in 0..20 {
let codec = if cycle % 2 == 0 { VideoCodec::H264 } else { VideoCodec::H265 };
let mut runner = Runner::start(portal.clone(), codec);
let frame = runner.frame().await;
assert!(!decoded_is_black(&frame, codec), "restarted stream stayed black");
runner.finish().await;
reopen(portal.clone()).await;
let (fds, rss_kb) = resources();
snapshots.push((fds, rss_kb));
println!("restart_cycle={} fds={} rss_kb={}", cycle + 1, fds, rss_kb);
}
let warm = snapshots[3];
let last = *snapshots.last().unwrap();
assert!(last.0 <= warm.0 + 2, "file descriptors grew across reconnects");
assert!(last.1 <= warm.1 + 32 * 1024, "resident memory grew across reconnects");
let mut runner = Runner::start(portal.clone(), VideoCodec::H265);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265));
for state in [Some(true), None, Some(false)] {
locked.send(state).unwrap();
portal.pause();
runner.idr.store(true, Ordering::Release);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265),
"healthy DMA source was blanked for lock state {state:?}");
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
println!("dma_lock_state={state:?} valid_frame=true");
}
for cycle in 0..3 {
locked.send(Some(true)).unwrap();
portal.end();
runner.idr.store(true, Ordering::Release);
assert!(decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "closed Portal source did not produce placeholder frame");
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Cpu));
locked.send(Some(false)).unwrap();
let session = portal.clone();
tokio::task::spawn_blocking(move || { session.recover(&AtomicBool::new(false)).unwrap(); }).await.unwrap();
runner.idr.store(true, Ordering::Release);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "desktop did not recover after unlock observation");
println!("injected_lock_cycle={} source_closed=true placeholder_black=true same_arc_recovered=true", cycle + 1);
}
runner.finish().await;
println!("portal_restart_resources_passed cycles=20 fd_growth={} rss_growth_kb={} injected_lock_cycles=3",
last.0 as i64 - warm.0 as i64, last.1 as i64 - warm.1 as i64);
}
}