Compare commits

...
8 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 d630fc4128 Release v0.1.19
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 11:24:51 +08:00
VallierDevandClaude Opus 5.5 aeaf818c39 Signaling: treat a connection without pings as dead and reconnect (#19)
Only a close frame or read error ended the signaling loop, so a half-open
socket after suspend or a NAT drop left the host believing it was online.
Per Engine.IO 4, report Disconnected when no ping arrives within the
server's pingInterval + pingTimeout so the existing reconnect loop runs.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 11:24:51 +08:00
VallierDevandClaude Opus 5.5 d5e9007dd6 Release v0.1.18
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 11:16:49 +08:00
VallierDevandGemini 4 Argon f876ee1ff3 Wayland: reuse per-slot SHM buffers across screencopy frames
Retain memfd, mmap, wl_shm_pool, and wl_buffer per pipeline slot when
dimensions, stride, and format remain unchanged, avoiding 33 MB 4K
allocations and unmaps on every frame. Rebuild on geometry/format
changes or aborted in-flight copies, and release all SHM resources on
reset/shutdown.

Co-Authored-By: Gemini 4 Argon <[email protected]>
2026-10-16 11:01:26 +08:00
VallierDevandClaude Opus 5.5 6cdc177b9e Wayland capture: pace from buffer availability; log capture exit
Review follow-ups to f0506bc: a stalled encoder read no longer shortens the
next capture interval, and the capture process exit status is logged
because nothing awaits its task.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 11:01:26 +08:00
VallierDevandClaude Opus 5.5 567662a576 X11: pick up desktop resizes between connections (#18)
The root geometry and XShm image were read once at startup, so after a
RandR or xrdp resize every new connection asked x11grab for the old size
and stalled on "transferring picture". Query the root geometry before
each desktop connection and rebuild the capture when it changed; guard
capture with a lock and reject a stale-sized buffer instead of
overflowing it. The HEVC fallback log now includes the actual failure.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 10:56:48 +08:00
VallierDevandClaude Opus 5.5 f0506bcf48 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]>
2026-10-16 10:29:09 +08:00
VallierDevandClaude Opus 5.5 3d08d81b0d Log per-window frame counts in latest-frame stats
sent/skipped are cumulative while max_* are per-window peaks, which was
easy to misread (#16). Add window_s, window_sent and window_skipped.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 09:46:10 +08:00
12 changed files with 292 additions and 107 deletions

No files matched your search

Generated
+1 -1
View File
@@ -2649,7 +2649,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.1.17"
version = "0.1.19"
dependencies = [
"async-trait",
"base64 0.22.1",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.1.17"
version = "0.1.19"
edition = "2021"
authors = ["uu-remote-linux contributors"]
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
+48 -22
View File
@@ -65,9 +65,12 @@ static int initialized;
/* Independent slots let the compositor fill the next frame during delivery. */
struct frame {
struct zwlr_screencopy_frame_v1 *handle;
struct wl_buffer *buffer;
void *pixels;
size_t length;
struct wl_buffer *buffer,*shm_buffer;
struct wl_shm_pool *shm_pool;
void *pixels,*shm_pixels;
size_t shm_length;
int shm_fd,shm_busy;
uint32_t shm_width,shm_height,shm_stride,shm_format;
uint32_t width,height,stride,format,flags;
int done,failed,submitted;
struct zwp_linux_buffer_params_v1 *params;
@@ -76,7 +79,7 @@ struct frame {
void *map_data;
uint32_t dma_format,dma_width,dma_height;
};
static struct frame frames[2];
static struct frame frames[2]={{.shm_fd=-1},{.shm_fd=-1}};
static unsigned pending;
static uint32_t timestamp(void) {
@@ -177,14 +180,28 @@ static void dma_init(void) {
gbm.fd=open(device && *device ? device:"/dev/dri/renderD128",O_RDWR|O_CLOEXEC);
if(gbm.fd<0 || !(gbm.device=gbm.create_device(gbm.fd))) dma_disable("render-device");
}
static void shm_clear(struct frame *frame) {
if(frame->shm_buffer) wl_buffer_destroy(frame->shm_buffer);
if(frame->shm_pool) wl_shm_pool_destroy(frame->shm_pool);
if(frame->shm_pixels) munmap(frame->shm_pixels,frame->shm_length);
if(frame->shm_fd>=0) close(frame->shm_fd);
frame->shm_buffer=NULL; frame->shm_pool=NULL; frame->shm_pixels=NULL;
frame->shm_length=0; frame->shm_fd=-1; frame->shm_busy=0;
frame->shm_width=frame->shm_height=frame->shm_stride=frame->shm_format=0;
}
static void frame_clear(struct frame *frame) {
if(frame->handle) zwlr_screencopy_frame_v1_destroy(frame->handle);
if(frame->params) zwp_linux_buffer_params_v1_destroy(frame->params);
if(frame->buffer) wl_buffer_destroy(frame->buffer);
if(frame->dmabuf_used && frame->pixels) gbm.bo_unmap(frame->bo,frame->map_data);
else if(frame->pixels) munmap(frame->pixels,frame->length);
if(frame->bo) { if(frame->bo_fd>=0)close(frame->bo_fd); gbm.bo_destroy(frame->bo); }
memset(frame,0,sizeof(*frame));
if(frame->shm_busy) shm_clear(frame);
frame->handle=NULL; frame->params=NULL; frame->buffer=NULL;
frame->pixels=NULL; frame->map_data=NULL; frame->bo=NULL;
frame->bo_fd=-1; frame->dmabuf_used=0;
frame->width=frame->height=frame->stride=frame->format=frame->flags=0;
frame->done=frame->failed=frame->submitted=0;
frame->dma_format=frame->dma_width=frame->dma_height=0;
}
static void frame_fail(struct frame *frame) { frame->failed=frame->done=frame->submitted=1; }
static void copy_buffer(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t fmt,uint32_t w,uint32_t h,uint32_t s) {
@@ -194,22 +211,32 @@ static void copy_buffer(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t fmt,ui
(fmt!=WL_SHM_FORMAT_XRGB8888 && fmt!=WL_SHM_FORMAT_ARGB8888 &&
fmt!=WL_SHM_FORMAT_XBGR8888 && fmt!=WL_SHM_FORMAT_ABGR8888)) { frame_fail(frame); return; }
size_t length=(size_t)s*h;
int fd=memfd_create("uuremote-wayland-frame",MFD_CLOEXEC);
if (fd<0 || ftruncate(fd,(off_t)length)!=0) { if(fd>=0)close(fd); frame_fail(frame); return; }
frame->pixels=mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if (frame->pixels==MAP_FAILED) { frame->pixels=NULL; close(fd); frame_fail(frame); return; }
frame->length=length;
struct wl_shm_pool *pool=wl_shm_create_pool(shm,fd,(int32_t)length);
frame->buffer=wl_shm_pool_create_buffer(pool,0,w,h,s,fmt);
wl_shm_pool_destroy(pool); close(fd);
if (frame->shm_busy || !frame->shm_buffer || !frame->shm_pool || !frame->shm_pixels || frame->shm_fd<0 ||
frame->shm_length!=length || frame->shm_width!=w || frame->shm_height!=h ||
frame->shm_stride!=s || frame->shm_format!=fmt) {
shm_clear(frame);
int fd=memfd_create("uuremote-wayland-frame",MFD_CLOEXEC);
if (fd<0 || ftruncate(fd,(off_t)length)!=0) { if(fd>=0)close(fd); frame_fail(frame); return; }
void *pixels=mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if (pixels==MAP_FAILED) { close(fd); frame_fail(frame); return; }
struct wl_shm_pool *pool=wl_shm_create_pool(shm,fd,(int32_t)length);
if (!pool) { munmap(pixels,length); close(fd); frame_fail(frame); return; }
struct wl_buffer *buffer=wl_shm_pool_create_buffer(pool,0,w,h,s,fmt);
if (!buffer) { wl_shm_pool_destroy(pool); munmap(pixels,length); close(fd); frame_fail(frame); return; }
frame->shm_fd=fd; frame->shm_pixels=pixels; frame->shm_length=length;
frame->shm_pool=pool; frame->shm_buffer=buffer;
frame->shm_width=w; frame->shm_height=h; frame->shm_stride=s; frame->shm_format=fmt;
}
frame->pixels=frame->shm_pixels;
/* copy is valid immediately for SHM, including frame versions <3. */
if (zwlr_screencopy_frame_v1_get_version(f)<3) {
zwlr_screencopy_frame_v1_copy(f,frame->buffer); frame->submitted=1;
zwlr_screencopy_frame_v1_copy(f,frame->shm_buffer); frame->shm_busy=frame->submitted=1;
}
}
static void copy_flags(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t value) { ((struct frame*)d)->flags=value; }
static void copy_ready(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t hi,uint32_t lo,uint32_t ns) {
struct frame *frame=d;
frame->shm_busy=0;
if(frame->dmabuf_used) {
/* GBM READ mapping synchronizes readback, possibly via a staging buffer. */
uint32_t stride=0;
@@ -223,7 +250,7 @@ static void copy_ready(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t hi,uint
}
frame->done=1;
}
static void copy_failed(void*d,struct zwlr_screencopy_frame_v1*f) { frame_fail(d); }
static void copy_failed(void*d,struct zwlr_screencopy_frame_v1*f) { ((struct frame*)d)->shm_busy=0; frame_fail(d); }
static void copy_damage(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t x,uint32_t y,uint32_t w,uint32_t h) {}
static void copy_dmabuf(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t fmt,uint32_t w,uint32_t h) {
struct frame *frame=d;
@@ -232,15 +259,14 @@ static void copy_dmabuf(void*d,struct zwlr_screencopy_frame_v1*f,uint32_t fmt,ui
}
}
static void submit_shm(struct frame *frame) {
if(frame->buffer && !frame->failed) {
zwlr_screencopy_frame_v1_copy(frame->handle,frame->buffer); frame->submitted=1;
if(frame->shm_buffer && !frame->shm_busy && !frame->failed) {
zwlr_screencopy_frame_v1_copy(frame->handle,frame->shm_buffer); frame->shm_busy=frame->submitted=1;
} else frame_fail(frame);
}
static void dma_created(void*d,struct zwp_linux_buffer_params_v1*params,struct wl_buffer*buffer) {
struct frame *frame=d;
zwp_linux_buffer_params_v1_destroy(params); frame->params=NULL;
wl_buffer_destroy(frame->buffer);
munmap(frame->pixels,frame->length); frame->pixels=NULL; frame->length=0;
shm_clear(frame); frame->pixels=NULL;
frame->buffer=buffer; frame->dmabuf_used=1;
frame->width=frame->dma_width; frame->height=frame->dma_height;
frame->format=frame->dma_format==0x34325258 ? WL_SHM_FORMAT_XRGB8888:
@@ -254,7 +280,7 @@ static void dma_failed(void*d,struct zwp_linux_buffer_params_v1*params) {
}
static const struct zwp_linux_buffer_params_v1_listener dma_params_listener={dma_created,dma_failed};
static int dma_start(struct frame *frame) {
if(!dmabuf_requested || dmabuf_disabled || !gbm.device || frame->failed || !frame->buffer ||
if(!dmabuf_requested || dmabuf_disabled || !gbm.device || frame->failed || !frame->shm_buffer ||
!(dmabuf_linear_formats&dma_format_bit(frame->dma_format))) return 0;
/* Single-plane linear RGB only; unsupported imports are asynchronous failures,
never create_immed protocol errors. No privilege or device probing changes. */
@@ -285,7 +311,7 @@ static void reset(void) {
if (key_state) xkb_state_unref(key_state);
if (keymap) xkb_keymap_unref(keymap);
if (xkb) xkb_context_unref(xkb);
for(unsigned i=0;i<2;i++) frame_clear(&frames[i]);
for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); shm_clear(&frames[i]); }
if(gbm.device) gbm.device_destroy(gbm.device);
if(gbm.fd>=0) close(gbm.fd);
if(gbm.library) dlclose(gbm.library);
+70 -45
View File
@@ -16,6 +16,7 @@
#include <X11/extensions/Xfixes.h>
#include <stdint.h>
#include <poll.h>
#include <pthread.h>
static Display *g_display = NULL;
static Window g_root = 0;
@@ -27,6 +28,8 @@ static int g_depth = 0;
static XShmSegmentInfo g_shminfo;
static XImage *g_shm_image = NULL;
static int g_use_shm = 0;
/* Guards the capture geometry and SHM image against a resize between connections. */
static pthread_mutex_t g_capture_lock = PTHREAD_MUTEX_INITIALIZER;
static unsigned char g_injected_down[32]; // keycodes currently held by the remote viewer
static int g_injected_count = 0;
static int g_restore_repeat = 0;
@@ -52,6 +55,34 @@ static void track_injected_key(int keycode, int is_press) {
}
}
static void shm_open_image(void) {
g_use_shm = 0;
if (!XShmQueryExtension(g_display)) return;
g_shm_image = XShmCreateImage(g_display, DefaultVisual(g_display, g_screen),
g_depth, ZPixmap, NULL, &g_shminfo, g_width, g_height);
if (!g_shm_image) return;
g_shminfo.shmid = shmget(IPC_PRIVATE, g_shm_image->bytes_per_line * g_shm_image->height, IPC_CREAT | 0777);
if (g_shminfo.shmid == -1) return;
g_shminfo.shmaddr = g_shm_image->data = (char *)shmat(g_shminfo.shmid, 0, 0);
g_shminfo.readOnly = False;
if (g_shminfo.shmaddr != (char *)-1 && XShmAttach(g_display, &g_shminfo)) {
XSync(g_display, False);
g_use_shm = 1;
}
shmctl(g_shminfo.shmid, IPC_RMID, 0); // 标记删除,进程退出时自动回收;失败时也不遗留段
}
static void shm_close_image(void) {
if (g_use_shm) XShmDetach(g_display, &g_shminfo);
if (g_shm_image) {
g_shm_image->data = NULL; /* shm memory is released by shmdt, not XDestroyImage */
XDestroyImage(g_shm_image);
g_shm_image = NULL;
}
if (g_shminfo.shmaddr && g_shminfo.shmaddr != (char *)-1) shmdt(g_shminfo.shmaddr);
memset(&g_shminfo, 0, sizeof(g_shminfo));
g_use_shm = 0;
}
int x11_init(const char *display_name) {
if (g_display) return 0;
@@ -77,59 +108,60 @@ int x11_init(const char *display_name) {
g_height = DisplayHeight(g_display, g_screen);
g_depth = DefaultDepth(g_display, g_screen);
// 尝试初始化 XShm
if (XShmQueryExtension(g_display)) {
g_shm_image = XShmCreateImage(g_display, DefaultVisual(g_display, g_screen),
g_depth, ZPixmap, NULL, &g_shminfo, g_width, g_height);
if (g_shm_image) {
g_shminfo.shmid = shmget(IPC_PRIVATE, g_shm_image->bytes_per_line * g_shm_image->height, IPC_CREAT | 0777);
if (g_shminfo.shmid != -1) {
g_shminfo.shmaddr = g_shm_image->data = (char *)shmat(g_shminfo.shmid, 0, 0);
g_shminfo.readOnly = False;
if (g_shminfo.shmaddr != (char *)-1) {
if (XShmAttach(g_display, &g_shminfo)) {
XSync(g_display, False);
shmctl(g_shminfo.shmid, IPC_RMID, 0); // 标记删除,进程退出时自动回收
g_use_shm = 1;
}
}
}
}
}
shm_open_image();
return 0;
}
int x11_get_dimensions(int *out_w, int *out_h) {
if (!g_display) return -1;
pthread_mutex_lock(&g_capture_lock);
*out_w = g_width;
*out_h = g_height;
pthread_mutex_unlock(&g_capture_lock);
return 0;
}
/* The startup size goes stale when RandR/xrdp resizes the root window. Query the
* server and rebuild the SHM image on change. Returns 1 if changed, 0 if not, <0 on error. */
int x11_refresh_geometry(void) {
if (!g_display) return -1;
Window root; int x, y; unsigned int w, h, border, depth;
if (!XGetGeometry(g_display, g_root, &root, &x, &y, &w, &h, &border, &depth) || !w || !h) return -2;
pthread_mutex_lock(&g_capture_lock);
int changed = (int)w != g_width || (int)h != g_height;
if (changed) {
shm_close_image();
g_width = (int)w; g_height = (int)h;
shm_open_image();
}
pthread_mutex_unlock(&g_capture_lock);
return changed;
}
/**
* 截取一帧画面(RGBA/BGRA 格式)
* @param out_buffer 输出缓冲区,大小必须至少为 width * height * 4
*/
/* *out_w/*out_h carry the caller's buffer geometry in; a mismatch (desktop resized
* since that buffer was sized) returns -4 instead of overflowing it. */
int x11_capture_frame(unsigned char *out_buffer, int *out_w, int *out_h) {
if (!g_display) return -1;
pthread_mutex_lock(&g_capture_lock);
int result = 0;
if (*out_w != g_width || *out_h != g_height) result = -4;
else if (g_use_shm && g_shm_image) {
if (!XShmGetImage(g_display, g_root, g_shm_image, 0, 0, AllPlanes)) result = -2;
else memcpy(out_buffer, g_shm_image->data, (size_t)g_width * g_height * 4);
} else {
// Fallback: XGetImage
XImage *img = XGetImage(g_display, g_root, 0, 0, g_width, g_height, AllPlanes, ZPixmap);
if (!img) result = -3;
else { memcpy(out_buffer, img->data, (size_t)g_width * g_height * 4); XDestroyImage(img); }
}
*out_w = g_width;
*out_h = g_height;
if (g_use_shm && g_shm_image) {
if (!XShmGetImage(g_display, g_root, g_shm_image, 0, 0, AllPlanes)) {
return -2;
}
memcpy(out_buffer, g_shm_image->data, g_width * g_height * 4);
return 0;
}
// Fallback: XGetImage
XImage *img = XGetImage(g_display, g_root, 0, 0, g_width, g_height, AllPlanes, ZPixmap);
if (!img) return -3;
memcpy(out_buffer, img->data, g_width * g_height * 4);
XDestroyImage(img);
return 0;
pthread_mutex_unlock(&g_capture_lock);
return result;
}
// ============ 原生输入注入 ============
@@ -261,16 +293,9 @@ int x11_terminal_shortcut_state(void) {
void x11_close() {
if (!g_display) return;
if (g_use_shm) {
XShmDetach(g_display, &g_shminfo);
if (g_shm_image) {
XDestroyImage(g_shm_image);
g_shm_image = NULL;
}
if (g_shminfo.shmaddr && g_shminfo.shmaddr != (char *)-1) {
shmdt(g_shminfo.shmaddr);
}
}
pthread_mutex_lock(&g_capture_lock);
shm_close_image();
pthread_mutex_unlock(&g_capture_lock);
XCloseDisplay(g_display);
g_display = NULL;
}
+24
View File
@@ -0,0 +1,24 @@
修复分辨率变化后无法出画面;Wayland 采集提速;终端接回修复。/ Resolution change fix, faster Wayland capture, terminal fixes.
### 修复 / Fixed
- **服务运行中桌面分辨率变化后,新连接一直停在「正在传输画面」**(#18,感谢 @liangjiahui01):每次建立桌面连接前重新读取
X11 桌面尺寸,变化时重建截屏;截屏尺寸不符时报明确错误,不再误报「HEVC unavailable」。
已在隔离 Xvfb 上用 `xrandr` 改尺寸验证;xrdp 场景未实测。连接期间改分辨率暂不支持(需重连)。
X11 now re-reads the desktop size before each connection, so a RandR/xrdp resize no longer stalls new connections.
- **终端接回**(#17 后续):修复延迟恢复尺寸可能覆盖新尺寸的竞态,以及接回时同一段输出既在回放里又被实时重发的问题。
Fixed a size-restore race and duplicated output on terminal reattach.
### 改进 / Improved
- **原生 Wayland 采集**(#16,感谢 @meotao 的实机测量):采集进程直接写入 FFmpeg,不再经主进程中转 4K 帧;采集与写管道
双线程交替,管道缓冲扩大;SHM 截屏缓冲复用,不再每帧分配。
⚠️ 只做了编译和单元测试,没有在真机上测到提速效果;请求高帧率时的实际帧率欢迎在 #16 反馈。
Native Wayland: capture pipes straight into FFmpeg, overlaps capture with writes and reuses SHM buffers. Not yet
measured on real hardware.
- 视频统计日志新增本窗口的 `window_s`、`window_sent`、`window_skipped`(原 `sent`/`skipped` 仍为累计值)。
The latest-frame stats line adds per-window counts.
### 下载 / Download
`uu-remote-linux-v0.1.18-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
Wayland 后端需自行用 `--features wayland` 编译。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
信令断线检测:主机休眠恢复或网络悄悄断开后自动重新上线。/ Detect dead signaling connections and reconnect.
### 修复 / Fixed
- **主机显示在线但控制端看不到、只能手动重启服务**(#19,感谢 @Keinns):之前只有收到关闭帧或读错误才判定信令断开;
系统休眠恢复、NAT 超时等造成的半开连接会让主机一直以为自己在线。现在按 Engine.IO 协议,超过服务器下发的
`pingInterval + pingTimeout`(目前约 33 秒)没收到心跳就判定断线,走已有的自动重连。日志:`Signaling heartbeat lost`。
已用模拟的「不发心跳」信令服务器单元测试验证;真实休眠恢复场景未实测。
Signaling now treats a connection without pings for pingInterval + pingTimeout as dead and reconnects.
Unit-tested against a silent mock server; real suspend/resume not yet measured.
### 下载 / Download
`uu-remote-linux-v0.1.19-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -6,6 +6,7 @@ use std::sync::Mutex;
extern "C" {
fn x11_init(display_name: *const libc::c_char) -> libc::c_int;
fn x11_get_dimensions(out_w: *mut libc::c_int, out_h: *mut libc::c_int) -> libc::c_int;
fn x11_refresh_geometry() -> libc::c_int;
fn x11_capture_frame(
out_buffer: *mut libc::c_uchar,
out_w: *mut libc::c_int,
@@ -37,10 +38,22 @@ unsafe fn x11_capture_frame(
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_close() {}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_refresh_geometry() -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_display_name() -> *const libc::c_char { b":0\0".as_ptr().cast() }
/// The X11 root can be resized while the host runs (RandR, xrdp reconnects); the
/// geometry read at startup then makes x11grab reject every new connection.
pub fn x11_resized() -> bool {
match unsafe { x11_refresh_geometry() } {
1 => true,
0 => false,
code => { log::warn!("X11 geometry query failed with code {code}"); false }
}
}
pub struct ScreenCapture {
pub backend: crate::desktop_backend::DesktopBackend,
pub init_error: Option<String>,
@@ -126,6 +139,7 @@ impl ScreenCapture {
let ret = unsafe { x11_capture_frame(buf.as_mut_ptr(), &mut w, &mut h) };
if ret != 0 {
if ret == -4 { return Err(format!("desktop resized to {w}x{h}; reconnect to capture the new size")); }
return Err(format!("x11_capture_frame failed with code {}", ret));
}
+4 -1
View File
@@ -662,7 +662,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
continue;
}
let session_capture=if desktop && (capture.init_error.is_some() || stale_portal) {
let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_resized).await.unwrap_or(false);
if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); }
let session_capture=if desktop && (capture.init_error.is_some() || stale_portal || resized) {
if stale_portal {
input.release_held();input.bind_portal(None);
capture=Arc::new(ScreenCapture::unavailable("Portal authorization expired".into()));
+39
View File
@@ -95,6 +95,30 @@ mod refresh_tests {
// Retain it until after the server sees closure, just like PC callbacks.
drop(retained);
}
#[tokio::test]
async fn silent_half_open_socket_is_reported_disconnected() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
let (hold_tx,hold_rx)=tokio::sync::oneshot::channel::<()>();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let mut socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
// Shortest accepted window (clamped to 5 s); the server then never pings.
socket.send(Message::Text(r#"0{"pingInterval":1000,"pingTimeout":1000}"#.into())).await.unwrap();
let _=socket.next().await;
socket.send(Message::Text("40{}".into())).await.unwrap();
let _=hold_rx.await; // keep the TCP connection open but silent
});
let (sender,mut events)=tokio::sync::mpsc::channel(8);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
let disconnected=tokio::time::timeout(std::time::Duration::from_secs(8),async {
loop { if matches!(events.recv().await,Some(super::SignalingEvent::Disconnected)|None) { return; } }
}).await;
assert!(disconnected.is_ok(),"a socket without pings must be reported dead");
drop(hold_tx);
}
}
impl SignalingClient {
@@ -156,9 +180,19 @@ impl SignalingClient {
let mut accepted_refresh=0;
// Socket.IO binary event awaiting attachments: (event name, header JSON).
let mut pending_binary: Option<(String, Value)> = None;
// Engine.IO 4: a client treats the connection as dead when no ping arrives within
// pingInterval + pingTimeout. A half-open TCP socket (suspend, NAT drop) otherwise
// blocks the read forever and the host silently stays offline.
let mut ping_window=std::time::Duration::from_secs(25+20);
let mut ping_deadline=tokio::time::Instant::now()+ping_window;
loop {
let msg_res=tokio::select! {
_=event_sender.closed()=>break,
_=tokio::time::sleep_until(ping_deadline) => {
log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
break;
},
// Official ControlledSession RefreshSignalTokenLoop: first
// 30s, success every ~300s, failure retry after 30s. Native
// libstreamer 0x885774 / 0x885e58; emit has NO payload args.
@@ -185,12 +219,17 @@ impl SignalingClient {
if txt.starts_with('0') {
if let Ok(open)=serde_json::from_str::<Value>(&txt[1..]) {
log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64));
if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) {
ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000));
ping_deadline=tokio::time::Instant::now()+ping_window;
}
}
// Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await;
} else if txt == "2" {
// Ping -> 回复 Pong
let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1;
ping_deadline=tokio::time::Instant::now()+ping_window;
if tx_out_clone.send("3".into()).await.is_ok() { pong_queued+=1; }
if pings==1 || pings%12==0 {
log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap);
+25 -15
View File
@@ -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);
+30 -19
View File
@@ -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,12 @@ 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}"))?;
// Nothing awaits this task; log so the cause survives the generic encoder EOF.
log::warn!("Wayland capture exited: {status}");
Err(format!("Wayland capture exited: {status}"))
})))
} else { None };
let mut stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
@@ -538,12 +545,14 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
let mut health = tokio::time::interval(Duration::from_millis(200));
health.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut stats = Instant::now();
// sent/skipped are cumulative; window_* and max_* cover the interval since the last stats line.
let (mut window_frames, mut window_skipped) = (0u64, 0u64);
loop {
tokio::select! {
result = &mut reader.0 => {
let result = result.map_err(|e| format!("Encoder reader task: {e}"))?;
if result.is_err() && current.codec == VideoCodec::H265 && track.supports(VideoCodec::H264) {
log::warn!("HEVC unavailable; falling back to negotiated H264");
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
log::warn!("HEVC stream failed ({error}); falling back to negotiated H264");
current.codec = VideoCodec::H264;
applied.send_modify(|value| value.codec = VideoCodec::H264);
current = *settings.borrow_and_update();
@@ -598,7 +607,9 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
frames += 1;
if stats.elapsed() >= Duration::from_secs(30) {
crate::capture::keep_display_awake()?;
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} max_slot_age_ms={} max_send_ms={}", frames, skipped, frame.sequence, max_age_ms,max_send_ms);
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} window_s={} window_sent={} window_skipped={} max_slot_age_ms={} max_send_ms={}",
frames, skipped, frame.sequence, stats.elapsed().as_secs(), frames - window_frames, skipped - window_skipped, max_age_ms, max_send_ms);
(window_frames, window_skipped) = (frames, skipped);
stats = Instant::now();
max_age_ms = 0;
max_send_ms = 0;
+22 -3
View File
@@ -60,19 +60,38 @@ 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 {
// Time from buffer availability: a slow encoder read must not shorten the next interval.
let Ok(mut frame)=free_rx.recv() else { break };
let start=std::time::Instant::now();
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> {