mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6882b76801 | ||
|
|
145bf9d25b | ||
|
|
e603761aa8 | ||
|
|
a28800ba44 | ||
|
|
c080b5f653 | ||
|
|
c5ba87f3ad | ||
|
|
edaa27fe6b | ||
|
|
d630fc4128 | ||
|
|
aeaf818c39 | ||
|
|
d5e9007dd6 | ||
|
|
f876ee1ff3 | ||
|
|
6cdc177b9e | ||
|
|
567662a576 | ||
|
|
f0506bcf48 | ||
|
|
3d08d81b0d |
No files matched your search
Generated
+69
-1
@@ -382,6 +382,22 @@ version = "0.9.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
|
||||
|
||||
[[package]]
|
||||
name = "core-foundation"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
|
||||
dependencies = [
|
||||
"core-foundation-sys",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "core-foundation-sys"
|
||||
version = "0.8.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
@@ -969,6 +985,7 @@ dependencies = [
|
||||
"hyper",
|
||||
"hyper-util",
|
||||
"rustls 0.23.45",
|
||||
"rustls-native-certs",
|
||||
"tokio",
|
||||
"tokio-rustls",
|
||||
"tower-service",
|
||||
@@ -1417,6 +1434,12 @@ version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
|
||||
|
||||
[[package]]
|
||||
name = "openssl-probe"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
|
||||
|
||||
[[package]]
|
||||
name = "p256"
|
||||
version = "0.13.2"
|
||||
@@ -1797,6 +1820,7 @@ dependencies = [
|
||||
"pin-project-lite",
|
||||
"quinn",
|
||||
"rustls 0.23.45",
|
||||
"rustls-native-certs",
|
||||
"rustls-pki-types",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -1946,6 +1970,18 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustls-native-certs"
|
||||
version = "0.8.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
|
||||
dependencies = [
|
||||
"openssl-probe",
|
||||
"rustls-pki-types",
|
||||
"schannel",
|
||||
"security-framework",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustls-pki-types"
|
||||
version = "1.15.1"
|
||||
@@ -1989,6 +2025,15 @@ version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
|
||||
|
||||
[[package]]
|
||||
name = "schannel"
|
||||
version = "0.1.29"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "scopeguard"
|
||||
version = "1.2.0"
|
||||
@@ -2031,6 +2076,29 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "security-framework"
|
||||
version = "3.7.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"core-foundation",
|
||||
"core-foundation-sys",
|
||||
"libc",
|
||||
"security-framework-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "security-framework-sys"
|
||||
version = "2.17.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
|
||||
dependencies = [
|
||||
"core-foundation-sys",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.28"
|
||||
@@ -2649,7 +2717,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.17"
|
||||
version = "0.1.22"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.22.1",
|
||||
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.17"
|
||||
version = "0.1.22"
|
||||
edition = "2021"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
|
||||
@@ -29,7 +29,7 @@ tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
|
||||
futures-util = "0.3"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0"
|
||||
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
|
||||
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] }
|
||||
hmac = "0.12"
|
||||
sha2 = "0.10"
|
||||
hex = "0.4"
|
||||
|
||||
@@ -51,6 +51,7 @@ struct uu_portal {
|
||||
uint8_t *frame;
|
||||
size_t frame_length;
|
||||
uint64_t sequence;
|
||||
uint64_t revision;
|
||||
};
|
||||
#include "portal_clipboard.inc"
|
||||
|
||||
@@ -182,6 +183,7 @@ static void copy_video_buffer(struct uu_portal *p, struct spa_buffer *spa) {
|
||||
memset(p->frame, 0, p->frame_length);
|
||||
for (size_t pixel = 0; pixel < p->frame_length / 4; pixel++) p->frame[pixel * 4 + 3] = 255;
|
||||
p->sequence++;
|
||||
p->revision++;
|
||||
return;
|
||||
}
|
||||
struct spa_meta_region *crop = spa_buffer_find_meta_data(spa, SPA_META_VideoCrop, sizeof(*crop));
|
||||
@@ -203,6 +205,7 @@ static void copy_video_buffer(struct uu_portal *p, struct spa_buffer *spa) {
|
||||
}
|
||||
}
|
||||
p->sequence++;
|
||||
p->revision++;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -418,14 +421,22 @@ void uu_portal_reset_frame(struct uu_portal *p) {
|
||||
if (!p) return;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
p->sequence = 0;
|
||||
p->revision++;
|
||||
if (p->frame) memset(p->frame, 0, p->frame_length);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
}
|
||||
int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
|
||||
return uu_portal_capture_since(p, frame, length, NULL);
|
||||
}
|
||||
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;
|
||||
if (!result) memcpy(frame, p->frame, length);
|
||||
if (!result) {
|
||||
if (revision && *revision == p->revision) result = 12;
|
||||
else memcpy(frame, p->frame, length);
|
||||
if (revision) *revision = p->revision;
|
||||
}
|
||||
pthread_mutex_unlock(&p->lock); return result;
|
||||
}
|
||||
int uu_portal_alive(struct uu_portal *p) {
|
||||
|
||||
@@ -16,6 +16,7 @@ int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t cap
|
||||
int uu_portal_alive(struct uu_portal *portal);
|
||||
void uu_portal_reset_frame(struct uu_portal *portal);
|
||||
int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
|
||||
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
|
||||
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
|
||||
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
|
||||
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int pressed);
|
||||
|
||||
+92
-32
@@ -21,6 +21,7 @@
|
||||
|
||||
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static struct wl_display *display;
|
||||
static struct wl_registry *registry;
|
||||
static struct wl_shm *shm;
|
||||
static struct wl_seat *seat;
|
||||
static struct zwlr_screencopy_manager_v1 *copy_manager;
|
||||
@@ -65,18 +66,22 @@ 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;
|
||||
int done,failed,submitted,released;
|
||||
struct zwp_linux_buffer_params_v1 *params;
|
||||
struct gbm_bo *bo;
|
||||
int bo_fd,dmabuf_used;
|
||||
void *map_data;
|
||||
uint32_t dma_format,dma_width,dma_height;
|
||||
uint32_t bo_format,bo_width,bo_height;
|
||||
};
|
||||
static struct frame frames[2];
|
||||
static struct frame frames[2]={{.shm_fd=-1,.bo_fd=-1},{.shm_fd=-1,.bo_fd=-1}};
|
||||
static unsigned pending;
|
||||
|
||||
static uint32_t timestamp(void) {
|
||||
@@ -177,15 +182,37 @@ 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 dma_clear(struct frame *frame) {
|
||||
if(frame->buffer) wl_buffer_destroy(frame->buffer);
|
||||
if(frame->dmabuf_used && frame->pixels) {
|
||||
gbm.bo_unmap(frame->bo,frame->map_data); frame->pixels=NULL; frame->map_data=NULL;
|
||||
}
|
||||
if(frame->bo) { if(frame->bo_fd>=0)close(frame->bo_fd); gbm.bo_destroy(frame->bo); }
|
||||
frame->buffer=NULL; frame->bo=NULL; frame->bo_fd=-1; frame->dmabuf_used=frame->released=0;
|
||||
frame->bo_format=frame->bo_width=frame->bo_height=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->pixels=NULL; frame->map_data=NULL; 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 buffer_release(void*d,struct wl_buffer*b) { ((struct frame*)d)->released=1; }
|
||||
static const struct wl_buffer_listener buffer_listener={buffer_release};
|
||||
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) {
|
||||
struct frame *frame=d;
|
||||
@@ -194,22 +221,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 +260,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,30 +269,40 @@ 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;
|
||||
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:
|
||||
frame->dma_format==0x34325241 ? WL_SHM_FORMAT_ARGB8888:frame->dma_format;
|
||||
wl_buffer_add_listener(buffer,&buffer_listener,frame);
|
||||
frame->released=0;
|
||||
zwlr_screencopy_frame_v1_copy(frame->handle,buffer); frame->submitted=1;
|
||||
}
|
||||
static void dma_failed(void*d,struct zwp_linux_buffer_params_v1*params) {
|
||||
struct frame *frame=d;
|
||||
zwp_linux_buffer_params_v1_destroy(params); frame->params=NULL;
|
||||
dma_disable("import"); submit_shm(frame);
|
||||
dma_disable("import"); dma_clear(frame); submit_shm(frame);
|
||||
}
|
||||
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;
|
||||
if(frame->buffer && frame->bo && frame->released && frame->bo_width==frame->dma_width &&
|
||||
frame->bo_height==frame->dma_height && frame->bo_format==frame->dma_format) {
|
||||
frame->pixels=NULL; frame->dmabuf_used=1; frame->released=0;
|
||||
frame->width=frame->dma_width; frame->height=frame->dma_height;
|
||||
frame->format=frame->dma_format==0x34325258 ? WL_SHM_FORMAT_XRGB8888:
|
||||
frame->dma_format==0x34325241 ? WL_SHM_FORMAT_ARGB8888:frame->dma_format;
|
||||
zwlr_screencopy_frame_v1_copy(frame->handle,frame->buffer); frame->submitted=1; return 1;
|
||||
}
|
||||
dma_clear(frame);
|
||||
/* Single-plane linear RGB only; unsupported imports are asynchronous failures,
|
||||
never create_immed protocol errors. No privilege or device probing changes. */
|
||||
frame->bo=gbm.bo_create(gbm.device,frame->dma_width,frame->dma_height,frame->dma_format,(1u<<2)|(1u<<4));
|
||||
@@ -264,7 +311,8 @@ static int dma_start(struct frame *frame) {
|
||||
uint32_t stride=gbm.bo_get_stride(frame->bo);
|
||||
if(gbm.bo_get_plane_count(frame->bo)!=1 || gbm.bo_get_modifier(frame->bo)!=0 ||
|
||||
stride<frame->dma_width*4 || stride>131072 || (uint64_t)stride*frame->dma_height>256*1024*1024 ||
|
||||
(frame->bo_fd=gbm.bo_get_fd(frame->bo))<0) {dma_disable("layout-or-export"); return 0;}
|
||||
(frame->bo_fd=gbm.bo_get_fd(frame->bo))<0) {dma_disable("layout-or-export"); dma_clear(frame); return 0;}
|
||||
frame->bo_format=frame->dma_format; frame->bo_width=frame->dma_width; frame->bo_height=frame->dma_height;
|
||||
frame->params=zwp_linux_dmabuf_v1_create_params(dmabuf);
|
||||
zwp_linux_buffer_params_v1_add_listener(frame->params,&dma_params_listener,frame);
|
||||
zwp_linux_buffer_params_v1_add(frame->params,frame->bo_fd,0,gbm.bo_get_offset(frame->bo,0),stride,0,0);
|
||||
@@ -285,14 +333,25 @@ 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]); dma_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);
|
||||
memset(&gbm,0,sizeof(gbm)); gbm.fd=-1;
|
||||
/* Disconnect drops every proxy; failure never leaves an initialized backend. */
|
||||
if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);
|
||||
if(pointer) zwlr_virtual_pointer_v1_destroy(pointer);
|
||||
if(power) zwlr_output_power_v1_destroy(power);
|
||||
if(keyboard_manager) zwp_virtual_keyboard_manager_v1_destroy(keyboard_manager);
|
||||
if(pointer_manager) zwlr_virtual_pointer_manager_v1_destroy(pointer_manager);
|
||||
if(power_manager) zwlr_output_power_manager_v1_destroy(power_manager);
|
||||
if(copy_manager) zwlr_screencopy_manager_v1_destroy(copy_manager);
|
||||
if(dmabuf) zwp_linux_dmabuf_v1_destroy(dmabuf);
|
||||
for(unsigned i=0;i<output_count;i++) if(outputs[i].handle) wl_output_destroy(outputs[i].handle);
|
||||
if(seat) wl_seat_destroy(seat);
|
||||
if(shm) wl_shm_destroy(shm);
|
||||
if(registry) wl_registry_destroy(registry);
|
||||
if (display) wl_display_disconnect(display);
|
||||
display=NULL; shm=NULL; seat=NULL; copy_manager=NULL; pointer_manager=NULL; keyboard_manager=NULL;
|
||||
display=NULL; registry=NULL; shm=NULL; seat=NULL; copy_manager=NULL; pointer_manager=NULL; keyboard_manager=NULL;
|
||||
pointer=NULL; keyboard=NULL; xkb=NULL; keymap=NULL; key_state=NULL;
|
||||
power_manager=NULL; power=NULL; power_failed=0;
|
||||
dmabuf=NULL; dmabuf_requested=dmabuf_disabled=dmabuf_reported=0; dmabuf_linear_formats=0;
|
||||
@@ -305,7 +364,7 @@ int uu_wl_init(int32_t *w,int32_t *h) {
|
||||
int result=-1;
|
||||
const char *dma=getenv("UU_WAYLAND_DMABUF"); dmabuf_requested=dma && !strcmp(dma,"1");
|
||||
display=wl_display_connect(NULL); if (!display) goto end;
|
||||
struct wl_registry *registry=wl_display_get_registry(display);
|
||||
registry=wl_display_get_registry(display);
|
||||
wl_registry_add_listener(registry,®istry_listener,NULL);
|
||||
if(sync_display()!=0 || sync_display()!=0) goto end;
|
||||
dma_init();
|
||||
@@ -366,7 +425,8 @@ retry:;
|
||||
if(frame->failed && frame->dmabuf_used && !retried) {
|
||||
/* Mapping/copy failure retries once on SHM; connection errors do not. */
|
||||
dma_disable("copy"); retried=1;
|
||||
for(unsigned i=0;i<2;i++) frame_clear(&frames[i]);
|
||||
/* dma-buf stays disabled, so its cached buffers are never reused. */
|
||||
for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); }
|
||||
pending=0; goto retry;
|
||||
}
|
||||
if(frame->failed || !frame->pixels || frame->width!=width || frame->height!=height) goto end;
|
||||
@@ -391,7 +451,7 @@ retry:;
|
||||
}
|
||||
frame_clear(frame); pending=1-pending;
|
||||
end:
|
||||
if(result!=0) for(unsigned i=0;i<2;i++) frame_clear(&frames[i]);
|
||||
if(result!=0) for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); }
|
||||
pthread_mutex_unlock(&lock); return result;
|
||||
}
|
||||
int uu_wl_move(int32_t x,int32_t y,int relative) {
|
||||
|
||||
+70
-45
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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.**
|
||||
@@ -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.**
|
||||
@@ -0,0 +1,16 @@
|
||||
登录诊断与系统证书支持。/ Login diagnostics and system certificate support.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **企业代理 / 自定义 CA 环境下登录失败**(#21,感谢 @liuji10000qian-svg):除内置根证书外,现在也信任系统证书库,
|
||||
并遵循 `SSL_CERT_FILE` / `SSL_CERT_DIR`。会做 TLS 拦截的代理(使用自签 CA)此前会导致设备注册请求失败。
|
||||
Trust the system certificate store and honor `SSL_CERT_FILE` / `SSL_CERT_DIR` in addition to the bundled roots.
|
||||
- **网络请求失败时只显示「error sending request」**:错误信息现在包含底层原因链(证书、代理、DNS、超时等),
|
||||
并去掉 URL 中的用户名密码(如代理凭据)和查询参数。
|
||||
Transport errors now include their cause chain, with URL credentials and query strings removed.
|
||||
|
||||
⚠️ 自定义 CA / 代理环境未实测,请在 #21 反馈新版本的错误信息。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.20-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,17 @@
|
||||
视频管线减少重复分配和过量编码。/ Fewer allocations and less wasted encoding in the video pipeline.
|
||||
|
||||
### 改进 / Improved(#20,感谢 @mengdehong)
|
||||
- 采集到发送之间最多 4 帧在途:网络发不出去时采集端自动放慢,不再白白编码无法送出的帧。
|
||||
贡献者实验(发送受阻场景):编码 CPU 耗时降低约 88%。
|
||||
- 原生 Wayland 可选的 dma-buf 路径、Portal / KMS 路径复用采集缓冲;Portal 同一帧不重复复制。
|
||||
- X11 进程内编码(`inproc-av`,需自行编译)缓存静态画面的采集与转色结果:静态画面每帧 CPU 降低约 40%。
|
||||
- 原生 Wayland 关闭时完整释放协议对象。
|
||||
|
||||
⚠️ 以上性能数据来自贡献者在隔离 headless Sway / Xvfb 中的合成画面实验,未在维护者的真机上复测。
|
||||
预编译的 X11 包默认走外部 FFmpeg 管线,受影响的主要是 Wayland / Portal / KMS / `inproc-av` 自编译用户。
|
||||
Performance figures come from the contributor's headless Sway/Xvfb experiments; not re-measured on maintainer hardware.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.21-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,15 @@
|
||||
v0.1.21 视频管线改动的两处修正。/ Two follow-up fixes to the v0.1.21 video pipeline changes.
|
||||
|
||||
### 修复 / Fixed
|
||||
- 原生 Wayland 的 dma-buf 映射失败、回退到 SHM 时,已缓存的 dma-buf 缓冲没有释放(最多两个槽位,到会话结束才回收)。
|
||||
Release cached dma-buf buffers when capture falls back to SHM.
|
||||
- 原生 Wayland 在发送受阻(背压)解除后的第一帧可能是受阻前预取的旧画面;现在等待超过两个帧间隔时会重新采集。
|
||||
After a backpressure stall the first native Wayland frame is captured fresh instead of reusing the stale prefetch.
|
||||
|
||||
两处均由代码审查发现,只做了编译和单元测试,未在真机复现。
|
||||
Both found in review; compile- and unit-tested only.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.22-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
+38
-2
@@ -91,6 +91,36 @@ pub struct UUAuthClient {
|
||||
guest_id: Option<String>,
|
||||
}
|
||||
|
||||
/// Transport failures name only the outer request; the cause (certificate, proxy, DNS,
|
||||
/// timeout) lives in the source chain. URL user-info (proxy credentials) and query
|
||||
/// strings are removed before the chain is shown.
|
||||
pub fn transport_error(error: &(dyn std::error::Error + 'static)) -> String {
|
||||
let mut parts = vec![error.to_string()];
|
||||
let mut source = error.source();
|
||||
while let Some(cause) = source {
|
||||
let text = cause.to_string();
|
||||
if parts.last() != Some(&text) { parts.push(text); }
|
||||
source = cause.source();
|
||||
if parts.len() >= 8 { break; }
|
||||
}
|
||||
redact_urls(&parts.join(": "))
|
||||
}
|
||||
fn redact_urls(text: &str) -> String {
|
||||
let mut out = String::with_capacity(text.len());
|
||||
let mut rest = text;
|
||||
while let Some(i) = rest.find("://") {
|
||||
let (head, tail) = rest.split_at(i + 3);
|
||||
out.push_str(head);
|
||||
let end = tail.find(|c: char| c.is_whitespace() || c == ')' || c == '"' || c == '\'').unwrap_or(tail.len());
|
||||
let url = &tail[..end];
|
||||
let url = url.rsplit_once('@').map_or(url, |(_, host)| host);
|
||||
out.push_str(url.split(['?', '#']).next().unwrap_or(""));
|
||||
rest = &tail[end..];
|
||||
}
|
||||
out.push_str(rest);
|
||||
out
|
||||
}
|
||||
|
||||
impl UUAuthClient {
|
||||
pub fn new(creds: Credentials) -> Self {
|
||||
let http = reqwest::Client::builder()
|
||||
@@ -200,7 +230,7 @@ impl UUAuthClient {
|
||||
let body_str = serde_json::to_string(body).map_err(|e| e.to_string())?;
|
||||
let resp = self.http.post(format!("{}{}", BASE_URL, path))
|
||||
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
|
||||
.send().await.map_err(|e| format!("HTTP post {path} failed: {e}"))?;
|
||||
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?;
|
||||
let status = resp.status().as_u16();
|
||||
let value = resp.json().await.unwrap_or(serde_json::Value::Null);
|
||||
Ok((status, value))
|
||||
@@ -219,7 +249,7 @@ impl UUAuthClient {
|
||||
}
|
||||
async fn assist_send(&self, request: reqwest::Request) -> Result<(u16, serde_json::Value), String> {
|
||||
let response = self.http.execute(request)
|
||||
.await.map_err(|_| "assist request transport failed")?;
|
||||
.await.map_err(|e| format!("assist request transport failed: {}", transport_error(&e)))?;
|
||||
let status = response.status().as_u16();
|
||||
let bytes = response.bytes().await.map_err(|_| "assist response read failed")?;
|
||||
if bytes.len() > 65536 { return Err("assist response too large".into()); }
|
||||
@@ -310,4 +340,10 @@ mod guest_tests {
|
||||
let mut without_guest = params; without_guest.remove("x-param-guest-id");
|
||||
assert_ne!(headers["x-param-sign"], client.sign_request("POST", "/api/v1/guest/room/create", &without_guest, ""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transport_error_redacts_proxy_credentials_and_queries() {
|
||||
let text = super::redact_urls("proxy http://user:[email protected]:3128 failed for (https://api.example/p?token=abc)");
|
||||
assert_eq!(text, "proxy http://proxy.example:3128 failed for (https://api.example/p)");
|
||||
}
|
||||
}
|
||||
+19
-5
@@ -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>,
|
||||
@@ -59,18 +72,18 @@ impl ScreenCapture {
|
||||
let kms=crate::kms::Capture::open()?;
|
||||
let (width,height)=(kms.width,kms.height);
|
||||
return Ok(Self { backend,init_error:None,portal:None,display:"kms:linear".into(),width,height,
|
||||
buffer:Mutex::new(vec![0;width as usize*height as usize*4]),kms:Some(kms) });
|
||||
buffer:Mutex::new(Vec::new()),kms:Some(kms) });
|
||||
}
|
||||
if backend == crate::desktop_backend::DesktopBackend::Portal {
|
||||
let session=std::sync::Arc::new(crate::portal::PortalSession::open()?);
|
||||
let (width,height)=(session.width,session.height);
|
||||
return Ok(Self { backend,init_error:None,portal:Some(session),kms:None,display:"wayland:portal".into(),width,height,
|
||||
buffer:Mutex::new(vec![0;(width as usize)*(height as usize)*4]) });
|
||||
buffer:Mutex::new(Vec::new()) });
|
||||
}
|
||||
if backend == crate::desktop_backend::DesktopBackend::Wayland {
|
||||
let (width,height)=crate::wayland::init()?;
|
||||
return Ok(Self { backend, init_error:None, portal:None, kms:None, display:"wayland:native".into(), width,height,
|
||||
buffer:Mutex::new(vec![0;(width as usize)*(height as usize)*4]) });
|
||||
buffer:Mutex::new(Vec::new()) });
|
||||
}
|
||||
let ret = unsafe { x11_init(std::ptr::null()) };
|
||||
if ret != 0 {
|
||||
@@ -85,8 +98,7 @@ impl ScreenCapture {
|
||||
return Err(format!("Invalid screen dimensions: {}x{}", w, h));
|
||||
}
|
||||
|
||||
let buf_size = (w * h * 4) as usize;
|
||||
let buffer = Mutex::new(vec![0u8; buf_size]);
|
||||
let buffer = Mutex::new(Vec::new());
|
||||
|
||||
log::info!("ScreenCapture initialized: {}x{}", w, h);
|
||||
let display_ptr = unsafe { x11_display_name() };
|
||||
@@ -115,6 +127,7 @@ impl ScreenCapture {
|
||||
pub fn capture_frame(&self) -> Result<Vec<u8>, String> {
|
||||
if let Some(error)=&self.init_error { return Err(error.clone()); }
|
||||
let mut buf = self.buffer.lock().unwrap();
|
||||
buf.resize(self.width as usize * self.height as usize * 4, 0);
|
||||
if let Some(kms)=&self.kms { kms.capture(&mut buf)?; return Ok(buf.clone()); }
|
||||
if let Some(session)=&self.portal { session.capture(&mut buf)?; return Ok(buf.clone()); }
|
||||
if self.backend == crate::desktop_backend::DesktopBackend::Wayland {
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
|
||||
+63
-20
@@ -11,6 +11,8 @@ use ff::ChannelLayout;
|
||||
use ff::util::picture;
|
||||
use ff::{codec, encoder, frame, software::scaling, Dictionary, Packet, Rational};
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::sync::{Semaphore, OwnedSemaphorePermit};
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::damage_capture::DamageCapture;
|
||||
|
||||
@@ -58,13 +60,38 @@ fn ensure_init() -> Result<(), String> {
|
||||
result
|
||||
}
|
||||
|
||||
/// Sends one access unit per encoder packet. Returns `Ok(false)` when the receiver is gone.
|
||||
fn drain(encoder: &mut encoder::Video, packet: &mut Packet, units: &mpsc::Sender<Vec<u8>>) -> Result<bool, String> {
|
||||
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,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod budget_tests {
|
||||
use super::*;
|
||||
#[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());
|
||||
}
|
||||
}
|
||||
|
||||
fn drain(encoder: &mut encoder::Video, packet: &mut Packet, units: &mpsc::Sender<EncodedUnit>, permits: &mut VecDeque<OwnedSemaphorePermit>) -> Result<bool, String> {
|
||||
loop {
|
||||
match encoder.receive_packet(packet) {
|
||||
Ok(()) => {
|
||||
let data = packet.data().unwrap_or_default().to_vec();
|
||||
if units.blocking_send(data).is_err() { return Ok(false); }
|
||||
let permit = permits.pop_front().ok_or("Encoder returned an unbudgeted access unit")?;
|
||||
if units.blocking_send(EncodedUnit {data, permit, completed_at: Instant::now()}).is_err() { return Ok(false); }
|
||||
}
|
||||
Err(ff::Error::Other { errno }) if errno == libc::EAGAIN => return Ok(true),
|
||||
Err(error) => return Err(text(error)),
|
||||
@@ -168,11 +195,11 @@ fn send_video_frame(encoder: &mut encoder::Video, frame: &frame::Video, kind: cr
|
||||
}
|
||||
|
||||
/// Runs until `stop` is set or the receiver is dropped. A set `idr` flag forces the next frame to be an IDR.
|
||||
pub fn run(config: Config, units: mpsc::Sender<Vec<u8>>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>) -> Result<(), String> {
|
||||
pub fn run(config: Config, units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>) -> Result<(), String> {
|
||||
ensure_init()?;
|
||||
if config.damage {
|
||||
match DamageCapture::open(&config.display) {
|
||||
Ok(capture) => return run_damage(config, capture, units, stop, idr),
|
||||
Ok(capture) => return run_damage(config, capture, units, stop, idr, budget),
|
||||
Err(error) => log::warn!("Damage-driven capture unavailable, using x11grab: {error}"),
|
||||
}
|
||||
}
|
||||
@@ -195,14 +222,18 @@ pub fn run(config: Config, units: mpsc::Sender<Vec<u8>>, stop: Arc<AtomicBool>,
|
||||
|
||||
let mut scaler: Option<(scaling::Context, (Pixel, u32, u32))> = None;
|
||||
let mut decoded = frame::Video::empty();
|
||||
let mut converted = frame::Video::new(pixel, width, height);
|
||||
let mut converted = frame::Video::empty();
|
||||
let mut packet = Packet::empty();
|
||||
let started = Instant::now();
|
||||
let frame_interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
|
||||
let mut last_at: Option<Duration> = None;
|
||||
let mut last_slot: i64 = -1;
|
||||
for (stream, input_packet) in input.packets() {
|
||||
let mut permits = VecDeque::with_capacity(4);
|
||||
let mut packets = input.packets();
|
||||
loop {
|
||||
if stop.load(Ordering::Relaxed) { return Ok(()); }
|
||||
let Some(permit) = acquire(&budget, &units) else { return Ok(()); };
|
||||
let Some((stream, input_packet)) = packets.next() else { return Ok(()); };
|
||||
if stream.index() != index { continue; }
|
||||
decoder.send_packet(&input_packet).map_err(text)?;
|
||||
match decoder.receive_frame(&mut decoded) {
|
||||
@@ -236,20 +267,19 @@ pub fn run(config: Config, units: mpsc::Sender<Vec<u8>>, stop: Arc<AtomicBool>,
|
||||
frame.set_pts(Some(slot));
|
||||
frame.set_kind(if idr.swap(false, Ordering::AcqRel) { picture::Type::I } else { picture::Type::None });
|
||||
send_video_frame(&mut encoder, frame, config.encoder)?;
|
||||
if !drain(&mut encoder, &mut packet, &units)? { return Ok(()); }
|
||||
permits.push_back(permit);
|
||||
if !drain(&mut encoder, &mut packet, &units, &mut permits)? { return Ok(()); }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Damage-driven loop. Damage only marks the picture dirty; a dirty picture is captured and encoded on
|
||||
/// the next fixed frame tick, so the stream keeps a steady cadence while the screen moves. The viewer's
|
||||
/// jitter buffer grows with irregular arrivals, and irregular sends were what raised its latency.
|
||||
/// An idle screen sends a keepalive about once a second so the viewer still sees traffic.
|
||||
fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<Vec<u8>>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>) -> Result<(), String> {
|
||||
fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>) -> Result<(), String> {
|
||||
let (mut encoder, pixel, width, height) = open_encoder(&config)?;
|
||||
let (cap_width, cap_height) = capture.size();
|
||||
let mut captured = frame::Video::new(Pixel::BGRZ, cap_width, cap_height);
|
||||
let mut converted = frame::Video::new(pixel, width, height);
|
||||
let mut converted = frame::Video::empty();
|
||||
let mut scaler = None;
|
||||
let mut packet = Packet::empty();
|
||||
let started = Instant::now();
|
||||
@@ -261,6 +291,9 @@ fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<Ve
|
||||
let mut next_tick = Instant::now();
|
||||
let mut last_send = Instant::now();
|
||||
let mut last_slot: i64 = -1;
|
||||
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 };
|
||||
@@ -271,13 +304,20 @@ fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<Ve
|
||||
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 source = capture.capture()?;
|
||||
let bytes_per_line = cap_width as usize * 4;
|
||||
let stride = captured.stride(0);
|
||||
let row = bytes_per_line.min(stride);
|
||||
for (y, src) in source.chunks_exact(bytes_per_line).enumerate() {
|
||||
captured.data_mut(0)[y * stride..y * stride + row].copy_from_slice(&src[..row]);
|
||||
if dirty {
|
||||
let source = capture.capture()?;
|
||||
let bytes_per_line = cap_width as usize * 4;
|
||||
let stride = captured.stride(0);
|
||||
let row = bytes_per_line.min(stride);
|
||||
for (y, src) in source.chunks_exact(bytes_per_line).enumerate() {
|
||||
captured.data_mut(0)[y * stride..y * stride + row].copy_from_slice(&src[..row]);
|
||||
}
|
||||
}
|
||||
|
||||
let slot = ((started.elapsed().as_micros() * u128::from(config.fps) + 500_000) / 1_000_000) as i64;
|
||||
@@ -290,13 +330,16 @@ fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<Ve
|
||||
if scaler.is_none() {
|
||||
scaler = Some(scaling::Context::get(Pixel::BGRZ, cap_width, cap_height, pixel, width, height, scaling::Flags::BILINEAR).map_err(text)?);
|
||||
}
|
||||
if let Some(context) = scaler.as_mut() { context.run(&captured, &mut converted).map_err(text)?; }
|
||||
if dirty {
|
||||
if let Some(context) = scaler.as_mut() { context.run(&captured, &mut converted).map_err(text)?; }
|
||||
}
|
||||
&mut converted
|
||||
};
|
||||
frame.set_pts(Some(slot));
|
||||
frame.set_kind(if idr.swap(false, Ordering::AcqRel) { picture::Type::I } else { picture::Type::None });
|
||||
send_video_frame(&mut encoder, frame, config.encoder)?;
|
||||
if !drain(&mut encoder, &mut packet, &units)? { return Ok(()); }
|
||||
permits.push_back(permit);
|
||||
if !drain(&mut encoder, &mut packet, &units, &mut permits)? { return Ok(()); }
|
||||
let now = Instant::now();
|
||||
if dirty {
|
||||
// Keep the tick phase; after a long idle, restart the phase from now instead of bursting to catch up.
|
||||
|
||||
+4
-1
@@ -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()));
|
||||
|
||||
+25
-8
@@ -1,6 +1,8 @@
|
||||
//! GNOME/KDE portal session. Capture and input must share this Arc; do not
|
||||
//! recreate it in an encoder subprocess (that would request consent again).
|
||||
use std::sync::Arc;
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub struct FrameVersion(usize, u64);
|
||||
#[cfg(unix)]
|
||||
#[path = "portal_permissions.rs"]
|
||||
mod permissions;
|
||||
@@ -17,7 +19,7 @@ mod native {
|
||||
fn uu_portal_close(portal: *mut c_void);
|
||||
fn uu_portal_alive(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_reset_frame(portal: *mut c_void);
|
||||
fn uu_portal_capture(portal: *mut c_void, bgra: *mut u8, length: usize) -> i32;
|
||||
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;
|
||||
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
|
||||
fn uu_portal_key(portal: *mut c_void, keysym: u32, pressed: i32) -> i32;
|
||||
@@ -26,6 +28,10 @@ mod native {
|
||||
// The engine owns callback threads; public calls are serialized by Mutex.
|
||||
unsafe impl Send for Handle {}
|
||||
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
|
||||
fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool {
|
||||
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 }
|
||||
impl Session {
|
||||
pub fn is_alive(&self) -> bool {
|
||||
@@ -56,6 +62,10 @@ mod native {
|
||||
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 })
|
||||
}
|
||||
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 state = *self.locked.borrow();
|
||||
if state != Some(false) {
|
||||
@@ -64,30 +74,30 @@ mod native {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
}
|
||||
super::blank(frame); return Ok(());
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
if self.was_locked.swap(false, std::sync::atomic::Ordering::AcqRel) {
|
||||
// First unlocked capture after a real lock: drop frames captured while locked.
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
super::blank(frame); return Ok(());
|
||||
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);
|
||||
super::blank(frame); return Ok(());
|
||||
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 { super::blank(frame); return Ok(()); }
|
||||
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));
|
||||
super::blank(frame); return Ok(());
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
};
|
||||
*retry = None;
|
||||
@@ -97,8 +107,14 @@ mod native {
|
||||
*handle = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
log::info!("Portal capture session restored after closure");
|
||||
}
|
||||
let code = unsafe { uu_portal_capture(handle.0.as_ptr(), frame.as_mut_ptr(), frame.len()) };
|
||||
if code == 10 || code == 9 { super::blank(frame); Ok(()) } else { super::check(code) }
|
||||
let identity = handle.0.as_ptr() as usize;
|
||||
let mut revision = version.filter(|v| v.0 == identity).map_or(0, |v| v.1);
|
||||
let code = unsafe { uu_portal_capture_since(handle.0.as_ptr(), frame.as_mut_ptr(), frame.len(), &mut revision) };
|
||||
match code {
|
||||
0 | 12 => { *version = Some(super::FrameVersion(identity, revision)); Ok(code == 0) }
|
||||
9 | 10 => Ok(blank_changed(frame, version)),
|
||||
_ => Err(super::error(code)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn clipboard_supported(&self) -> bool {
|
||||
@@ -166,6 +182,7 @@ impl PortalSession {
|
||||
pub fn is_alive(&self) -> bool { 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)) }
|
||||
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(2)) }
|
||||
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(2)) }
|
||||
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(2)) }
|
||||
|
||||
@@ -75,6 +75,66 @@ pub fn decode_wire(input: &[u8]) -> Result<Vec<WireField<'_>>, WireError> {
|
||||
Ok(fields)
|
||||
}
|
||||
|
||||
/// Structure-only rendering for diagnostics: field numbers, wire types, lengths and small
|
||||
/// varints (enums, sizes, fps). String and byte contents are never rendered.
|
||||
pub fn wire_shape(data: &[u8], depth: u8) -> String {
|
||||
let Ok(fields) = decode_wire(data) else { return format!("bytes({})", data.len()) };
|
||||
let parts: Vec<String> = fields.iter().map(|f| match f.value {
|
||||
WireValue::Varint(u64::MAX) => format!("{}=-1", f.number),
|
||||
WireValue::Varint(v) if v <= 0xFFFF => format!("{}={v}", f.number),
|
||||
WireValue::Varint(_) => format!("{}=big", f.number),
|
||||
WireValue::Fixed32(_) => format!("{}:f32", f.number),
|
||||
WireValue::Fixed64(_) => format!("{}:f64", f.number),
|
||||
WireValue::Bytes(b) => format!("{}:{}", f.number, bytes_shape(b, depth)),
|
||||
}).collect();
|
||||
format!("{{{}}}", parts.join(","))
|
||||
}
|
||||
fn bytes_shape(b: &[u8], depth: u8) -> String {
|
||||
let printable = !b.is_empty() && std::str::from_utf8(b).is_ok_and(|t| t.chars().all(|c| !c.is_control()));
|
||||
if printable { return format!("str({})", b.len()); }
|
||||
if depth > 0 && !b.is_empty() && decode_wire(b).is_ok_and(|f| !f.is_empty() && f.iter().all(|x| (1..=128).contains(&x.number))) {
|
||||
return wire_shape(b, depth - 1);
|
||||
}
|
||||
format!("bytes({})", b.len())
|
||||
}
|
||||
|
||||
/// JSON counterpart: keys and value types; strings as lengths (or nested JSON/base64-protobuf
|
||||
/// shape), numbers only when small. Values that could identify a user are never rendered.
|
||||
pub fn json_shape(value: &serde_json::Value, depth: u8) -> String {
|
||||
use base64::Engine;
|
||||
use serde_json::Value;
|
||||
match value {
|
||||
Value::Null => "null".into(),
|
||||
Value::Bool(b) => b.to_string(),
|
||||
Value::Number(n) => match n.as_i64() { Some(v) if v.abs() <= 0xFFFF => v.to_string(), _ => "num".into() },
|
||||
Value::String(t) => {
|
||||
if depth > 0 {
|
||||
if let Ok(inner @ (Value::Object(_) | Value::Array(_))) = serde_json::from_str::<Value>(t) {
|
||||
return format!("json{}", json_shape(&inner, depth - 1));
|
||||
}
|
||||
if t.len() >= 8 && t.len() % 4 == 0 {
|
||||
if let Ok(raw) = base64::engine::general_purpose::STANDARD.decode(t) {
|
||||
if decode_wire(&raw).is_ok_and(|f| !f.is_empty()) { return format!("b64{}", wire_shape(&raw, depth - 1)); }
|
||||
}
|
||||
}
|
||||
}
|
||||
format!("str({})", t.len())
|
||||
}
|
||||
Value::Array(items) => match items.first() {
|
||||
Some(first) if depth > 0 => format!("[{}x{}]", items.len(), json_shape(first, depth - 1)),
|
||||
_ => format!("[{}]", items.len()),
|
||||
},
|
||||
Value::Object(map) if depth > 0 => {
|
||||
let parts: Vec<String> = map.iter().take(48).map(|(k, v)| {
|
||||
let key: String = k.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '_').take(40).collect();
|
||||
format!("{key}:{}", json_shape(v, depth - 1))
|
||||
}).collect();
|
||||
format!("{{{}}}", parts.join(","))
|
||||
}
|
||||
Value::Object(map) => format!("{{{} keys}}", map.len()),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -105,4 +165,20 @@ mod tests {
|
||||
assert_eq!(decode_wire(&[11]), Err(WireError::UnsupportedWireType(3)));
|
||||
assert_eq!(decode_wire(&[255, 255, 255, 255, 31]), Err(WireError::InvalidField));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shapes_never_render_contents() {
|
||||
// {1:1, 2:-1, 4:{1:60,2:2}, 9:"device-secret", 12:big}
|
||||
let mut data = vec![0x08, 0x01, 0x10];
|
||||
data.extend([0xff; 9]); data.push(0x01);
|
||||
data.extend([0x22, 0x04, 0x08, 0x3c, 0x10, 0x02]);
|
||||
data.extend([0x4a, 0x0d]); data.extend(b"device-secret");
|
||||
data.extend([0x60, 0x80, 0x80, 0x80, 0x80, 0x10]);
|
||||
let shape = super::wire_shape(&data, 3);
|
||||
assert_eq!(shape, "{1=1,2=-1,4:{1=60,2=2},9:str(13),12=big}");
|
||||
let header = serde_json::json!({"streamer_data": "{\"token\":\"secret-value\",\"n\":3}", "city": "Somewhere", "id": 123456789});
|
||||
let shape = super::json_shape(&header, 4);
|
||||
assert!(!shape.contains("secret") && !shape.contains("Somewhere") && !shape.contains("123456789"), "{shape}");
|
||||
assert!(shape.contains("streamer_data:json{n:3,token:str(12)}"), "{shape}");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
@@ -317,6 +356,16 @@ impl SignalingClient {
|
||||
let ice_id = ["ice_id", "iceId"].iter().find_map(|k| header.get(*k).or_else(|| header.get("data").and_then(|d| d.get(*k))))
|
||||
.and_then(|v| v.as_str()).map(str::to_owned);
|
||||
log::info!("be-controlled connect request: capture_type={} header_keys={:?} ice_id_present={}", capture_type, keys, ice_id.is_some());
|
||||
// Structure only (numbers, types, lengths): documents what the viewer and cloud send.
|
||||
let header_shape: String = crate::protocol::json_shape(&header, 7).chars().take(8000).collect();
|
||||
log::info!("Connect request shape: app_data={} header={}", crate::protocol::wire_shape(data, 3), header_shape);
|
||||
// Relation only, never the ids themselves.
|
||||
let control_id = header.get("streamer_data").and_then(Value::as_str)
|
||||
.and_then(|t| serde_json::from_str::<Value>(t).ok())
|
||||
.and_then(|v| v.get("control_id").and_then(Value::as_str).map(str::to_owned));
|
||||
let app_control_id = header.get("app_control_id").and_then(Value::as_str);
|
||||
log::info!("Connect request ids: streamer_control_id_equals_app_control_id={:?}",
|
||||
control_id.as_deref().zip(app_control_id).map(|(a, b)| a == b));
|
||||
// ConnectOptions 4 decoder_cap_list: DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265),
|
||||
// 3 width, 4 height, 5 chroma_format (1 4:2:0, 3 4:4:4)}. Numbers only.
|
||||
let caps: Vec<Vec<(u32, u64)>> = fields.iter().flatten().filter(|f| f.number == 4).filter_map(|f| match f.value {
|
||||
|
||||
+25
-15
@@ -75,6 +75,20 @@ struct Session {
|
||||
}
|
||||
|
||||
impl Session {
|
||||
/// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each
|
||||
/// chunk either in the replay or live, never both.
|
||||
fn record_output(&self, data: &[u8]) {
|
||||
let mut sink = self.sink.lock().unwrap();
|
||||
{
|
||||
let mut sb = self.scrollback.lock().unwrap();
|
||||
sb.extend(data);
|
||||
let excess = sb.len().saturating_sub(SCROLLBACK);
|
||||
sb.drain(..excess);
|
||||
}
|
||||
if let Some(tx) = sink.as_ref() {
|
||||
if tx.send(encode(STDOUT, self.id, data)).is_err() { *sink = None; }
|
||||
}
|
||||
}
|
||||
fn emit(&self, kind: u8, payload: &[u8]) -> bool {
|
||||
let mut sink = self.sink.lock().unwrap();
|
||||
if let Some(tx) = sink.as_ref() {
|
||||
@@ -83,8 +97,10 @@ impl Session {
|
||||
}
|
||||
false
|
||||
}
|
||||
// The size lock is held across the ioctl so a delayed restore cannot reapply a stale size.
|
||||
fn resize(&self, cols: u16, rows: u16) {
|
||||
*self.size.lock().unwrap() = (cols, rows);
|
||||
let mut size = self.size.lock().unwrap();
|
||||
*size = (cols, rows);
|
||||
self.set_winsize(cols, rows);
|
||||
}
|
||||
fn set_winsize(&self, cols: u16, rows: u16) {
|
||||
@@ -94,14 +110,16 @@ impl Session {
|
||||
/// Full-screen programs repaint only on SIGWINCH, which an unchanged size never raises:
|
||||
/// shrink by one row, then restore the latest requested size after a pause.
|
||||
fn force_redraw(self: &Arc<Self>) {
|
||||
let (cols, rows) = *self.size.lock().unwrap();
|
||||
if rows <= 1 { return; }
|
||||
self.set_winsize(cols, rows - 1);
|
||||
{
|
||||
let size = self.size.lock().unwrap();
|
||||
if size.1 <= 1 { return; }
|
||||
self.set_winsize(size.0, size.1 - 1);
|
||||
}
|
||||
let s = self.clone();
|
||||
std::thread::spawn(move || {
|
||||
std::thread::sleep(std::time::Duration::from_millis(150));
|
||||
let (cols, rows) = *s.size.lock().unwrap();
|
||||
s.set_winsize(cols, rows);
|
||||
let size = s.size.lock().unwrap();
|
||||
s.set_winsize(size.0, size.1);
|
||||
});
|
||||
}
|
||||
fn write(&self, data: &[u8]) {
|
||||
@@ -163,15 +181,7 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
|
||||
loop {
|
||||
match reader.read(&mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => {
|
||||
{
|
||||
let mut sb = worker.scrollback.lock().unwrap();
|
||||
sb.extend(&buf[..n]);
|
||||
let excess = sb.len().saturating_sub(SCROLLBACK);
|
||||
sb.drain(..excess);
|
||||
}
|
||||
worker.emit(STDOUT, &buf[..n]);
|
||||
}
|
||||
Ok(n) => worker.record_output(&buf[..n]),
|
||||
}
|
||||
}
|
||||
let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
|
||||
|
||||
+127
-62
@@ -3,7 +3,7 @@ use std::sync::atomic::AtomicBool;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::AsyncReadExt;
|
||||
use tokio::process::Command;
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::sync::{mpsc, Semaphore, OwnedSemaphorePermit};
|
||||
use webrtc::media::Sample;
|
||||
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
|
||||
use webrtc::peer_connection::RTCPeerConnection;
|
||||
@@ -66,6 +66,7 @@ struct CompleteFrame {
|
||||
sequence: u64,
|
||||
completed_at: Instant,
|
||||
data: Vec<u8>,
|
||||
_permit: Option<OwnedSemaphorePermit>,
|
||||
}
|
||||
|
||||
const RTP_CLOCK: u64 = 90_000;
|
||||
@@ -269,16 +270,16 @@ impl Drop for StopOnDrop { fn drop(&mut self) { self.0.store(true, std::sync::at
|
||||
async fn read_encoder(
|
||||
size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
|
||||
latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>,
|
||||
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
) -> Result<(), String> {
|
||||
// The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct).
|
||||
let encoder = Encoder::requested();
|
||||
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,sequence,settings,idr).await; }
|
||||
match read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,sequence.clone(),settings,idr.clone()).await {
|
||||
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,sequence,settings,idr,budget).await; }
|
||||
match read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,sequence.clone(),settings,idr.clone(),budget.clone()).await {
|
||||
Ok(())=>Ok(()),
|
||||
Err(error) if !latest.is_closed()=>{
|
||||
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error);
|
||||
read_encoder_with(size,display,portal,latest,Encoder::Cpu,sequence,settings,idr).await
|
||||
read_encoder_with(size,display,portal,latest,Encoder::Cpu,sequence,settings,idr,budget).await
|
||||
},
|
||||
Err(error)=>Err(error),
|
||||
}
|
||||
@@ -288,21 +289,21 @@ async fn read_encoder(
|
||||
#[cfg(feature = "inproc-av")]
|
||||
async fn read_inprocess(
|
||||
config: crate::inproc_encoder::Config, latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>,
|
||||
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
) -> Result<(), String> {
|
||||
let codec = config.codec;
|
||||
let (units_tx, mut units) = mpsc::channel::<Vec<u8>>(4);
|
||||
let (units_tx, mut units) = mpsc::channel::<crate::inproc_encoder::EncodedUnit>(4);
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
// If this future is dropped (reader task aborted), the blocking encoder stops at its next packet.
|
||||
let _stop_on_drop = StopOnDrop(stop.clone());
|
||||
let job = tokio::task::spawn_blocking({
|
||||
let stop = stop.clone();
|
||||
move || crate::inproc_encoder::run(config, units_tx, stop, idr)
|
||||
move || crate::inproc_encoder::run(config, units_tx, stop, idr, budget)
|
||||
});
|
||||
let mut gate = DependencyGate::default();
|
||||
while let Some(data) = units.recv().await {
|
||||
while let Some(unit) = units.recv().await {
|
||||
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { codec, sequence, completed_at: Instant::now(), data }));
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
|
||||
if latest.is_closed() { break; }
|
||||
}
|
||||
// Dropping the receiver also unblocks the encoder if it is waiting to send.
|
||||
@@ -333,10 +334,11 @@ fn rate_args(settings: &VideoSettings, encoder: Encoder) -> (String, String) {
|
||||
|
||||
async fn read_encoder_with(
|
||||
size: (u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,latest:mpsc::Sender<Arc<CompleteFrame>>,encoder:Encoder,sequence:Arc<std::sync::atomic::AtomicU64>,
|
||||
settings: VideoSettings, #[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] idr: Arc<AtomicBool>,
|
||||
settings: VideoSettings, #[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
)->Result<(),String>{
|
||||
let kms=display.starts_with("kms:");
|
||||
let wayland=kms || display.starts_with("wayland:");
|
||||
let (permits_tx,mut permits_rx)=mpsc::channel::<OwnedSemaphorePermit>(4);
|
||||
let kms_capture=if kms {
|
||||
let capture=tokio::task::spawn_blocking(crate::kms::Capture::open).await.map_err(|_|"KMS worker failed")??;
|
||||
if (capture.width,capture.height)!=size { return Err("KMS mode changed; restart host to refresh desktop geometry".into()); }
|
||||
@@ -354,7 +356,7 @@ async fn read_encoder_with(
|
||||
};
|
||||
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} pipeline=in-process",
|
||||
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec));
|
||||
return read_inprocess(config, latest, sequence, idr).await;
|
||||
return read_inprocess(config, latest, sequence, idr, budget).await;
|
||||
}
|
||||
let size = format!("{}x{}", size.0, size.1);
|
||||
let fps = settings.fps.to_string();
|
||||
@@ -386,7 +388,25 @@ 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)
|
||||
.env("UU_WAYLAND_DEMAND","1")
|
||||
.kill_on_drop(true).stdin(std::process::Stdio::piped()).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())
|
||||
@@ -399,11 +419,13 @@ async fn read_encoder_with(
|
||||
use tokio::io::AsyncWriteExt;
|
||||
let mut tick=tokio::time::interval(Duration::from_nanos(1_000_000_000/u64::from(settings.fps)));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
let mut bytes=vec![0;capture.width as usize*capture.height as usize*4];
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let permit=budget.clone().acquire_owned().await.map_err(|_|"Encoder stopped")?;
|
||||
permits_tx.send(permit).await.map_err(|_|"Encoder stopped")?;
|
||||
let capture=capture.clone();
|
||||
let bytes=tokio::task::spawn_blocking(move || {
|
||||
let mut bytes=vec![0;capture.width as usize*capture.height as usize*4];
|
||||
bytes=tokio::task::spawn_blocking(move || {
|
||||
capture.capture(&mut bytes)?; Ok::<_,String>(bytes)
|
||||
}).await.map_err(|_|"KMS worker failed")??;
|
||||
sink.write_all(&bytes).await.map_err(|_|"KMS encoder pipe failed")?;
|
||||
@@ -416,33 +438,42 @@ async fn read_encoder_with(
|
||||
let interval=Duration::from_nanos(1_000_000_000/u64::from(settings.fps));
|
||||
let mut tick=tokio::time::interval(interval);
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
let mut frame=vec![0;(session.width as usize)*(session.height as usize)*4];
|
||||
let mut version=None;
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let permit=budget.clone().acquire_owned().await.map_err(|_|"Encoder stopped")?;
|
||||
permits_tx.send(permit).await.map_err(|_|"Encoder stopped")?;
|
||||
let session=session.clone();
|
||||
let frame=tokio::task::spawn_blocking(move || {
|
||||
let mut frame=vec![0;(session.width as usize)*(session.height as usize)*4];
|
||||
session.capture(&mut frame)?;
|
||||
Ok::<_,String>(frame)
|
||||
(frame,version)=tokio::task::spawn_blocking(move || {
|
||||
session.capture_changed(&mut frame,&mut version)?;
|
||||
Ok::<_,String>((frame,version))
|
||||
}).await.map_err(|e|format!("Portal capture worker: {e}"))??;
|
||||
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 {
|
||||
let mut demand=capture.stdin.take().ok_or("Capture stdin missing")?;
|
||||
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}"))
|
||||
use tokio::io::AsyncWriteExt;
|
||||
tokio::select! {
|
||||
result=async {
|
||||
let mut tick=tokio::time::interval(Duration::from_nanos(1_000_000_000/u64::from(settings.fps)));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop {
|
||||
let permit=budget.clone().acquire_owned().await.map_err(|_|"Encoder stopped")?;
|
||||
tick.tick().await;
|
||||
permits_tx.send(permit).await.map_err(|_|"Encoder stopped")?;
|
||||
demand.write_all(&[1]).await.map_err(|_|"Capture demand pipe closed")?;
|
||||
}
|
||||
} => result,
|
||||
status=capture.wait() => {
|
||||
let status=status.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")?;
|
||||
@@ -461,8 +492,9 @@ async fn read_encoder_with(
|
||||
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
|
||||
let frame: Vec<u8> = pending.drain(..next).collect();
|
||||
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
|
||||
let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None};
|
||||
gate.submit(&latest, Arc::new(CompleteFrame {
|
||||
codec: settings.codec, sequence, completed_at: Instant::now(), data: frame,
|
||||
codec: settings.codec, sequence, completed_at: Instant::now(), data: frame, _permit: permit,
|
||||
}));
|
||||
if latest.is_closed() { return Ok(()); }
|
||||
}
|
||||
@@ -492,7 +524,7 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
|
||||
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let fps=crate::wayland::capture_fps(std::env::var("UU_PROBE_FPS").ok().as_deref())?;
|
||||
let settings=VideoSettings {fps,..VideoSettings::default()};
|
||||
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)))));
|
||||
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)))));
|
||||
let mut count=0;
|
||||
let mut bytes=0;
|
||||
// UU_PROBE_FRAMES lengthens the sample for baseline measurements; default is 5 frames.
|
||||
@@ -520,6 +552,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
}
|
||||
crate::capture::keep_display_awake()?;
|
||||
let (latest, mut receiver) = mpsc::channel(4);
|
||||
let budget=Arc::new(Semaphore::new(4));
|
||||
let sequence = Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let mut current = *settings.borrow_and_update();
|
||||
if !track.supports(current.codec) && track.supports(VideoCodec::H265) {
|
||||
@@ -527,7 +560,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
applied.send_replace(current);
|
||||
settings.borrow_and_update();
|
||||
}
|
||||
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone())));
|
||||
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone())));
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
let mut settings_open = true;
|
||||
@@ -538,39 +571,42 @@ 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();
|
||||
loop {
|
||||
// sent/skipped are cumulative; window_* and max_* cover the interval since the last stats line.
|
||||
let (mut window_frames, mut window_skipped) = (0u64, 0u64);
|
||||
let mut send_interrupted=false;
|
||||
'stream: loop {
|
||||
let next = *settings.borrow_and_update();
|
||||
if next != current || send_interrupted {
|
||||
let discard = next.codec != current.codec || send_interrupted;
|
||||
current = next;
|
||||
timeline.fps = u64::from(next.fps);
|
||||
if discard {
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone()));
|
||||
} else {
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone())).await;
|
||||
}
|
||||
send_interrupted=false;
|
||||
}
|
||||
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");
|
||||
current.codec = VideoCodec::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");
|
||||
applied.send_modify(|value| value.codec = VideoCodec::H264);
|
||||
current = *settings.borrow_and_update();
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone()));
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
|
||||
continue;
|
||||
}
|
||||
return result;
|
||||
},
|
||||
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
|
||||
changed = settings.changed(), if settings_open => {
|
||||
if changed.is_err() { settings_open = false; continue; }
|
||||
// Restart the encoder with the viewer's new 帧率/画质; it begins with an IDR, and frames
|
||||
// still queued from the old encoder remain a valid chain before it.
|
||||
let next = *settings.borrow_and_update();
|
||||
let codec_changed = next.codec != current.codec;
|
||||
current = next;
|
||||
timeline.fps = u64::from(next.fps);
|
||||
if codec_changed {
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
// Drain only after the old producer is gone, before the new IDR can enter.
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone()));
|
||||
} else {
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone())).await;
|
||||
}
|
||||
if changed.is_err() { settings_open = false; }
|
||||
continue;
|
||||
},
|
||||
frame = receiver.recv() => {
|
||||
// A closed queue means the reader ended; its JoinHandle carries the reason.
|
||||
@@ -591,6 +627,10 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
tokio::select! {
|
||||
result = &mut send => { result.map_err(|e| format!("Video send: {e}"))?; break; },
|
||||
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
|
||||
changed = settings.changed(), if settings_open => {
|
||||
if changed.is_err() { settings_open=false; }
|
||||
else if *settings.borrow()!=current { send_interrupted=true; continue 'stream; }
|
||||
},
|
||||
}
|
||||
}
|
||||
previous = Some(frame.sequence);
|
||||
@@ -598,7 +638,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;
|
||||
@@ -619,6 +661,29 @@ mod tests {
|
||||
}
|
||||
}
|
||||
use super::*;
|
||||
#[tokio::test]
|
||||
async fn frame_budget_spans_queued_sending_and_restarted_encoders() {
|
||||
let budget=Arc::new(Semaphore::new(2));
|
||||
let (tx,mut rx)=mpsc::channel(4);
|
||||
let mut gate=DependencyGate::default();
|
||||
for sequence in 1..=2 {
|
||||
let permit=budget.clone().acquire_owned().await.unwrap();
|
||||
gate.submit(&tx,Arc::new(CompleteFrame {codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
|
||||
data:vec![0,0,1,5,42],_permit:Some(permit)}));
|
||||
}
|
||||
let sending=rx.recv().await.unwrap();
|
||||
assert_eq!(budget.available_permits(),0);
|
||||
let restarted=tokio::spawn(budget.clone().acquire_owned());
|
||||
tokio::task::yield_now().await;
|
||||
assert!(!restarted.is_finished());
|
||||
drop(sending);
|
||||
let permit=tokio::time::timeout(Duration::from_secs(1),restarted).await.unwrap().unwrap().unwrap();
|
||||
assert_eq!(budget.available_permits(),0);
|
||||
drop(rx);
|
||||
assert_eq!(budget.available_permits(),1);
|
||||
drop(permit);
|
||||
assert_eq!(budget.available_permits(),2);
|
||||
}
|
||||
#[test]
|
||||
fn x264_buffer_fits_keyframes() {
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 250);
|
||||
@@ -656,7 +721,7 @@ mod tests {
|
||||
let (tx, mut rx) = mpsc::channel(4);
|
||||
let old_tx = tx.clone();
|
||||
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
|
||||
let frame = |sequence, idr| Arc::new(CompleteFrame {
|
||||
let frame = |sequence, idr| Arc::new(CompleteFrame { _permit: None,
|
||||
sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
|
||||
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42],
|
||||
});
|
||||
@@ -751,7 +816,7 @@ mod tests {
|
||||
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
|
||||
let(tx,mut rx)=mpsc::channel(1);
|
||||
let mut gate=DependencyGate::default();
|
||||
let frame=|sequence,idr|Arc::new(CompleteFrame{sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
|
||||
let frame=|sequence,idr|Arc::new(CompleteFrame{_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
|
||||
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
|
||||
gate.submit(&tx,frame(2,true));
|
||||
gate.submit(&tx,frame(3,false)); // queue full: P3 lost
|
||||
@@ -784,7 +849,7 @@ mod tests {
|
||||
async fn hevc_dependency_gate_recovers_only_at_irap_after_overflow() {
|
||||
let (tx, mut rx) = mpsc::channel(1);
|
||||
let mut gate = DependencyGate::default();
|
||||
let frame = |sequence, irap| Arc::new(CompleteFrame { codec: VideoCodec::H265,
|
||||
let frame = |sequence, irap| Arc::new(CompleteFrame { _permit: None, codec: VideoCodec::H265,
|
||||
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] });
|
||||
gate.submit(&tx, frame(1, false));
|
||||
assert!(rx.try_recv().is_err());
|
||||
|
||||
+3
-2
@@ -61,14 +61,15 @@ impl VideoTrack {
|
||||
};
|
||||
let count = payloads.len();
|
||||
let mut complete = count > 0;
|
||||
let timestamp = state.timestamp;
|
||||
state.timestamp = state.timestamp.wrapping_add((sample.duration.as_secs_f64() * 90_000.0) as u32);
|
||||
for (index, payload) in payloads.into_iter().enumerate() {
|
||||
let packet = Packet { header: Header { version: 2, sequence_number: state.sequence, timestamp: state.timestamp,
|
||||
let packet = Packet { header: Header { version: 2, sequence_number: state.sequence, timestamp,
|
||||
marker: index + 1 == count, ..Default::default() }, payload };
|
||||
state.sequence = state.sequence.wrapping_add(1);
|
||||
complete &= track.write_rtp_with_extensions(&packet, extensions).await? > 0;
|
||||
}
|
||||
if complete { self.progress.send_modify(|value| { value.0 += 1; value.1 = codec; }); }
|
||||
state.timestamp = state.timestamp.wrapping_add((sample.duration.as_secs_f64() * 90_000.0) as u32);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
+35
-5
@@ -60,19 +60,49 @@ 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;
|
||||
use std::io::{Read,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}"))?;
|
||||
stdout.flush().map_err(|e|format!("Capture pipe: {e}"))?;
|
||||
if free_tx.send(frame).is_err() { break; }
|
||||
}
|
||||
Ok(())
|
||||
}).map_err(|e|format!("Capture writer: {e}"))?;
|
||||
let demand=std::env::var("UU_WAYLAND_DEMAND").is_ok_and(|v|v=="1");
|
||||
let mut stdin=std::io::stdin().lock();
|
||||
let mut delivered=std::time::Instant::now();
|
||||
loop {
|
||||
if demand { stdin.read_exact(&mut [0]).map_err(|_|"Capture demand pipe closed")?; }
|
||||
// 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();
|
||||
// The engine prefetches the next frame on delivery; after a backpressure stall that
|
||||
// prefetch is as old as the stall, so drop it and capture the current screen.
|
||||
if demand && start.duration_since(delivered)>interval*2 { capture(&mut frame)?; }
|
||||
capture(&mut frame)?;
|
||||
stdout.write_all(&frame).map_err(|e|format!("Capture pipe: {e}"))?;
|
||||
if let Some(left)=interval.checked_sub(start.elapsed()) { std::thread::sleep(left); }
|
||||
delivered=std::time::Instant::now();
|
||||
if full_tx.send(frame).is_err() { break; }
|
||||
if !demand {
|
||||
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> {
|
||||
|
||||
+7
-1
@@ -273,9 +273,15 @@ impl WebRtcSession {
|
||||
let control_video_track = video_track.clone();
|
||||
let stream_settings = video_settings.clone();
|
||||
if desktop {
|
||||
let state_pc = streaming_pc.clone();
|
||||
tokio::spawn(async move {
|
||||
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request).await {
|
||||
log::error!("Live desktop stream stopped: {}", e);
|
||||
// A send racing the viewer's close fails with a misleading track error.
|
||||
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
|
||||
log::info!("Live desktop stream ended: peer connection closed ({})", e);
|
||||
} else {
|
||||
log::error!("Live desktop stream stopped: {}", e);
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
|
||||
Reference in new issue
Block a user