Portal: recover capture after live scaling changes (#26)

* fix(portal): recover capture after live scaling changes

* fix(portal): keep input available during session recovery

* fix(portal): serialize reconnect recovery and throttle lock probes
This commit is contained in:
wanglz111 authored and GitHub committed 2026-10-17 01:08:32 +08:00
1 parent aa4dca75d2
commit f35ec3b2c7
8 files changed
+626 -64

No files matched your search

+1 -1
View File
@@ -75,7 +75,7 @@ Wayland limits: single screen, fixed resolution. The native Hyprland backend now
dynamic resolution yet; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
permission; the permission is remembered once granted.
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery requires reconnecting if physical or logical dimensions change. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping and recovery checks.
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. A previously streaming Portal capture that stays paused without a negotiated format for five seconds enters session recovery; a static desktop does not trigger this timeout. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the detection threshold, not the total recovery time. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
The native Wayland backend needs `wlr-output-power-management` from the compositor to wake a turned-off screen; without it only wake is unavailable — capture and encoding are unaffected.
+1 -1
View File
@@ -66,7 +66,7 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
Wayland 下的限制:只支持单屏、固定分辨率;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持唤醒屏幕和动态分辨率;剪贴板只在控制端的远控窗口处于前台时同步。
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时若物理或逻辑尺寸变化,需要重新连接。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射和恢复校验。
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。已开始推流的 Portal 采集若暂停且无有效协商格式持续五秒,将进入会话恢复;静态桌面不会触发该超时。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是故障判定阈值,并非总恢复时间。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。
+45 -3
View File
@@ -23,6 +23,7 @@
#define SCREEN "org.freedesktop.portal.ScreenCast"
#define REQUEST "org.freedesktop.portal.Request"
#define SESSION "org.freedesktop.portal.Session"
#define PORTAL_RENEGOTIATION_TIMEOUT (5 * G_TIME_SPAN_SECOND)
struct uu_portal {
GDBusConnection *bus;
@@ -46,6 +47,9 @@ struct uu_portal {
pthread_cond_t changed;
atomic_int closed;
int error;
enum pw_stream_state state;
int format_valid, stream_started;
gint64 interrupted_at;
uint32_t node, width, height;
int logical_width, logical_height;
int absolute_stream_pixels;
@@ -155,13 +159,33 @@ static int has_interface(struct uu_portal *p, const char *interface) {
if (!r) return 0;
g_variant_unref(r); return 1;
}
/* Called with the frame mutex held. Count only the continuous invalid pause,
* not a healthy pause before format removal, and never arm during startup. */
static void update_interruption(struct uu_portal *p) {
if (p->stream_started && p->state == PW_STREAM_STATE_PAUSED && !p->format_valid) {
if (!p->interrupted_at) p->interrupted_at = g_get_monotonic_time();
} else p->interrupted_at = 0;
}
static void stream_state(void *data, enum pw_stream_state old, enum pw_stream_state state, const char *message) {
(void)old; (void)message;
struct uu_portal *p = data;
pthread_mutex_lock(&p->lock);
p->state = state;
if (state == PW_STREAM_STATE_STREAMING) p->stream_started = 1;
update_interruption(p);
pthread_mutex_unlock(&p->lock);
if (state == PW_STREAM_STATE_ERROR || state == PW_STREAM_STATE_UNCONNECTED) fail(data, 9);
}
static void stream_format(void *data, uint32_t id, const struct spa_pod *param) {
struct uu_portal *p = data;
if (id != SPA_PARAM_Format || !param) return;
if (id != SPA_PARAM_Format) return;
if (!param) {
pthread_mutex_lock(&p->lock);
p->format_valid = 0;
update_interruption(p);
pthread_mutex_unlock(&p->lock);
return;
}
struct spa_video_info_raw info = {0};
if (spa_format_video_raw_parse(param, &info) < 0 || !info.size.width || !info.size.height ||
info.size.width > 8192 || info.size.height > 8192 ||
@@ -176,13 +200,15 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
if (!p->frame) { p->error = 8; pthread_mutex_unlock(&p->lock); return; }
p->width = info.size.width; p->height = info.size.height; p->format = info.format;
p->frame_length = length;
p->format_valid = 1;
update_interruption(p);
pthread_cond_broadcast(&p->changed);
pthread_mutex_unlock(&p->lock);
}
/* Called with the frame mutex held. Invalid transient chunks are discarded;
* allocation capacity is not evidence that valid pixels have been supplied. */
static void copy_video_buffer(struct uu_portal *p, struct spa_buffer *spa) {
if (!p->error && p->frame && spa->n_datas >= 1) {
if (!p->error && p->format_valid && p->frame && spa->n_datas >= 1) {
struct spa_data *d = &spa->datas[0];
struct spa_meta_header *header = spa_buffer_find_meta_data(spa, SPA_META_Header, sizeof(*header));
if (!d->chunk || (d->chunk->flags & SPA_CHUNK_FLAG_CORRUPTED) ||
@@ -448,10 +474,18 @@ void uu_portal_reset_frame(struct uu_portal *p) {
int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
return uu_portal_capture_since(p, frame, length, NULL);
}
/* A static desktop can stop producing frames indefinitely. Only time out the
* paused, format-less renegotiation observed after a live scaling change (#25).
* Called with the frame mutex held; recovery runs on the Rust capture worker. */
static int stream_stalled(struct uu_portal *p) {
return p->state == PW_STREAM_STATE_PAUSED && !p->format_valid && p->interrupted_at &&
g_get_monotonic_time() - p->interrupted_at >= PORTAL_RENEGOTIATION_TIMEOUT;
}
int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length, uint64_t *revision) {
if (!p || !frame) return 11;
pthread_mutex_lock(&p->lock);
int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : !p->sequence ? 10 : length != p->frame_length ? 11 : 0;
int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : stream_stalled(p) ? 9 :
!p->sequence ? 10 : length != p->frame_length ? 11 : 0;
if (!result) {
if (revision && *revision == p->revision) result = 12;
else memcpy(frame, p->frame, length);
@@ -466,6 +500,14 @@ int uu_portal_alive(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock);
return alive;
}
/* Video renegotiation must not block input releases or clipboard traffic. */
int uu_portal_capture_alive(struct uu_portal *p) {
if (!uu_portal_alive(p)) return 0;
pthread_mutex_lock(&p->lock);
int alive = !stream_stalled(p);
pthread_mutex_unlock(&p->lock);
return alive;
}
void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p);
}
+1
View File
@@ -14,6 +14,7 @@ int uu_portal_clipboard_ready(struct uu_portal *portal);
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
int uu_portal_alive(struct uu_portal *portal);
int uu_portal_capture_alive(struct uu_portal *portal);
void uu_portal_input_dispatch(struct uu_portal *portal);
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
void uu_portal_reset_frame(struct uu_portal *portal);
+5 -2
View File
@@ -656,8 +656,11 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let stale: Vec<String> = sessions.iter().filter(|(_, s)| s.desktop).map(|(k, _)| k.clone()).collect();
for k in stale { if let Some(old) = sessions.remove(&k) { let _ = old.pc.close().await; } }
}
let stale_portal=capture.portal.as_ref().is_some_and(|session|!session.is_alive())
&& crate::session_lock::locked_now() == Some(false);
let stale_portal=if desktop {
if let Some(session)=capture.portal.clone() {
tokio::task::spawn_blocking(move || session.retire_if_closed()).await??
} else { false }
} else { false };
if desktop && desktop_backend::headless() {
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
continue;
+347 -56
View File
@@ -9,7 +9,7 @@ mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))]
mod native {
use std::{ffi::c_void, ptr::NonNull, sync::Mutex};
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
extern "C" {
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
@@ -18,8 +18,8 @@ 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_capture_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;
@@ -34,12 +34,57 @@ 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, logical_size: (u32, u32) }
// Portal preparation and native teardown can wait for consent or D-Bus.
// Only the swap may hold the mutex shared with input and clipboard.
fn replace_handle<T>(current: &Mutex<T>, locked: MutexGuard<'_, T>, prepare: impl FnOnce() -> Result<Option<T>, String>) -> Result<bool, String> {
drop(locked);
let Some(replacement) = prepare()? else { return Ok(false); };
let old = {
let mut handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
std::mem::replace(&mut *handle, replacement)
};
drop(old);
Ok(true)
}
#[derive(Default)]
struct Recovery { retry_at: Option<std::time::Instant>, retired: bool }
impl Recovery {
fn ready(&mut self, now: std::time::Instant, unlocked: impl FnOnce() -> bool) -> bool {
if self.retired { return false; }
let deadline = self.retry_at.get_or_insert(now + std::time::Duration::from_secs(1));
if now < *deadline { return false; }
*deadline = now + std::time::Duration::from_secs(1);
unlocked()
}
}
fn retire_if_closed<T>(current: &Mutex<T>, recovery: &Mutex<Recovery>, alive: impl FnOnce(&T) -> bool, unlocked: impl FnOnce() -> bool) -> Result<bool, String> {
// Wait outside the input mutex. Inspect the published replacement if recovery
// won; otherwise prevent the old encoder from opening after reconnect takes over.
let mut recovery = recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
let alive = {
let handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
alive(&handle)
};
if alive || !unlocked() { return Ok(false); }
recovery.retired = true;
Ok(true)
}
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, pub width: u32, pub height: u32 }
impl Session {
pub fn logical_size(&self) -> (u32, u32) { self.logical_size }
fn take_lock_observation(&self) -> Result<bool, String> {
// A recovery in progress must see the lock even if another capture
// observes unlock and would otherwise reset only the old handle.
let _recovery = match self.recovery.try_lock() {
Ok(recovery) => recovery,
Err(TryLockError::WouldBlock) => return Ok(false),
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
};
Ok(self.was_locked.swap(false, std::sync::atomic::Ordering::AcqRel))
}
fn check_geometry(&self, replacement: &Self) -> Result<(), String> {
if (self.width, self.height) != (replacement.width, replacement.height)
|| self.logical_size != replacement.logical_size {
// Encoder buffers use frame pixels. Logical geometry and EIS regions
// belong to the replacement handle and may change with scaling (#25).
if (self.width, self.height) != (replacement.width, replacement.height) {
Err("Portal dimensions changed; reconnect required".into())
} else {
Ok(())
@@ -48,6 +93,10 @@ mod native {
pub fn is_alive(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
}
pub fn retire_if_closed(&self) -> Result<bool, String> {
retire_if_closed(&self.handle, &self.recovery, |handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 },
|| crate::session_lock::locked_now() == Some(false))
}
pub fn open() -> Result<Self, String> {
let (mut error, mut width, mut height) = (0, 0, 0);
let directory = super::permissions::directory();
@@ -67,19 +116,17 @@ 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, logical_size: (logical_width, logical_height) })
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), width, height })
}
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
self.capture_changed(frame, &mut None).map(|_| ())
}
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")?;
let 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()) };
@@ -92,34 +139,60 @@ mod native {
}
return Ok(blank_changed(frame, version));
}
if self.was_locked.swap(false, std::sync::atomic::Ordering::AcqRel) {
if self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
// First unlocked capture after a real lock: drop frames captured while locked.
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
if self.take_lock_observation()? { unsafe { uu_portal_reset_frame(handle.0.as_ptr()) }; }
return Ok(blank_changed(frame, version));
}
if unsafe { uu_portal_alive(handle.0.as_ptr()) } == 0 {
// GNOME can close the stream before the periodic lock watcher updates.
if crate::session_lock::locked_now() != Some(false) {
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
return Ok(blank_changed(frame, version));
}
// logind's LockedHint can lag compositor stream closure. Give it a
// full watcher interval before attempting another permission session.
let mut retry = self.retry_at.lock().map_err(|_| "Portal recovery lock poisoned")?;
let deadline = retry.get_or_insert_with(|| std::time::Instant::now() + std::time::Duration::from_secs(1));
if std::time::Instant::now() < *deadline { return Ok(blank_changed(frame, version)); }
let replacement = match Self::open() {
Ok(value) => value,
Err(error) => {
log::warn!("Portal capture recovery deferred: {error}");
*retry = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
return Ok(blank_changed(frame, version));
}
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
// Serialize recovery without making another capture worker hold
// the input mutex while waiting for this worker's Portal calls.
let mut recovery = match self.recovery.try_lock() {
Ok(retry) => retry,
Err(TryLockError::WouldBlock) => return Ok(blank_changed(frame, version)),
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
};
*retry = None;
self.check_geometry(&replacement)?;
*handle = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
log::info!("Portal capture session restored after closure");
if replace_handle(&self.handle, handle, || {
{
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 {
recovery.retry_at = None;
return Ok(None);
}
}
// logind's LockedHint can lag compositor stream closure.
if !recovery.ready(std::time::Instant::now(), || {
if crate::session_lock::locked_now() == Some(false) { return true; }
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
false
}) { return Ok(None); }
let replacement = match Self::open() {
Ok(value) => value,
Err(error) => {
log::warn!("Portal capture recovery deferred: {error}");
recovery.retry_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
return Ok(None);
}
};
recovery.retry_at = None;
self.check_geometry(&replacement)?;
// Consent can outlive the unlocked state checked above.
if *self.locked.borrow() != Some(false) || self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
return Ok(None);
}
replacement.handle.into_inner().map(Some).map_err(|_| "Portal session lock poisoned".into())
})? {
*version = None;
log::info!("Portal capture session restored after stream loss");
}
// Recheck lock state on the next capture before showing the new session.
return Ok(blank_changed(frame, version));
} else {
match self.recovery.try_lock() {
Ok(mut recovery) => recovery.retry_at = None,
Err(TryLockError::WouldBlock) => (),
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
}
}
let identity = handle.0.as_ptr() as usize;
let mut revision = version.filter(|v| v.0 == identity).map_or(0, |v| v.1);
@@ -172,20 +245,19 @@ mod native {
#[cfg(test)]
mod tests {
use super::*;
use std::mem::ManuallyDrop;
use std::{mem::ManuallyDrop, sync::Arc};
struct Fixture(ManuallyDrop<Session>);
impl Fixture {
fn new(physical: (u32, u32), logical_size: (u32, u32)) -> Self {
fn new(physical: (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),
recovery: Mutex::new(Recovery::default()),
width: physical.0,
height: physical.1,
logical_size,
}))
}
@@ -193,35 +265,254 @@ mod native {
}
impl Drop for Fixture {
fn drop(&mut self) {
let Session { handle, locked, was_locked, retry_at, .. } =
let Session { handle, locked, was_locked, recovery, .. } =
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));
drop((locked, was_locked, recovery));
}
}
#[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");
}));
fn recovery_requires_only_matching_frame_dimensions() {
let original = Fixture::new((3840, 2160));
let same = Fixture::new((3840, 2160));
let width_changed = Fixture::new((2560, 2160));
let height_changed = Fixture::new((3840, 1440));
assert_eq!(session.session().logical_size(), (1280, 720));
assert!(original.session().check_geometry(same.session()).is_ok());
assert!(original.session().check_geometry(width_changed.session()).is_err());
assert!(original.session().check_geometry(height_changed.session()).is_err());
}
struct TestHandle {
generation: u8,
key_held: bool,
button_held: bool,
retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>,
}
impl Drop for TestHandle {
fn drop(&mut self) {
if let Some((entered, resume)) = self.retirement.take() {
let _ = entered.send(());
let _ = resume.recv_timeout(std::time::Duration::from_secs(10));
}
}
}
fn release_input(current: Arc<Mutex<TestHandle>>) -> (std::thread::JoinHandle<()>, std::sync::mpsc::Receiver<(u8, bool, bool)>) {
let (released, received) = std::sync::mpsc::channel();
let worker = std::thread::spawn(move || {
let mut handle = current.lock().unwrap();
handle.key_held = false;
handle.button_held = false;
released.send((handle.generation, handle.key_held, handle.button_held)).unwrap();
});
(worker, received)
}
#[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));
fn recovery_does_not_block_input_releases_during_open_or_close() {
use std::{sync::mpsc::channel, time::Duration};
let timeout = Duration::from_secs(3);
let (opening, opened) = channel();
let (resume_open, wait_open) = channel();
let (closing, closed) = channel();
let (resume_close, wait_close) = channel();
let current = Arc::new(Mutex::new(TestHandle {
generation: 1, key_held: true, button_held: true, retirement: Some((closing, wait_close)),
}));
let retry = Arc::new(Mutex::new(None::<std::time::Instant>));
let recovery = {
let current = current.clone();
let retry = retry.clone();
std::thread::spawn(move || {
let handle = current.lock().unwrap();
let _owner = retry.try_lock().unwrap();
replace_handle(&current, handle, || {
opening.send(()).unwrap();
wait_open.recv_timeout(Duration::from_secs(10)).unwrap();
Ok(Some(TestHandle {
generation: 2, key_held: true, button_held: true, retirement: None,
}))
})
})
};
let opening_result = opened.recv_timeout(timeout);
let (first_worker, first_release) = release_input(current.clone());
let first_result = first_release.recv_timeout(timeout);
// A concurrent capture must not wait on recovery while retaining input's mutex.
let (contended, contention) = channel();
let contender = {
let current = current.clone();
let retry = retry.clone();
std::thread::spawn(move || {
let _handle = current.lock().unwrap();
contended.send(matches!(retry.try_lock(), Err(TryLockError::WouldBlock))).unwrap();
})
};
let contention_result = contention.recv_timeout(timeout);
let _ = resume_open.send(());
let closing_result = closed.recv_timeout(timeout);
let (second_worker, second_release) = release_input(current.clone());
let second_result = second_release.recv_timeout(timeout);
// Always release blocked work before asserting, including on regression.
let _ = resume_close.send(());
let recovered = recovery.join().unwrap();
first_worker.join().unwrap();
second_worker.join().unwrap();
contender.join().unwrap();
assert!(opening_result.is_ok() && closing_result.is_ok());
assert_eq!(first_result.unwrap(), (1, false, false));
assert_eq!(second_result.unwrap(), (2, false, false));
assert!(contention_result.unwrap());
assert!(recovered.unwrap());
}
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());
#[test]
fn failed_or_deferred_recovery_keeps_the_current_handle_unlocked() {
let current = Mutex::new(1);
for failure in [false, true] {
let handle = current.lock().unwrap();
let result = replace_handle(&current, handle, || {
assert_eq!(*current.try_lock().unwrap(), 1);
if failure { Err("open failed".into()) } else { Ok(None) }
});
if failure { assert_eq!(result.unwrap_err(), "open failed"); }
else { assert!(!result.unwrap()); }
assert_eq!(*current.try_lock().unwrap(), 1);
}
}
#[test]
fn reconnect_waits_for_recovery_and_rechecks_the_published_handle() {
use std::{sync::mpsc::channel, time::Duration};
for succeeds in [false, true] {
let current = Arc::new(Mutex::new(false));
let recovery = Arc::new(Mutex::new(Recovery::default()));
let (opening, opened) = channel();
let (resume, wait) = channel();
let (checked, observed) = channel();
let (starting, started) = channel();
let worker = {
let current = current.clone();
let recovery = recovery.clone();
std::thread::spawn(move || {
let handle = current.lock().unwrap();
let _owner = recovery.lock().unwrap();
replace_handle(&current, handle, || {
opening.send(()).unwrap();
wait.recv_timeout(Duration::from_secs(10)).unwrap();
if succeeds { Ok(Some(true)) } else { Ok(None) }
}).unwrap()
})
};
let ready = opened.recv_timeout(Duration::from_secs(3));
let reconnect = {
let current = current.clone();
let recovery = recovery.clone();
std::thread::spawn(move || {
starting.send(()).unwrap();
retire_if_closed(&current, &recovery, |alive| {
checked.send(*alive).unwrap();
*alive
}, || {
assert!(current.try_lock().is_ok());
true
}).unwrap()
})
};
let started = started.recv_timeout(Duration::from_secs(3));
// A reconnect waiting on recovery must leave input's mutex available.
let input_available = current.try_lock().is_ok();
let premature_check = observed.recv_timeout(Duration::from_millis(100));
let _ = resume.send(());
let recovered = worker.join().unwrap();
let stale = reconnect.join().unwrap();
assert!(ready.is_ok() && started.is_ok() && input_available);
assert!(matches!(premature_check, Err(std::sync::mpsc::RecvTimeoutError::Timeout)));
assert_eq!(observed.recv_timeout(Duration::from_secs(3)).unwrap(), succeeds);
assert_eq!(recovered, succeeds);
assert_eq!(stale, !succeeds);
assert_eq!(recovery.lock().unwrap().retired, !succeeds);
}
}
#[test]
fn reconnect_retirement_prevents_a_late_encoder_recovery() {
let current = Mutex::new(false);
let recovery = Mutex::new(Recovery::default());
// Locked or unknown sessions must not be retired by a reconnect.
assert!(!retire_if_closed(&current, &recovery, |alive| *alive, || false).unwrap());
assert!(!recovery.lock().unwrap().retired);
assert!(retire_if_closed(&current, &recovery, |alive| *alive, || true).unwrap());
let mut recovery = recovery.lock().unwrap();
recovery.retry_at = Some(std::time::Instant::now());
assert!(!recovery.ready(std::time::Instant::now(), || panic!("retired encoder probed logind")));
}
#[test]
fn recovery_backoff_skips_lock_probes_until_the_deadline() {
use std::{cell::Cell, time::{Duration, Instant}};
let now = Instant::now();
let probes = Cell::new(0);
let unlocked = || { probes.set(probes.get() + 1); true };
let mut recovery = Recovery::default();
// Initial one-second grace period, polled at up to 144 fps.
for millis in 0..1000 {
assert!(!recovery.ready(now + Duration::from_millis(millis), unlocked));
}
assert_eq!(probes.get(), 0);
assert!(recovery.ready(now + Duration::from_secs(1), unlocked));
assert_eq!(probes.get(), 1);
// A failed open schedules the existing five-second retry delay.
recovery.retry_at = Some(now + Duration::from_secs(6));
for millis in 1000..6000 {
assert!(!recovery.ready(now + Duration::from_millis(millis), unlocked));
}
assert_eq!(probes.get(), 1);
// A locked/unknown probe denies opening and is itself throttled.
assert!(!recovery.ready(now + Duration::from_secs(6), || { probes.set(2); false }));
assert!(!recovery.ready(now + Duration::from_millis(6999), || panic!("early lock probe")));
assert!(recovery.ready(now + Duration::from_secs(7), unlocked));
assert_eq!(probes.get(), 3);
}
#[test]
fn lock_observation_survives_unlock_while_recovery_is_opening() {
use std::{sync::{atomic::Ordering, mpsc::channel}, time::Duration};
let mut fixture = Fixture::new((2, 2));
let (locked, watch) = tokio::sync::watch::channel(Some(false));
fixture.0.locked = watch;
let session = fixture.session();
std::thread::scope(|threads| {
let (opening, opened) = channel();
let (resume, wait) = channel();
let recovery = threads.spawn(move || {
let _owner = session.recovery.lock().unwrap();
opening.send(()).unwrap();
wait.recv_timeout(Duration::from_secs(10)).unwrap();
});
let ready = opened.recv_timeout(Duration::from_secs(3));
locked.send_replace(Some(true));
session.was_locked.store(true, Ordering::Release);
locked.send_replace(Some(false));
let (reset, result) = channel();
let capture = threads.spawn(move || {
let _handle = session.handle.lock().unwrap();
assert_eq!(*session.locked.borrow(), Some(false));
reset.send(session.take_lock_observation()).unwrap();
});
let consumed = result.recv_timeout(Duration::from_secs(3));
let still_pending = session.was_locked.load(Ordering::Acquire);
let _ = resume.send(());
recovery.join().unwrap();
capture.join().unwrap();
assert!(ready.is_ok());
assert!(!consumed.unwrap().unwrap());
assert!(still_pending);
});
assert!(session.take_lock_observation().unwrap());
assert!(!session.was_locked.load(std::sync::atomic::Ordering::Acquire));
}
}
}
@@ -246,12 +537,12 @@ 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)) }
pub fn clipboard_poll(&self) -> Option<String> { None }
pub fn is_alive(&self) -> bool { false }
pub fn retire_if_closed(&self) -> Result<bool, String> { Ok(false) }
pub fn open() -> Result<Self, String> { Err("Portal backend requires Linux and --features portal".into()) }
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(2)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(2)) }
+39 -1
View File
@@ -380,6 +380,24 @@ static void run_geometry(const struct geometry *geometry) {
assert(h.events[0].type == EIS_EVENT_SCROLL_DISCRETE);
assert(h.events[0].dx == 0 && h.events[0].dy == -120);
uint8_t storage[256];
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *format = spa_format_video_raw_build(&builder, SPA_PARAM_Format,
&SPA_VIDEO_INFO_RAW_INIT(.format=SPA_VIDEO_FORMAT_BGRA,
.size=SPA_RECTANGLE(geometry->width, geometry->height), .framerate=SPA_FRACTION(60,1)));
assert(format);
stream_format(h.portal, SPA_PARAM_Format, format);
stream_state(h.portal, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_STREAMING, NULL);
stream_state(h.portal, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
stream_format(h.portal, SPA_PARAM_Format, NULL);
/* Expire only video recovery; keep EIS and the harness wall clock live. */
pthread_mutex_lock(&h.portal->lock);
h.portal->interrupted_at = g_get_monotonic_time() - PORTAL_RENEGOTIATION_TIMEOUT - 1;
pthread_mutex_unlock(&h.portal->lock);
assert(!uu_portal_capture_alive(h.portal));
uint8_t pixel = 99;
assert(uu_portal_capture_since(h.portal, &pixel, sizeof(pixel), NULL) == 9 && pixel == 99);
clear_events(&h);
assert(uu_portal_key(h.portal, 'a', 30, 0) == 0);
wait_for_input(&h);
@@ -392,6 +410,24 @@ static void run_geometry(const struct geometry *geometry) {
assert(h.events[0].type == EIS_EVENT_BUTTON_BUTTON);
assert(h.events[0].code == 0x110 && !h.events[0].pressed);
stream_format(h.portal, SPA_PARAM_Format, format);
stream_state(h.portal, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_STREAMING, NULL);
assert(uu_portal_capture_alive(h.portal) && !h.portal->interrupted_at);
/* Natural video recovery keeps this EIS device, with neither input held. */
assert(h.portal->ei_devices->data == device && h.connect_calls == 1 && h.starts == 1);
for (int pressed = 1; pressed >= 0; pressed--) {
clear_events(&h);
assert(uu_portal_key(h.portal, 'a', 30, pressed) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_KEYBOARD_KEY);
assert(h.events[0].code == 30 && h.events[0].pressed == pressed);
clear_events(&h);
assert(uu_portal_button(h.portal, 1, pressed) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_BUTTON_BUTTON);
assert(h.events[0].code == 0x110 && h.events[0].pressed == pressed);
}
pause_resume(&h);
clear_events(&h);
@@ -436,6 +472,8 @@ int main(void) {
{3840, 2160, 2560, 1440, 100, 200}, /* 150% */
{3840, 2160, 2194, 1234, 0, 0}, /* 175%, rounded logical size */
{3840, 2160, 1920, 1080, 320, 90}, /* 200% */
{3840, 2160, 2304, 1296, 320, 90}, /* replacement at 166.67% */
{3840, 2160, 1920, 1080, 320, 90}, /* replacement back at 200% */
{5120, 2880, 2560, 1440, 0, 0}, /* 5K */
{7680, 4320, 3840, 2160, 7680, 0}, /* 8K, nonzero origin */
{3440, 1440, 2293, 960, 0, 1080}, /* ultrawide */
@@ -443,6 +481,6 @@ int main(void) {
{2257, 1505, 1806, 1204, 0, 0}, /* odd frame dimensions */
};
for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) run_geometry(&cases[i]);
puts("Portal EIS integration checks passed: 11 geometries");
printf("Portal EIS integration checks passed: %zu geometries\n", sizeof(cases) / sizeof(cases[0]));
return 0;
}
+187
View File
@@ -1,7 +1,190 @@
#define _GNU_SOURCE
/* Protocol-independent C bounds/lifecycle checks; never requests consent. */
#include <gio/gio.h>
#include <assert.h>
static gint64 test_monotonic_time = 1000000;
static gint64 portal_test_monotonic_time(void) { return test_monotonic_time; }
#define g_get_monotonic_time portal_test_monotonic_time
#include "../c_engine/portal_engine.c"
#undef g_get_monotonic_time
static struct uu_portal *test_portal(void) {
struct uu_portal *p = calloc(1, sizeof(*p));
assert(p);
pthread_mutex_init(&p->lock, NULL);
pthread_cond_init(&p->changed, NULL);
return p;
}
static void test_format(struct uu_portal *p, uint32_t width, uint32_t height) {
uint8_t storage[256];
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *format = spa_format_video_raw_build(&builder, SPA_PARAM_Format,
&SPA_VIDEO_INFO_RAW_INIT(.format=SPA_VIDEO_FORMAT_BGRA, .size=SPA_RECTANGLE(width,height),
.framerate=SPA_FRACTION(60,1)));
assert(format);
stream_format(p, SPA_PARAM_Format, format);
}
static void test_frame(struct uu_portal *p) {
uint8_t pixels[16] = {1,2,3,255, 4,5,6,255, 7,8,9,255, 10,11,12,255};
struct spa_chunk chunk = {.offset=0, .size=sizeof(pixels), .stride=8};
struct spa_data data = {.type=SPA_DATA_MemPtr, .data=pixels, .maxsize=sizeof(pixels), .chunk=&chunk};
struct spa_buffer buffer = {.n_datas=1, .datas=&data};
copy_video_buffer(p, &buffer);
}
static void assert_capture_ok(struct uu_portal *p, uint8_t *pixels) {
uint64_t revision = p->revision + 1;
assert(uu_portal_capture_since(p, pixels, p->frame_length, &revision) == 0);
}
static void portal_renegotiation_timeout(void) {
uint8_t pixels[16];
struct uu_portal *p = test_portal();
test_monotonic_time = 1000000;
test_format(p, 2, 2);
assert(p->format_valid);
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
assert(p->sequence == 1 && uu_portal_capture_alive(p));
assert_capture_ok(p, pixels);
gint64 paused_at = test_monotonic_time;
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
assert(!p->interrupted_at);
stream_format(p, SPA_PARAM_Format, NULL);
assert(!p->format_valid && p->interrupted_at == paused_at && uu_portal_capture_alive(p));
uint64_t sequence = p->sequence;
test_frame(p);
assert(p->sequence == sequence); /* Buffers without a negotiated format are ignored. */
test_monotonic_time = paused_at + 3 * G_TIME_SPAN_SECOND;
stream_state(p, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_PAUSED, NULL);
stream_format(p, SPA_PARAM_Format, NULL);
test_monotonic_time = paused_at + 4 * G_TIME_SPAN_SECOND;
stream_format(p, SPA_PARAM_Format, NULL);
assert(p->interrupted_at == paused_at); /* Repeated NULL formats do not restart the deadline. */
assert(uu_portal_capture_alive(p));
assert_capture_ok(p, pixels);
test_monotonic_time = paused_at + 5 * G_TIME_SPAN_SECOND - 1;
assert(uu_portal_capture_alive(p));
assert_capture_ok(p, pixels);
test_monotonic_time = paused_at + 5 * G_TIME_SPAN_SECOND;
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
uint64_t revision = 0;
memset(pixels, 99, sizeof(pixels));
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), &revision) == 9);
assert(!revision && pixels[0] == 99 && pixels[15] == 99);
/* Late renegotiation can recover naturally before the worker replaces it. */
test_format(p, 2, 2);
stream_state(p, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
assert(uu_portal_capture_alive(p) && p->revision == 2);
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), &revision) == 0);
assert(revision == 2 && pixels[0] == 1);
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), &revision) == 12);
uu_portal_close(p);
}
static void portal_renegotiation_recovery(void) {
uint8_t pixels[16];
struct uu_portal *p = test_portal();
test_monotonic_time = 2000000;
test_format(p, 2, 2);
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
gint64 paused_at = test_monotonic_time;
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
stream_format(p, SPA_PARAM_Format, NULL);
test_monotonic_time = paused_at + 2 * G_TIME_SPAN_SECOND;
test_format(p, 2, 2);
assert(p->format_valid && !p->interrupted_at);
stream_state(p, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_STREAMING, NULL);
assert(p->interrupted_at == 0 && uu_portal_capture_alive(p));
test_monotonic_time = paused_at + 6 * G_TIME_SPAN_SECOND;
assert(uu_portal_capture_alive(p));
assert_capture_ok(p, pixels);
uu_portal_close(p);
}
static void portal_renegotiation_event_order_and_healthy_states(void) {
uint8_t pixels[16];
struct uu_portal *p = test_portal();
test_monotonic_time = 3000000;
test_format(p, 2, 2);
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
stream_format(p, SPA_PARAM_Format, NULL); /* Format can disappear before the state callback. */
assert(!p->format_valid && !p->interrupted_at && uu_portal_capture_alive(p));
test_monotonic_time += 20 * G_TIME_SPAN_SECOND;
assert(uu_portal_capture_alive(p));
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
gint64 paused_at = test_monotonic_time;
assert(p->interrupted_at == paused_at);
test_monotonic_time = paused_at + 5 * G_TIME_SPAN_SECOND;
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), NULL) == 9);
uu_portal_close(p);
p = test_portal();
test_monotonic_time = 4000000;
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_PAUSED, NULL);
assert(!p->interrupted_at);
test_monotonic_time += 60 * G_TIME_SPAN_SECOND;
assert(uu_portal_capture_alive(p)); /* A stream that never reached STREAMING has no recovery deadline. */
assert(uu_portal_capture(p, pixels, sizeof(pixels)) == 10);
uu_portal_close(p);
p = test_portal();
test_monotonic_time = 5000000;
test_format(p, 2, 2);
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
uint64_t revision = 0;
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), &revision) == 0);
test_monotonic_time += 60 * G_TIME_SPAN_SECOND;
assert(uu_portal_capture_alive(p)); /* A static screen can stream without producing a new frame. */
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), &revision) == 12);
uu_portal_close(p);
p = test_portal();
test_monotonic_time = 6000000;
test_format(p, 2, 2);
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
test_frame(p);
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
test_monotonic_time += 6 * G_TIME_SPAN_SECOND;
assert(p->format_valid && uu_portal_capture_alive(p)); /* PAUSED alone is not a format failure. */
assert_capture_ok(p, pixels);
assert(!p->interrupted_at);
/* Healthy paused time must not consume a later negotiation's allowance. */
stream_format(p, SPA_PARAM_Format, NULL);
paused_at = test_monotonic_time;
assert(p->interrupted_at == paused_at && uu_portal_capture_alive(p));
test_monotonic_time += 4 * G_TIME_SPAN_SECOND;
assert(uu_portal_capture_alive(p));
test_format(p, 2, 2);
assert(!p->interrupted_at && uu_portal_capture_alive(p));
/* A second format removal while still paused gets a new full deadline. */
test_monotonic_time += 20 * G_TIME_SPAN_SECOND;
stream_format(p, SPA_PARAM_Format, NULL);
paused_at = test_monotonic_time;
assert(p->interrupted_at == paused_at && uu_portal_capture_alive(p));
test_monotonic_time += 5 * G_TIME_SPAN_SECOND - 1;
assert(uu_portal_capture_alive(p));
test_monotonic_time++;
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
uu_portal_close(p);
}
static void portal_changed_physical_format_still_fails(void) {
struct uu_portal *p = test_portal();
uint8_t pixels[24];
test_monotonic_time = 7000000;
test_format(p, 2, 2);
assert(p->format_valid && !p->error);
test_format(p, 3, 2);
assert(p->error == 8 && !uu_portal_capture_alive(p));
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), NULL) == 8);
uu_portal_close(p);
}
static void clipboard_bounds(void) {
int fds[2]; uint8_t bytes[8]={0};
assert(pipe2(fds,O_NONBLOCK)==0);
@@ -65,6 +248,10 @@ static void authorization_still_required(void) {
}
}
int main(void) {
portal_renegotiation_timeout();
portal_renegotiation_recovery();
portal_renegotiation_event_order_and_healthy_states();
portal_changed_physical_format_still_fails();
clipboard_bounds();
capture_with_optional_geometry(0);
capture_with_optional_geometry(1);